Merge pull request #316 from PikalaxALT/various_documentation

Various documentation

66 files changed, 3462 insertions, 1214 deletions

diff --git a/src/AgbRfu_LinkManager.c b/src/AgbRfu_LinkManager.c
index e4127ee09..35ac45d5f 100644
--- a/src/AgbRfu_LinkManager.c
+++ b/src/AgbRfu_LinkManager.c
@@ -1,6 +1,6 @@
 #include "global.h"
 #include "librfu.h"
-#include "link_rfu.h"
+#include "AgbRfu_LinkManager.h"
 
 #define RN_ACCEPT           0x01
 #define RN_NAME_TIMER_CLEAR 0x02
diff --git a/src/bag.c b/src/bag.c
index 2ca62a3b4..198be971a 100644
--- a/src/bag.c
+++ b/src/bag.c
@@ -1,8 +1,6 @@
 #include "global.h"
-#include "palette.h"
+#include "gflib.h"
 #include "item_menu.h"
-#include "text.h"
-#include "window.h"
 #include "text_window.h"
 #include "menu_helpers.h"
 #include "new_menu_helpers.h"
diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
index a8bc439f4..877fba80a 100644
--- a/src/battle_ai_script_commands.c
+++ b/src/battle_ai_script_commands.c
@@ -4,7 +4,6 @@
 #include "util.h"
 #include "item.h"
 #include "random.h"
-#include "pokemon.h"
 #include "battle_ai_script_commands.h"
 #include "constants/species.h"
 #include "constants/abilities.h"
diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c
index 5d642bda9..e689d2353 100644
--- a/src/battle_ai_switch_items.c
+++ b/src/battle_ai_switch_items.c
@@ -2,7 +2,6 @@
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
-#include "pokemon.h"
 #include "random.h"
 #include "util.h"
 #include "constants/abilities.h"
diff --git a/src/battle_anim.c b/src/battle_anim.c
index 0cb88219a..1132b5725 100644
--- a/src/battle_anim.c
+++ b/src/battle_anim.c
@@ -1,20 +1,13 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_bg.h"
-#include "bg.h"
 #include "decompress.h"
-#include "dma3.h"
-#include "gpu_regs.h"
 #include "graphics.h"
-#include "main.h"
 #include "m4a.h"
-#include "palette.h"
-#include "pokemon.h"
-#include "sound.h"
-#include "sprite.h"
 #include "task.h"
 #include "constants/battle_anim.h"
 
@@ -1970,6 +1963,11 @@ static void ScriptCmd_unloadspritegfx(void)
     ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index));
 }
 
+// Create sprite from template and init data array with varargs
+// args: template, flags, va_args
+// flags:
+//  - bits 0-6: subpriority mod (signed)
+//  - bit 7: target if set else attacker
 static void ScriptCmd_createsprite(void)
 {
     s32 i;
diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c
index 33b5ceacc..d1f75ff8f 100644
--- a/src/battle_anim_effects_1.c
+++ b/src/battle_anim_effects_1.c
@@ -1,10 +1,8 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle_anim.h"
 #include "battle_interface.h"
-#include "gpu_regs.h"
-#include "palette.h"
 #include "random.h"
-#include "sound.h"
 #include "trig.h"
 #include "util.h"
 #include "constants/songs.h"
@@ -4321,7 +4319,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite)
         sprite->data[1] = 0;
     }
 
-    BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB_WHITE);
+    BlendPalettes(SelectBattleAnimSpriteAndBgPalettes(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB_WHITE);
     if (sprite->data[1] == 16)
     {
         int pal;
@@ -4981,7 +4979,7 @@ void AnimTask_FadeScreenBlueStep(u8);
 
 void AnimTask_FadeScreenBlue(u8 taskId)
 {
-    int a = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF;
+    int a = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0) & 0xFFFF;
     int b;
     int c;
     int d;
@@ -4996,7 +4994,7 @@ void AnimTask_FadeScreenBlue(u8 taskId)
     gTasks[taskId].data[7] = 13;
     gTasks[taskId].data[8] = 14;
     gTasks[taskId].data[9] = 15;
-    b = sub_8075CB8(1, 1, 1, 1);
+    b = SelectBattlerSpritePalettes(1, 1, 1, 1);
     c = a | b;
     StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c);
     b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON));
diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c
index 093660389..510b8eabb 100644
--- a/src/battle_anim_effects_2.c
+++ b/src/battle_anim_effects_2.c
@@ -1,15 +1,12 @@
 #include "global.h"
-#include "malloc.h"
+#include "gflib.h"
 #include "battle_anim.h"
 #include "battle_interface.h"
 #include "decompress.h"
-#include "gpu_regs.h"
 #include "graphics.h"
 #include "math_util.h"
-#include "palette.h"
 #include "random.h"
 #include "scanline_effect.h"
-#include "sound.h"
 #include "trig.h"
 #include "util.h"
 #include "constants/songs.h"
@@ -3090,7 +3087,7 @@ static void FakeOutStep2(u8 taskId)
     {
         gTasks[taskId].data[11] = 0x88;
         SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN);
-        BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB_WHITE);
+        BlendPalettes(SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0), 16, RGB_WHITE);
     }
     else if (gTasks[taskId].data[10] > 4)
     {
diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c
index 69bae2c6f..e9bfb2618 100644
--- a/src/battle_anim_effects_3.c
+++ b/src/battle_anim_effects_3.c
@@ -1,19 +1,13 @@
 #include "global.h"
-#include "malloc.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
-#include "bg.h"
 #include "data.h"
 #include "decompress.h"
-#include "dma3.h"
-#include "gpu_regs.h"
 #include "graphics.h"
-#include "palette.h"
 #include "pokemon_icon.h"
 #include "random.h"
 #include "scanline_effect.h"
-#include "sound.h"
-#include "sprite.h"
 #include "task.h"
 #include "trig.h"
 #include "util.h"
diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c
index 7f3516670..8cc6c9a00 100644
--- a/src/battle_anim_mons.c
+++ b/src/battle_anim_mons.c
@@ -1,14 +1,9 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle_anim.h"
-#include "bg.h"
 #include "data.h"
 #include "decompress.h"
-#include "dma3.h"
-#include "gpu_regs.h"
-#include "malloc.h"
-#include "palette.h"
 #include "pokemon_icon.h"
-#include "sprite.h"
 #include "task.h"
 #include "trig.h"
 #include "util.h"
@@ -1240,7 +1235,7 @@ void SetGreyscaleOrOriginalPalette(u16 paletteNum, bool8 restoreOriginalColor)
     }
 }
 
-u32 sub_8075BE8(u8 battleBackground, u8 attacker, u8 target, u8 attackerPartner, u8 targetPartner, u8 a6, u8 a7)
+u32 SelectBattleAnimSpriteAndBgPalettes(bool8 battleBackground, bool8 attacker, bool8 target, bool8 attackerPartner, bool8 targetPartner, bool8 a6, bool8 a7)
 {
     u32 selectedPalettes = 0;
     u32 shift;
@@ -1286,19 +1281,19 @@ u32 sub_8075BE8(u8 battleBackground, u8 attacker, u8 target, u8 attackerPartner,
     return selectedPalettes;
 }
 
-u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4)
+u32 SelectBattlerSpritePalettes(bool8 playerLeft, bool8 playerRight, bool8 foeLeft, bool8 foeRight)
 {
     u32 var = 0;
     u32 shift;
 
-    if (a1)
+    if (playerLeft)
     {
         if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)))
         {
             var |= 1 << (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) + 16);
         }
     }
-    if (a2)
+    if (playerRight)
     {
         if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)))
         {
@@ -1306,7 +1301,7 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4)
             var |= 1 << shift;
         }
     }
-    if (a3)
+    if (foeLeft)
     {
         if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)))
         {
@@ -1314,7 +1309,7 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4)
             var |= 1 << shift;
         }
     }
-    if (a4)
+    if (foeRight)
     {
         if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)))
         {
@@ -1325,13 +1320,13 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4)
     return var;
 }
 
-u8 sub_8075D80(u8 a1)
+u8 GetSpritePalIdxByBattler(u8 a1)
 {
     return a1;
 }
 
 // not used
-static u8 GetBattlerAtPosition_(u8 position)
+static u8 GetSpritePalIdxByPosition(u8 position)
 {
     return GetBattlerAtPosition(position);
 }
diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c
index f2740a1a5..a820667fb 100644
--- a/src/battle_anim_sound_tasks.c
+++ b/src/battle_anim_sound_tasks.c
@@ -1,7 +1,7 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
-#include "sound.h"
 #include "task.h"
 #include "constants/battle_anim.h"
 #include "constants/species.h"
diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c
index 7590c0e58..621ee9039 100644
--- a/src/battle_anim_special.c
+++ b/src/battle_anim_special.c
@@ -1,19 +1,14 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_main.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "decompress.h"
-#include "dma3.h"
-#include "gpu_regs.h"
 #include "graphics.h"
 #include "m4a.h"
-#include "main.h"
-#include "palette.h"
 #include "pokeball.h"
-#include "sound.h"
-#include "sprite.h"
 #include "task.h"
 #include "trig.h"
 #include "util.h"
@@ -666,7 +661,7 @@ void sub_80EF344(u8 taskId)
         priority = gSprites[spriteId].oam.priority;
         subpriority = gSprites[spriteId].subpriority;
         gTasks[taskId].data[10] = LaunchBallStarsTask(x, y + 32, priority, subpriority, ballId);
-        selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
         gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId);
         gTasks[taskId].data[0]++;
         break;
diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c
index 2e7f30ff1..4eb475a5c 100644
--- a/src/battle_anim_status_effects.c
+++ b/src/battle_anim_status_effects.c
@@ -1,10 +1,8 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "decompress.h"
-#include "gpu_regs.h"
-#include "palette.h"
-#include "sprite.h"
 #include "task.h"
 #include "trig.h"
 #include "util.h"
diff --git a/src/battle_anim_utility_funcs.c b/src/battle_anim_utility_funcs.c
index df4a8243b..a1897b94a 100644
--- a/src/battle_anim_utility_funcs.c
+++ b/src/battle_anim_utility_funcs.c
@@ -1,12 +1,8 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
-#include "gpu_regs.h"
 #include "graphics.h"
-#include "malloc.h"
-#include "palette.h"
-#include "sound.h"
-#include "sprite.h"
 #include "task.h"
 #include "util.h"
 #include "constants/songs.h"
@@ -22,9 +18,9 @@ struct AnimStatsChangeData
 
 static void StartBlendAnimSpriteColor(u8 taskId, u32 selectedPalettes);
 static void AnimTask_BlendSpriteColor_Step2(u8 taskId);
-static void sub_80BAB78(u8 taskId);
-static void sub_80BABD0(u8 taskId);
-static void sub_80BACA8(struct Sprite *sprite);
+static void Task_WaitHardwarePaletteFade(u8 taskId);
+static void Task_DoCloneBattlerSpriteWithBlend(u8 taskId);
+static void Task_FinishCloneBattlerSpriteWithBlend(struct Sprite *sprite);
 static void sub_80BAF38(u8 taskId);
 static void sub_80BB0D8(u8 taskId);
 static void sub_80BB2A0(u8 taskId);
@@ -41,18 +37,42 @@ static const u16 gUnknown_83E7CC8[] = { RGB(31, 31, 31) };
 const u8 gUnknown_83E7CCA[] = { REG_OFFSET_BG0CNT, REG_OFFSET_BG1CNT, REG_OFFSET_BG2CNT, REG_OFFSET_BG3CNT };
 const u8 gUnknown_83E7CCE[] = { REG_OFFSET_BG0CNT, REG_OFFSET_BG1CNT, REG_OFFSET_BG2CNT, REG_OFFSET_BG3CNT };
 
-void sub_80BA7F8(u8 taskId)
+// gBattleAnimArgs[0] is a bitfield.
+// Bits 0-10 result in the following palettes being selected:
+//   0: battle background palettes (BG palettes 1, 2, and 3)
+//   1: gBattleAnimAttacker OBJ palette
+//   2: gBattleAnimTarget OBJ palette
+//   3: gBattleAnimAttacker partner OBJ palette
+//   4: gBattleAnimTarget partner OBJ palette
+//   5: BG palette 4
+//   6: BG palette 5
+//   7: Player battler left
+//   8: Player battler right
+//   9: Enemy battler left
+//  10: Enemy battler right
+void AnimTask_BlendSelected(u8 taskId)
 {
     u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
     
-    selectedPalettes |= sub_8075CB8((gBattleAnimArgs[0] >>  7) & 1,
-                                    (gBattleAnimArgs[0] >>  8) & 1,
-                                    (gBattleAnimArgs[0] >>  9) & 1,
-                                    (gBattleAnimArgs[0] >> 10) & 1);
+    selectedPalettes |= SelectBattlerSpritePalettes(
+        (gBattleAnimArgs[0] >>  7) & 1,
+        (gBattleAnimArgs[0] >>  8) & 1,
+        (gBattleAnimArgs[0] >>  9) & 1,
+        (gBattleAnimArgs[0] >> 10) & 1);
     StartBlendAnimSpriteColor(taskId, selectedPalettes);
 }
 
-void sub_80BA83C(u8 taskId)
+// gBattleAnimArgs[0] is a command ID
+// This command will blend bg and battlers except as commanded:
+// 0: Not attacker
+// 1: Not target
+// 2: Not attacker nor bg
+// 3: Not target nor bg
+// 4: Neither attacker nor target
+// 5: Blend all
+// 6: Neither bg nor attacker's partner
+// 7: Neither bg nor target's partner
+void AnimTask_BlendExcept(u8 taskId)
 {
     u8 battler;
     u32 selectedPalettes;
@@ -95,7 +115,7 @@ void sub_80BA83C(u8 taskId)
         if (battler != animBattlers[0] 
          && battler != animBattlers[1]
          && IsBattlerSpriteVisible(battler))
-            selectedPalettes |= 0x10000 << sub_8075D80(battler);
+            selectedPalettes |= 0x10000 << GetSpritePalIdxByBattler(battler);
     }
     StartBlendAnimSpriteColor(taskId, selectedPalettes);
 }
@@ -190,23 +210,23 @@ static void AnimTask_BlendSpriteColor_Step2(u8 taskId)
     }
 }
 
-void sub_80BAB38(u8 taskId)
+void AnimTask_HardwarePaletteFade(u8 taskId)
 {
     BeginHardwarePaletteFade(gBattleAnimArgs[0],
                              gBattleAnimArgs[1],
                              gBattleAnimArgs[2],
                              gBattleAnimArgs[3],
                              gBattleAnimArgs[4]);
-    gTasks[taskId].func = sub_80BAB78;
+    gTasks[taskId].func = Task_WaitHardwarePaletteFade;
 }
 
-static void sub_80BAB78(u8 taskId)
+static void Task_WaitHardwarePaletteFade(u8 taskId)
 {
     if (!gPaletteFade.active)
         DestroyAnimVisualTask(taskId);
 }
 
-void sub_80BAB98(u8 taskId)
+void AnimTask_CloneBattlerSpriteWithBlend(u8 taskId)
 {
     struct Task *task = &gTasks[taskId];
 
@@ -216,9 +236,9 @@ void sub_80BAB98(u8 taskId)
     task->data[3] = gBattleAnimArgs[2];
     task->data[4] = gBattleAnimArgs[3];
     task->data[5] = 0;
-    task->func = sub_80BABD0;
+    task->func = Task_DoCloneBattlerSpriteWithBlend;
 }
-static void sub_80BABD0(u8 taskId)
+static void Task_DoCloneBattlerSpriteWithBlend(u8 taskId)
 {
     struct Task *task = &gTasks[taskId];
 
@@ -237,7 +257,7 @@ static void sub_80BABD0(u8 taskId)
                 gSprites[task->data[6]].data[0] = task->data[3];
                 gSprites[task->data[6]].data[1] = taskId;
                 gSprites[task->data[6]].data[2] = 5;
-                gSprites[task->data[6]].callback = sub_80BACA8;
+                gSprites[task->data[6]].callback = Task_FinishCloneBattlerSpriteWithBlend;
                 ++task->data[5];
             }
             --task->data[4];
@@ -250,7 +270,7 @@ static void sub_80BABD0(u8 taskId)
     }
 }
 
-static void sub_80BACA8(struct Sprite *sprite)
+static void Task_FinishCloneBattlerSpriteWithBlend(struct Sprite *sprite)
 {
     if (sprite->data[0])
     {
@@ -263,7 +283,7 @@ static void sub_80BACA8(struct Sprite *sprite)
     }
 }
 
-void sub_80BACEC(u8 taskId)
+void AnimTask_SetUpCurseBackground(u8 taskId)
 {
     u16 species;
     s32 newSpriteId;
@@ -559,11 +579,11 @@ static void sub_80BB4B8(u8 taskId)
 
 void sub_80BB660(u8 taskId)
 {
-    u32 selectedPalettes = sub_8075CB8(1, 1, 1, 1);
+    u32 selectedPalettes = SelectBattlerSpritePalettes(1, 1, 1, 1);
 
     sub_80BB790(selectedPalettes, 0);
     gTasks[taskId].data[14] = selectedPalettes >> 16;
-    selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF;
+    selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0) & 0xFFFF;
     sub_80BB790(selectedPalettes, 0xFFFF);
     gTasks[taskId].data[15] = selectedPalettes;
     gTasks[taskId].data[0] = 0;
@@ -835,7 +855,7 @@ void sub_80BBE6C(u8 taskId)
     s32 paletteIndex = 0;
 
     if (gBattleAnimArgs[0] == 0)
-        for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
              (selectedPalettes & 1) == 0;
              ++paletteIndex)
             selectedPalettes >>= 1;
@@ -853,7 +873,7 @@ void sub_80BBF08(u8 taskId)
     s32 paletteIndex = 0;
 
     if (gBattleAnimArgs[0] == 0)
-        for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
              (selectedPalettes & 1) == 0;
              ++paletteIndex)
             selectedPalettes >>= 1;
@@ -871,7 +891,7 @@ void sub_80BBFA4(u8 taskId)
     s32 paletteIndex = 0;
 
     if (gBattleAnimArgs[0] == 0)
-        for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
              (selectedPalettes & 1) == 0;
              ++paletteIndex)
             selectedPalettes >>= 1;
diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c
index a80e79bf4..90080b88e 100644
--- a/src/battle_controller_link_opponent.c
+++ b/src/battle_controller_link_opponent.c
@@ -1,14 +1,10 @@
 #include "global.h"
+#include "gflib.h"
 #include "data.h"
 #include "link.h"
 #include "m4a.h"
-#include "palette.h"
 #include "pokeball.h"
-#include "pokemon.h"
-#include "sound.h"
-#include "string_util.h"
 #include "task.h"
-#include "text.h"
 #include "util.h"
 #include "battle.h"
 #include "battle_anim.h"
diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c
index 5ac4f1abc..fdac017c8 100644
--- a/src/battle_controller_link_partner.c
+++ b/src/battle_controller_link_partner.c
@@ -1,13 +1,9 @@
 #include "global.h"
+#include "gflib.h"
 #include "data.h"
 #include "link.h"
-#include "palette.h"
 #include "pokeball.h"
-#include "pokemon.h"
-#include "sound.h"
-#include "string_util.h"
 #include "task.h"
-#include "text.h"
 #include "util.h"
 #include "battle.h"
 #include "battle_anim.h"
diff --git a/src/battle_controller_oak_old_man.c b/src/battle_controller_oak_old_man.c
index 0807018a2..97a167fe3 100644
--- a/src/battle_controller_oak_old_man.c
+++ b/src/battle_controller_oak_old_man.c
@@ -1,21 +1,14 @@
 #include "global.h"
+#include "gflib.h"
 #include "task.h"
-#include "pokemon.h"
 #include "pokeball.h"
 #include "party_menu.h"
-#include "bg.h"
-#include "data.h"
-#include "palette.h"
 #include "util.h"
 #include "m4a.h"
 #include "link.h"
-#include "sound.h"
 #include "item.h"
 #include "item_menu.h"
-#include "text.h"
 #include "strings.h"
-#include "string_util.h"
-#include "window.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
index 26e35ae65..b7522c0de 100644
--- a/src/battle_controller_opponent.c
+++ b/src/battle_controller_opponent.c
@@ -1,15 +1,11 @@
 #include "global.h"
+#include "gflib.h"
 #include "data.h"
-#include "main.h"
 #include "m4a.h"
 #include "task.h"
-#include "text.h"
 #include "util.h"
 #include "pokeball.h"
-#include "pokemon.h"
 #include "random.h"
-#include "sound.h"
-#include "string_util.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
index b28249a97..97e833ffd 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -1,23 +1,16 @@
 #include "global.h"
-#include "bg.h"
+#include "gflib.h"
 #include "data.h"
 #include "item.h"
 #include "item_menu.h"
 #include "link.h"
-#include "main.h"
 #include "m4a.h"
-#include "palette.h"
 #include "party_menu.h"
 #include "pokeball.h"
-#include "pokemon.h"
-#include "sound.h"
 #include "strings.h"
-#include "string_util.h"
 #include "pokemon_special_anim.h"
 #include "task.h"
-#include "text.h"
 #include "util.h"
-#include "window.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c
index a6b3fe994..2489c2d95 100644
--- a/src/battle_controller_pokedude.c
+++ b/src/battle_controller_pokedude.c
@@ -1,21 +1,15 @@
 #include "global.h"
+#include "gflib.h"
 #include "task.h"
-#include "pokemon.h"
 #include "party_menu.h"
 #include "pokeball.h"
-#include "bg.h"
 #include "data.h"
-#include "palette.h"
 #include "util.h"
 #include "m4a.h"
 #include "link.h"
-#include "sound.h"
 #include "event_data.h"
 #include "item_menu.h"
-#include "text.h"
 #include "strings.h"
-#include "string_util.h"
-#include "window.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 28ed4091e..e15d76deb 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -1,19 +1,15 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
-#include "bg.h"
 #include "data.h"
 #include "item_menu.h"
 #include "link.h"
 #include "main.h"
-#include "palette.h"
 #include "pokeball.h"
-#include "pokemon.h"
-#include "sound.h"
-#include "text.h"
 #include "util.h"
 #include "strings.h"
 #include "constants/songs.h"
diff --git a/src/battle_controllers.c b/src/battle_controllers.c
index 834b9e6b6..d06d09012 100644
--- a/src/battle_controllers.c
+++ b/src/battle_controllers.c
@@ -10,7 +10,6 @@
 #include "link_rfu.h"
 #include "cable_club.h"
 #include "party_menu.h"
-#include "pokemon.h"
 #include "task.h"
 #include "util.h"
 #include "constants/abilities.h"
diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c
index 127b0903b..45188d022 100644
--- a/src/battle_gfx_sfx_util.c
+++ b/src/battle_gfx_sfx_util.c
@@ -1,10 +1,8 @@
 #include "global.h"
-#include "main.h"
+#include "gflib.h"
 #include "m4a.h"
 #include "task.h"
-#include "malloc.h"
 #include "graphics.h"
-#include "sound.h"
 #include "decompress.h"
 #include "palette.h"
 #include "sprite.h"
diff --git a/src/battle_interface.c b/src/battle_interface.c
index e5145adc0..107999045 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -1,19 +1,14 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle_anim.h"
 #include "battle_interface.h"
 #include "battle_message.h"
 #include "decompress.h"
-#include "gpu_regs.h"
 #include "graphics.h"
 #include "menu.h"
-#include "palette.h"
 #include "pokedex.h"
 #include "pokemon_summary_screen.h"
 #include "safari_zone.h"
-#include "sound.h"
-#include "string_util.h"
-#include "text.h"
-#include "window.h"
 #include "constants/songs.h"
 
 #define GetStringRightAlignXOffset(fontId, string, destWidth) ({ \
diff --git a/src/battle_intro.c b/src/battle_intro.c
index 93141f2ca..25fdbafda 100644
--- a/src/battle_intro.c
+++ b/src/battle_intro.c
@@ -1,10 +1,8 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_setup.h"
-#include "bg.h"
-#include "gpu_regs.h"
-#include "main.h"
 #include "scanline_effect.h"
 #include "task.h"
 #include "trig.h"
diff --git a/src/battle_main.c b/src/battle_main.c
index bbfcf5cf9..d2735086f 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_ai_script_commands.h"
@@ -10,40 +11,29 @@
 #include "battle_setup.h"
 #include "battle_string_ids.h"
 #include "berry.h"
-#include "bg.h"
 #include "data.h"
 #include "decompress.h"
 #include "event_data.h"
 #include "evolution_scene.h"
 #include "graphics.h"
-#include "gpu_regs.h"
 #include "help_system.h"
 #include "item.h"
 #include "link.h"
 #include "link_rfu.h"
 #include "load_save.h"
-#include "main.h"
-#include "malloc.h"
 #include "m4a.h"
-#include "palette.h"
 #include "party_menu.h"
 #include "pokeball.h"
 #include "pokedex.h"
-#include "pokemon.h"
 #include "quest_log.h"
 #include "random.h"
 #include "roamer.h"
 #include "safari_zone.h"
 #include "scanline_effect.h"
-#include "sound.h"
-#include "sprite.h"
-#include "string_util.h"
 #include "task.h"
-#include "text.h"
 #include "trig.h"
 #include "vs_seeker.h"
 #include "util.h"
-#include "window.h"
 #include "constants/abilities.h"
 #include "constants/battle_move_effects.h"
 #include "constants/battle_setup.h"
diff --git a/src/battle_message.c b/src/battle_message.c
index 7ca47e6fb..e17d3241b 100644
--- a/src/battle_message.c
+++ b/src/battle_message.c
@@ -1,11 +1,8 @@
 #include "global.h"
+#include "gflib.h"
 #include "battle_string_ids.h"
 #include "battle.h"
-#include "palette.h"
 #include "battle_anim.h"
-#include "string_util.h"
-#include "text.h"
-#include "window.h"
 #include "strings.h"
 #include "battle_message.h"
 #include "link.h"
diff --git a/src/battle_records.c b/src/battle_records.c
index 3196d9bad..7d9ddffe4 100644
--- a/src/battle_records.c
+++ b/src/battle_records.c
@@ -1,20 +1,12 @@
 #include "global.h"
-#include "malloc.h"
-#include "main.h"
-#include "bg.h"
-#include "gpu_regs.h"
+#include "gflib.h"
 #include "event_data.h"
-#include "palette.h"
 #include "task.h"
-#include "text.h"
-#include "window.h"
 #include "text_window.h"
 #include "battle.h"
 #include "trainer_tower.h"
 #include "trainer_pokemon_sprites.h"
 #include "scanline_effect.h"
-#include "sound.h"
-#include "string_util.h"
 #include "link.h"
 #include "menu.h"
 #include "overworld.h"
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index 225a47729..ceccdac87 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -1,17 +1,10 @@
 #include "global.h"
+#include "gflib.h"
 #include "item.h"
 #include "util.h"
-#include "pokemon.h"
 #include "random.h"
-#include "text.h"
-#include "sound.h"
 #include "pokedex.h"
-#include "window.h"
-#include "main.h"
-#include "palette.h"
 #include "money.h"
-#include "bg.h"
-#include "string_util.h"
 #include "pokemon_icon.h"
 #include "mail.h"
 #include "event_data.h"
diff --git a/src/battle_setup.c b/src/battle_setup.c
index df8a3ac45..ee923d6c7 100644
--- a/src/battle_setup.c
+++ b/src/battle_setup.c
@@ -235,7 +235,7 @@ static void DoStandardWildBattle(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
-    sub_805C780();
+    StopPlayerAvatar();
     gMain.savedCallback = CB2_EndWildBattle;
     gBattleTypeFlags = 0;
     CreateBattleStartTask(GetWildBattleTransition(), 0);
@@ -247,7 +247,7 @@ void StartRoamerBattle(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
-    sub_805C780();
+    StopPlayerAvatar();
     gMain.savedCallback = CB2_EndWildBattle;
     gBattleTypeFlags = BATTLE_TYPE_ROAMER;
     CreateBattleStartTask(GetWildBattleTransition(), MUS_VS_DEN);
@@ -259,7 +259,7 @@ static void DoSafariBattle(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
-    sub_805C780();
+    StopPlayerAvatar();
     gMain.savedCallback = CB2_EndSafariBattle;
     gBattleTypeFlags = BATTLE_TYPE_SAFARI;
     CreateBattleStartTask(GetWildBattleTransition(), 0);
@@ -269,7 +269,7 @@ static void DoGhostBattle(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
-    sub_805C780();
+    StopPlayerAvatar();
     gMain.savedCallback = CB2_EndWildBattle;
     gBattleTypeFlags = BATTLE_TYPE_GHOST;
     CreateBattleStartTask(GetWildBattleTransition(), 0);
@@ -399,7 +399,7 @@ static void sub_807FB08(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
-    sub_805C780();
+    StopPlayerAvatar();
     gMain.savedCallback = sub_807FAF8;
     SavePlayerParty();
     InitPokedudePartyAndOpponent();
diff --git a/src/berry_pouch.c b/src/berry_pouch.c
index 01a94c075..9798dd441 100644
--- a/src/berry_pouch.c
+++ b/src/berry_pouch.c
@@ -457,7 +457,7 @@ static void CB2_InitBerryPouch(void)
 {
     while (1)
     {
-        if ((u8)sub_80BF72C() == TRUE)
+        if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
             break;
         if (RunBerryPouchInit() == TRUE)
             break;
@@ -934,7 +934,7 @@ static void Task_BerryPouchMain(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
     s32 menuInput;
-    if (!gPaletteFade.active && (u8)sub_80BF72C() != TRUE)
+    if (!gPaletteFade.active && (u8)MenuHelpers_CallLinkSomething() != TRUE)
     {
         menuInput = ListMenu_ProcessInput(data[0]);
         ListMenuGetScrollAndRow(data[0], &sStaticCnt.listMenuScrollOffset, &sStaticCnt.listMenuSelectedRow);
@@ -1040,7 +1040,7 @@ static void Task_NormalContextMenu(u8 taskId)
 static void Task_NormalContextMenu_HandleInput(u8 taskId)
 {
     s8 input;
-    if ((u8)sub_80BF72C() != TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() != TRUE)
     {
         input = Menu_ProcessInputNoWrapAround();
         switch (input)
diff --git a/src/bike.c b/src/bike.c
index eaa4af2bd..d08a5fe82 100644
--- a/src/bike.c
+++ b/src/bike.c
@@ -9,67 +9,67 @@
 #include "constants/map_types.h"
 #include "constants/songs.h"
 
-static u8 sub_80BD0D4(u8 *, u16, u16);
+static u8 GetMovePlayerOnBikeFuncId(u8 *, u16, u16);
 static void sub_80BD664(void);
-static u8 sub_80BD4F0(u8, u8);
-static u8 sub_80BD3A0(u8);
-static u8 sub_80BD40C(struct ObjectEvent *, s16, s16, u8, u8);
-static bool8 sub_80BD4B8(u8);
-static void sub_80BD27C(u8);
-static void sub_80BD28C(u8);
-static void sub_80BD2C8(u8);
-static void sub_80BD358(u8);
-static void sub_80BD380(u8);
-static u8 sub_80BD100(u8 *, u16, u16);
-static u8 sub_80BD1C8(u8 *, u16, u16);
-static u8 sub_80BD1E8(u8 *, u16, u16);
-
-static void (*const gUnknown_83E7CFC[])(u8) =
+static u8 BikeCanFaceDIrectionOnRail(u8, u8);
+static u8 CheckNextTileForBikingCollision(u8);
+static u8 AdjustCollisionForBiking(struct ObjectEvent *, s16, s16, u8, u8);
+static bool8 MetatileBehaviorForbidsBiking(u8);
+static void BikeFaceDirection(u8);
+static void BikeFaceDirectionAccountForRail(u8);
+static void BikeTryMoveFastInDirection(u8);
+static void BikeLetGravityTakeTheWheel(u8);
+static void BikeTryMoveInDirection(u8);
+static u8 GetBikeMoveCmd_0(u8 *, u16, u16);
+static u8 GetBikeMoveCmd_1(u8 *, u16, u16);
+static u8 GetBikeMoveCmd_2(u8 *, u16, u16);
+
+static void (*const sMovePlayerOnBikeFuncs[])(u8) =
 {
-    sub_80BD27C,
-    sub_80BD28C,
-    sub_80BD2C8,
-    sub_80BD358,
-    sub_80BD380,
+    BikeFaceDirection,
+    BikeFaceDirectionAccountForRail,
+    BikeTryMoveFastInDirection,
+    BikeLetGravityTakeTheWheel,
+    BikeTryMoveInDirection,
 };
 
-static u8 (*const gUnknown_83E7D10[])(u8 *, u16, u16) =
+static u8 (*const sGetMovePlayerOnBikeFuncIdFuncs[])(u8 *, u16, u16) =
 {
-    sub_80BD100,
-    sub_80BD1C8,
-    sub_80BD1E8,
+    GetBikeMoveCmd_0,
+    GetBikeMoveCmd_1,
+    GetBikeMoveCmd_2,
 };
 
 void MovePlayerOnBike(u8 direction, u16 newKeys, u16 heldKeys)
 {
-    gUnknown_83E7CFC[sub_80BD0D4(&direction, newKeys, heldKeys)](direction);
+    sMovePlayerOnBikeFuncs[GetMovePlayerOnBikeFuncId(&direction, newKeys, heldKeys)](direction);
 }
 
-static u8 sub_80BD0D4(u8 *direction, u16 newKeys, u16 heldKeys)
+static u8 GetMovePlayerOnBikeFuncId(u8 *direction, u16 newKeys, u16 heldKeys)
 {
-    return gUnknown_83E7D10[gPlayerAvatar.acroBikeState](direction, newKeys, heldKeys);
+    return sGetMovePlayerOnBikeFuncIdFuncs[gPlayerAvatar.acroBikeState](direction, newKeys, heldKeys);
 }
 
-static u8 sub_80BD100(u8 *r6, u16 sl, u16 sb)
+static u8 GetBikeMoveCmd_0(u8 *direction_p, u16 newKeys, u16 heldKeys)
 {
-    struct ObjectEvent *r4 = &gObjectEvents[gPlayerAvatar.objectEventId];
-    u8 r7 = GetPlayerMovementDirection();
+    struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    u8 direction = GetPlayerMovementDirection();
 
     gPlayerAvatar.bikeFrameCounter = 0;
-    if (MetatileBehavior_IsCyclingRoadPullDownTile(r4->currentMetatileBehavior) == TRUE)
+    if (MetatileBehavior_IsCyclingRoadPullDownTile(playerObjEvent->currentMetatileBehavior) == TRUE)
     {
         if (!JOY_HELD(B_BUTTON))
         {
             gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING;
             gPlayerAvatar.runningState = 2;
-            if (*r6 < 2)
+            if (*direction_p < DIR_NORTH)
                 return 3;
             else
                 return 4;
         }
         else
         {
-            if (*r6 != 0)
+            if (*direction_p != DIR_NONE)
             {
                 gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING;
                 gPlayerAvatar.runningState = 2;
@@ -83,21 +83,21 @@ static u8 sub_80BD100(u8 *r6, u16 sl, u16 sb)
     }
     else
     {
-        if (*r6 == 0)
+        if (*direction_p == DIR_NONE)
         {
         _080BD17E:
-            *r6 = r7;
+            *direction_p = direction;
             gPlayerAvatar.runningState = 0;
             return 0;
         }
         else
         {
-            if (*r6 != r7 && gPlayerAvatar.runningState != 2)
+            if (*direction_p != direction && gPlayerAvatar.runningState != 2)
             {
                 gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING;
-                gPlayerAvatar.newDirBackup = *r6;
+                gPlayerAvatar.newDirBackup = *direction_p;
                 gPlayerAvatar.runningState = 0;
-                return sub_80BD0D4(r6, sl, sb);
+                return GetMovePlayerOnBikeFuncId(direction_p, newKeys, heldKeys);
             }
             else
             {
@@ -108,33 +108,33 @@ static u8 sub_80BD100(u8 *r6, u16 sl, u16 sb)
     }
 }
 
-static u8 sub_80BD1C8(u8 *r0, UNUSED u16 r1, UNUSED u16 r2)
+static u8 GetBikeMoveCmd_1(u8 *direction_p, UNUSED u16 newKeys, UNUSED u16 heldKeys)
 {
-    *r0 = gPlayerAvatar.newDirBackup;
+    *direction_p = gPlayerAvatar.newDirBackup;
     gPlayerAvatar.runningState = 1;
     gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL;
     sub_80BD664();
     return 1;
 }
 
-static u8 sub_80BD1E8(u8 *r6, u16 sb, u16 r8)
+static u8 GetBikeMoveCmd_2(u8 *direction_p, u16 newKeys, u16 heldKeys)
 {
-    u8 r5 = GetPlayerMovementDirection();
-    u8 r1 = gPlayerAvatar.objectEventId;
-    if (MetatileBehavior_IsCyclingRoadPullDownTile(r1[gObjectEvents].currentMetatileBehavior) == TRUE)
+    u8 direction = GetPlayerMovementDirection();
+    u8 playerObjEventId = gPlayerAvatar.objectEventId;
+    if (MetatileBehavior_IsCyclingRoadPullDownTile(playerObjEventId[gObjectEvents].currentMetatileBehavior) == TRUE)
     {
-        if (*r6 != r5)
+        if (*direction_p != direction)
         {
             gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING;
-            gPlayerAvatar.newDirBackup = *r6;
+            gPlayerAvatar.newDirBackup = *direction_p;
             gPlayerAvatar.runningState = 0;
-            return sub_80BD0D4(r6, sb, r8);
+            return GetMovePlayerOnBikeFuncId(direction_p, newKeys, heldKeys);
         }
         else
         {
             gPlayerAvatar.runningState = 2;
             gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING;
-            if (*r6 < 2)
+            if (*direction_p < DIR_NORTH)
                 return 3;
             else
                 return 4;
@@ -143,9 +143,9 @@ static u8 sub_80BD1E8(u8 *r6, u16 sb, u16 r8)
     else
     {
         gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL;
-        if (*r6 == 0)
+        if (*direction_p == DIR_NONE)
         {
-            *r6 = r5;
+            *direction_p = direction;
             gPlayerAvatar.runningState = 0;
             return 0;
         }
@@ -157,100 +157,100 @@ static u8 sub_80BD1E8(u8 *r6, u16 sb, u16 r8)
     }
 }
 
-static void sub_80BD27C(u8 r0)
+static void BikeFaceDirection(u8 direction)
 {
-    PlayerFaceDirection(r0);
+    PlayerFaceDirection(direction);
 }
 
-static void sub_80BD28C(u8 r4)
+static void BikeFaceDirectionAccountForRail(u8 direction)
 {
-    struct ObjectEvent *r5 = &gObjectEvents[gPlayerAvatar.objectEventId];
+    struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
 
-    if (!sub_80BD4F0(r4, r5->currentMetatileBehavior))
-        r4 = r5->movementDirection;
-    PlayerFaceDirection(r4);
+    if (!BikeCanFaceDIrectionOnRail(direction, playerObjEvent->currentMetatileBehavior))
+        direction = playerObjEvent->movementDirection;
+    PlayerFaceDirection(direction);
 }
 
-static void sub_80BD2C8(u8 r4)
+static void BikeTryMoveFastInDirection(u8 direction)
 {
-    struct ObjectEvent *r5;
+    struct ObjectEvent *playerObjEvent;
     
-    r5 = &gObjectEvents[gPlayerAvatar.objectEventId];
-    if (!sub_80BD4F0(r4, r5->currentMetatileBehavior))
+    playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!BikeCanFaceDIrectionOnRail(direction, playerObjEvent->currentMetatileBehavior))
     {
-        sub_80BD27C(r5->movementDirection);
+        BikeFaceDirection(playerObjEvent->movementDirection);
     }
     else
     {
-        u8 r1 = sub_80BD3A0(r4);
+        u8 collision = CheckNextTileForBikingCollision(direction);
 
-        if (r1 > 0 && r1 <= 11)
+        if (collision > COLLISION_NONE && collision <= COLLISION_ISOLATED_HORIZONTAL_RAIL)
         {
-            if (r1 == 6)
-                PlayerJumpLedge(r4);
-            else if (r1 != 5 && r1 != 6 && r1 != 7 && r1 != 8)
-                PlayerOnBikeCollide(r4);
+            if (collision == COLLISION_LEDGE_JUMP)
+                PlayerJumpLedge(direction);
+            else if (collision != COLLISION_STOP_SURFING && collision != COLLISION_LEDGE_JUMP && collision != COLLISION_PUSHED_BOULDER && collision != COLLISION_UNKNOWN_WARP_6C_6D_6E_6F)
+                PlayerOnBikeCollide(direction);
         }
         else
         {
             
-            if (r1 == 14)
-                PlayerGoSpeed2(r4);
-            else if (PlayerIsMovingOnRockStairs(r4))
-                PlayerGoSpeed2(r4);
+            if (collision == COLLISION_COUNT)
+                PlayerGoSpeed2(direction);
+            else if (PlayerIsMovingOnRockStairs(direction))
+                PlayerGoSpeed2(direction);
             else
-                PlayerRideWaterCurrent(r4);
+                PlayerRideWaterCurrent(direction);
         }
     }
 }
 
-static void sub_80BD358(UNUSED u8 v)
+static void BikeLetGravityTakeTheWheel(UNUSED u8 v)
 {
-    u8 r0 = sub_80BD3A0(1);
+    u8 collision = CheckNextTileForBikingCollision(DIR_SOUTH);
 
-    if (r0 == 0)
-        sub_805C164(1);
-    else if (r0 == 6)
-        PlayerJumpLedge(1);
+    if (collision == COLLISION_NONE)
+        sub_805C164(DIR_SOUTH);
+    else if (collision == COLLISION_LEDGE_JUMP)
+        PlayerJumpLedge(DIR_SOUTH);
 }
 
-static void sub_80BD380(u8 r4)
+static void BikeTryMoveInDirection(u8 direction)
 {
-    if (sub_80BD3A0(r4) == 0)
-        PlayerGoSpeed1(r4);
+    if (CheckNextTileForBikingCollision(direction) == COLLISION_NONE)
+        PlayerGoSpeed1(direction);
 }
 
-static u8 sub_80BD3A0(u8 r6)
+static u8 CheckNextTileForBikingCollision(u8 direction)
 {
-    struct ObjectEvent *r4 = &gObjectEvents[gPlayerAvatar.objectEventId];
-    s16 sp04, sp06;
-    u8 r0;
-
-    sp04 = r4->currentCoords.x;
-    sp06 = r4->currentCoords.y;
-    MoveCoords(r6, &sp04, &sp06);
-    r0 = MapGridGetMetatileBehaviorAt(sp04, sp06);
-    return sub_80BD40C(r4, sp04, sp06, r6, r0);
+    struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    s16 x, y;
+    u8 metatileBehavior;
+
+    x = playerObjEvent->currentCoords.x;
+    y = playerObjEvent->currentCoords.y;
+    MoveCoords(direction, &x, &y);
+    metatileBehavior = MapGridGetMetatileBehaviorAt(x, y);
+    return AdjustCollisionForBiking(playerObjEvent, x, y, direction, metatileBehavior);
 }
 
-static u8 sub_80BD40C(struct ObjectEvent *r0, s16 r1, s16 r2, u8 r3, u8 r5)
+static u8 AdjustCollisionForBiking(struct ObjectEvent *playerObjEvent, s16 x, s16 y, u8 direction, u8 metatileBehavior)
 {
-    u8 r4 = CheckForObjectEventCollision(r0, r1, r2, r3, r5);
+    u8 retVal = CheckForObjectEventCollision(playerObjEvent, x, y, direction, metatileBehavior);
 
-    if (r4 <= 4)
+    if (retVal <= COLLISION_OBJECT_EVENT)
     {
-        u8 r0 = MetatileBehavior_IsCrackedIce(r5);
-        if (r0 == TRUE)
-            return 14;
-        if (r4 == 0 && sub_80BD4B8(r5))
-            r4 = 2;
+        bool8 isCrackedIce = MetatileBehavior_IsCrackedIce(metatileBehavior);
+        if (isCrackedIce == TRUE)
+            return COLLISION_COUNT;
+        if (retVal == COLLISION_NONE && MetatileBehaviorForbidsBiking(metatileBehavior))
+            retVal = COLLISION_IMPASSABLE;
     }
-    return r4;
+    return retVal;
 }
 
 bool8 sub_80BD460(u8 r0)
 {
-    if (sub_80BD4B8(r0))
+    if (MetatileBehaviorForbidsBiking(r0))
         return TRUE;
     if (gMapHeader.mapType != MAP_TYPE_INDOOR)
         return FALSE;
@@ -262,13 +262,13 @@ bool32 IsRunningDisallowed(u8 metatileBehavior)
 {
     if (!(gMapHeader.flags & MAP_ALLOW_RUN))
         return TRUE;
-    if (sub_80BD4B8(metatileBehavior) != TRUE)
+    if (MetatileBehaviorForbidsBiking(metatileBehavior) != TRUE)
         return FALSE;
     else
         return TRUE;
 }
 
-static bool8 sub_80BD4B8(u8 r4)
+static bool8 MetatileBehaviorForbidsBiking(u8 r4)
 {
     if (MetatileBehavior_IsMB0A(r4))
         return TRUE;
@@ -279,31 +279,31 @@ static bool8 sub_80BD4B8(u8 r4)
     return TRUE;
 }
 
-static bool8 sub_80BD4F0(u8 r0, u8 r4)
+static bool8 BikeCanFaceDIrectionOnRail(u8 direction, u8 metatileBehavior)
 {
-    if (r0 == DIR_EAST || r0 == DIR_WEST)
+    if (direction == DIR_EAST || direction == DIR_WEST)
     {
-        if (MetatileBehavior_IsIsolatedVerticalRail(r4) || MetatileBehavior_IsVerticalRail(r4))
+        if (MetatileBehavior_IsIsolatedVerticalRail(metatileBehavior) || MetatileBehavior_IsVerticalRail(metatileBehavior))
             return FALSE;
     }
     else
     {
-        if (MetatileBehavior_IsIsolatedHorizontalRail(r4) || MetatileBehavior_IsHorizontalRail(r4))
+        if (MetatileBehavior_IsIsolatedHorizontalRail(metatileBehavior) || MetatileBehavior_IsHorizontalRail(metatileBehavior))
             return FALSE;
     }
     return TRUE;
 }
 
-bool8 sub_80BD540(void)
+bool8 MetatileAtPlayerPositionForbidsBiking(void)
 {
-    s16 sp00, sp02;
-    u8 r0;
+    s16 x, y;
+    u8 metatileBehavior;
 
     if (!(gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_UNDERWATER | PLAYER_AVATAR_FLAG_SURFING)))
     {
-        PlayerGetDestCoords(&sp00, &sp02);
-        r0 = MapGridGetMetatileBehaviorAt(sp00, sp02);
-        if (!sub_80BD4B8(r0))
+        PlayerGetDestCoords(&x, &y);
+        metatileBehavior = MapGridGetMetatileBehaviorAt(x, y);
+        if (!MetatileBehaviorForbidsBiking(metatileBehavior))
             return FALSE;
     }
     return TRUE;
@@ -331,7 +331,7 @@ void StartTransitionToFlipBikeState(u8 flags)
     else
     {
         SetPlayerAvatarTransitionFlags(flags);
-        if (sub_8056124(MUS_CYCLING))
+        if (Overworld_MusicCanOverrideMapMusic(MUS_CYCLING))
         {
             Overworld_SetSavedMusic(MUS_CYCLING);
             Overworld_ChangeMusicTo(MUS_CYCLING);
@@ -339,7 +339,7 @@ void StartTransitionToFlipBikeState(u8 flags)
     }
 }
 
-void sub_80BD620(u32 directionHistory, u32 abStartSelectHistory)
+void InitPlayerAvatarBikeState(u32 directionHistory, u32 abStartSelectHistory)
 {
     u8 i;
 
diff --git a/src/cable_club.c b/src/cable_club.c
index e75f1abf8..52856e3a3 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -402,7 +402,7 @@ static void Task_Linkup_6a(u8 taskId)
         if (gSpecialVar_Result == 1)
         {
             // Dumb trick required to match
-            if (gLinkType == LINKTYPE_0x4411)
+            if (gLinkType == LINKTYPE_BERRY_BLENDER_SETUP)
                 *UnusedVarNeededToMatch += 0;
             DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
             EnableBothScriptContexts();
@@ -493,9 +493,9 @@ void TryRecordMixLinkup(void)
     CreateLinkupTask(2, 4);
 }
 
-void sub_8081128(void)
+void TryContestLinkup(void)
 {
-    gLinkType = LINKTYPE_0x6601;
+    gLinkType = LINKTYPE_CONTEST_GMODE;
     gBattleTypeFlags = 0;
     CreateLinkupTask(4, 4);
 }
diff --git a/src/credits.c b/src/credits.c
index 12240c98f..58647f7b1 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -738,7 +738,7 @@ static void CB2_Credits(void)
         sCreditsMgr->unk_1D++;
         break;
     case 2:
-        FlagClear(FLAG_SPECIAL_FLAG_0x4000);
+        FlagClear(FLAG_DONT_SHOW_MAP_NAME_POPUP);
         gDisableMapMusicChangeOnMapLoad = MUSIC_DISABLE_OFF;
         Free(sCreditsMgr);
         SoftReset(RESET_ALL);
@@ -785,7 +785,7 @@ static bool32 DoOverworldMapScrollScene(UNUSED u8 unused)
     switch (sCreditsMgr->subseqno)
     {
     case 0:
-        FlagSet(FLAG_SPECIAL_FLAG_0x4000);
+        FlagSet(FLAG_DONT_SHOW_MAP_NAME_POPUP);
         gDisableMapMusicChangeOnMapLoad = MUSIC_DISABLE_KEEP;
         sCreditsMgr->ovwldseqno = 0;
         sCreditsMgr->subseqno++;
diff --git a/src/data/decoration/description.h b/src/data/decoration/description.h
new file mode 100644
index 000000000..b56f43eb6
--- /dev/null
+++ b/src/data/decoration/description.h
@@ -0,0 +1,573 @@
+const u8 DecorDesc_SMALL_DESK[] = _(
+    "A small desk built\n"
+        "for one.");
+
+const u8 DecorDesc_POKEMON_DESK[] = _(
+    "A small desk built in\n"
+        "the shape of a POKé\n"
+        "BALL.");
+
+const u8 DecorDesc_HEAVY_DESK[] = _(
+    "A large desk made\n"
+        "of steel. Put some\n"
+        "decorations on it.");
+
+const u8 DecorDesc_RAGGED_DESK[] = _(
+    "A large desk made\n"
+        "of wood. Put some\n"
+        "decorations on it.");
+
+const u8 DecorDesc_COMFORT_DESK[] = _(
+    "A large desk made\n"
+        "of leaves. Put some\n"
+        "decorations on it.");
+
+const u8 DecorDesc_PRETTY_DESK[] = _(
+    "A huge desk made\n"
+        "of glass. Holds lots\n"
+        "of decorations.");
+
+const u8 DecorDesc_BRICK_DESK[] = _(
+    "A huge desk made\n"
+        "of brick. Holds lots\n"
+        "of decorations.");
+
+const u8 DecorDesc_CAMP_DESK[] = _(
+    "A huge desk made\n"
+        "of logs. Put lots of\n"
+        "decorations on it.");
+
+const u8 DecorDesc_HARD_DESK[] = _(
+    "A huge desk made\n"
+        "of rocks. Holds\n"
+        "many decorations.");
+
+const u8 DecorDesc_SMALL_CHAIR[] = _(
+    "A small chair made\n"
+        "for one.");
+
+const u8 DecorDesc_POKEMON_CHAIR[] = _(
+    "A small chair built\n"
+        "in the shape of a\n"
+        "POKé BALL.");
+
+const u8 DecorDesc_HEAVY_CHAIR[] = _(
+    "A small chair made\n"
+        "of steel.");
+
+const u8 DecorDesc_PRETTY_CHAIR[] = _(
+    "A small chair made\n"
+        "of glass.");
+
+const u8 DecorDesc_COMFORT_CHAIR[] = _(
+    "A small chair made\n"
+        "of leaves.");
+
+const u8 DecorDesc_RAGGED_CHAIR[] = _(
+    "A small chair made\n"
+        "of wood.");
+
+const u8 DecorDesc_BRICK_CHAIR[] = _(
+    "A small chair made\n"
+        "of brick.");
+
+const u8 DecorDesc_CAMP_CHAIR[] = _(
+    "A small chair made\n"
+        "of logs.");
+
+const u8 DecorDesc_HARD_CHAIR[] = _(
+    "A small chair made\n"
+        "of rock.");
+
+const u8 DecorDesc_RED_PLANT[] = _(
+    "A vivid red potted\n"
+        "plant.");
+
+const u8 DecorDesc_TROPICAL_PLANT[] = _(
+    "A flowering tropical\n"
+        "plant in a pot.");
+
+const u8 DecorDesc_PRETTY_FLOWERS[] = _(
+    "A pot of cute\n"
+        "flowers.");
+
+const u8 DecorDesc_COLORFUL_PLANT[] = _(
+    "A large pot with\n"
+        "many colorful\n"
+        "flowers.");
+
+const u8 DecorDesc_BIG_PLANT[] = _(
+    "A large, umbrella-\n"
+        "shaped plant in a\n"
+        "big pot.");
+
+const u8 DecorDesc_GORGEOUS_PLANT[] = _(
+    "A large, impressive\n"
+        "plant in a big pot.");
+
+const u8 DecorDesc_RED_BRICK[] = _(
+    "A red-colored brick.\n"
+        "Decorations can be\n"
+        "placed on top.");
+
+const u8 DecorDesc_YELLOW_BRICK[] = _(
+    "A yellow-colored\n"
+        "brick. Put some\n"
+        "decorations on top.");
+
+const u8 DecorDesc_BLUE_BRICK[] = _(
+    "A blue-colored\n"
+        "brick. Put some\n"
+        "decorations on top.");
+
+const u8 DecorDesc_RED_BALLOON[] = _(
+    "A red balloon filled\n"
+        "with water. Bursts\n"
+        "if stepped on.");
+
+const u8 DecorDesc_BLUE_BALLOON[] = _(
+    "A blue balloon filled\n"
+        "with water. Bursts\n"
+        "if stepped on.");
+
+const u8 DecorDesc_YELLOW_BALLOON[] = _(
+    "A yellow balloon\n"
+        "filled with water.\n"
+        "Pops if stepped on.");
+
+const u8 DecorDesc_RED_TENT[] = _(
+    "A large red tent.\n"
+        "You can hide inside\n"
+        "it.");
+
+const u8 DecorDesc_BLUE_TENT[] = _(
+    "A large blue tent.\n"
+        "You can hide inside\n"
+        "it.");
+
+const u8 DecorDesc_SOLID_BOARD[] = _(
+    "Place over a hole to\n"
+        "cross to the other\n"
+        "side.");
+
+const u8 DecorDesc_SLIDE[] = _(
+    "Use to slide down\n"
+        "from the platform.");
+
+const u8 DecorDesc_FENCE_LENGTH[] = _(
+    "A small fence that\n"
+        "blocks passage.");
+
+const u8 DecorDesc_FENCE_WIDTH[] = _(
+    "A small fence that\n"
+        "blocks passage.");
+
+const u8 DecorDesc_TIRE[] = _(
+    "An old large tire.\n"
+        "Decorations can be\n"
+        "placed on top.");
+
+const u8 DecorDesc_STAND[] = _(
+    "A large pedestal\n"
+        "with steps.");
+
+const u8 DecorDesc_MUD_BALL[] = _(
+    "A large ball of mud.\n"
+        "Crumbles if stepped\n"
+        "on.");
+
+const u8 DecorDesc_BREAKABLE_DOOR[] = _(
+    "A weird door that\n"
+        "people can walk\n"
+        "right through.");
+
+const u8 DecorDesc_SAND_ORNAMENT[] = _(
+    "An ornament made\n"
+        "of sand. Crumbles if\n"
+        "touched.");
+
+const u8 DecorDesc_SILVER_SHIELD[] = _(
+    "Awarded for 50\n"
+        "straight wins at\n"
+        "the BATTLE TOWER.");
+
+const u8 DecorDesc_GOLD_SHIELD[] = _(
+    "Awarded for 100\n"
+        "straight wins at\n"
+        "the BATTLE TOWER.");
+
+const u8 DecorDesc_GLASS_ORNAMENT[] = _(
+    "A glass replica of\n"
+        "a famous sculpture\n"
+        "at the ART MUSEUM.");
+
+const u8 DecorDesc_TV[] = _(
+    "A small, gray-\n"
+        "colored toy TV.");
+
+const u8 DecorDesc_ROUND_TV[] = _(
+    "A toy TV modeled\n"
+        "in the image of a\n"
+        "SEEDOT.");
+
+const u8 DecorDesc_CUTE_TV[] = _(
+    "A toy TV modeled\n"
+        "in the image of a\n"
+        "SKITTY.");
+
+const u8 DecorDesc_GLITTER_MAT[] = _(
+    "An odd mat that\n"
+        "glitters if stepped\n"
+        "on.");
+
+const u8 DecorDesc_JUMP_MAT[] = _(
+    "A trick mat that\n"
+        "jumps when it is\n"
+        "stepped on.");
+
+const u8 DecorDesc_SPIN_MAT[] = _(
+    "A trick mat that\n"
+        "spins around when\n"
+        "stepped on.");
+
+const u8 DecorDesc_C_LOW_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "a low C note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_D_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "a D note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_E_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "an E note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_F_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "an F note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_G_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "a G note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_A_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "an A note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_B_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "a B note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_C_HIGH_NOTE_MAT[] = _(
+    "A mat that plays\n"
+        "a high C note when\n"
+        "stepped on.");
+
+const u8 DecorDesc_SURF_MAT[] = _(
+    "A mat designed with\n"
+        "a SURF image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_THUNDER_MAT[] = _(
+    "A mat designed with\n"
+        "a THUNDER image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_FIRE_BLAST_MAT[] = _(
+    "A mat designed with\n"
+        "a FIRE BLAST image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_POWDER_SNOW_MAT[] = _(
+    "A mat with a POWDER\n"
+        "SNOW image design.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_ATTRACT_MAT[] = _(
+    "A mat designed with\n"
+        "an ATTRACT image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_FISSURE_MAT[] = _(
+    "A mat designed with\n"
+        "a FISSURE image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_SPIKES_MAT[] = _(
+    "A mat designed with\n"
+        "a SPIKES image.\n"
+        "Put items on top.");
+
+const u8 DecorDesc_BALL_POSTER[] = _(
+    "A small poster\n"
+        "printed with POKé\n"
+        "BALLS.");
+
+const u8 DecorDesc_GREEN_POSTER[] = _(
+    "A small poster with\n"
+        "a TREECKO print.");
+
+const u8 DecorDesc_RED_POSTER[] = _(
+    "A small poster with\n"
+        "a TORCHIC print.");
+
+const u8 DecorDesc_BLUE_POSTER[] = _(
+    "A small poster with\n"
+        "a MUDKIP print.");
+
+const u8 DecorDesc_CUTE_POSTER[] = _(
+    "A small poster with\n"
+        "an AZURILL print.");
+
+const u8 DecorDesc_PIKA_POSTER[] = _(
+    "A large poster with\n"
+        "a PIKACHU and\n"
+        "PICHU print.");
+
+const u8 DecorDesc_LONG_POSTER[] = _(
+    "A large poster with\n"
+        "a SEVIPER print.");
+
+const u8 DecorDesc_SEA_POSTER[] = _(
+    "A large poster with\n"
+        "a RELICANTH print.");
+
+const u8 DecorDesc_SKY_POSTER[] = _(
+    "A large poster with\n"
+        "a WINGULL print.");
+
+const u8 DecorDesc_KISS_POSTER[] = _(
+    "A large poster with\n"
+        "a SMOOCHUM print.");
+
+const u8 DecorDesc_PICHU_DOLL[] = _(
+    "A PICHU doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_PIKACHU_DOLL[] = _(
+    "A PIKACHU doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_MARILL_DOLL[] = _(
+    "A MARILL doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_TOGEPI_DOLL[] = _(
+    "A TOGEPI doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_CYNDAQUIL_DOLL[] = _(
+    "A CYNDAQUIL doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_CHIKORITA_DOLL[] = _(
+    "A CHIKORITA doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_TOTODILE_DOLL[] = _(
+    "A TOTODILE doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_JIGGLYPUFF_DOLL[] = _(
+    "A JIGGLYPUFF doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_MEOWTH_DOLL[] = _(
+    "A MEOWTH doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_CLEFAIRY_DOLL[] = _(
+    "A CLEFAIRY doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_DITTO_DOLL[] = _(
+    "A DITTO doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_SMOOCHUM_DOLL[] = _(
+    "A SMOOCHUM doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_TREECKO_DOLL[] = _(
+    "A TREECKO doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_TORCHIC_DOLL[] = _(
+    "A TORCHIC doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_MUDKIP_DOLL[] = _(
+    "A MUDKIP doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_DUSKULL_DOLL[] = _(
+    "A DUSKULL doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_WYNAUT_DOLL[] = _(
+    "A WYNAUT doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_BALTOY_DOLL[] = _(
+    "A BALTOY doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_KECLEON_DOLL[] = _(
+    "A KECLEON doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_AZURILL_DOLL[] = _(
+    "An AZURILL doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_SKITTY_DOLL[] = _(
+    "A SKITTY doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_SWABLU_DOLL[] = _(
+    "A SWABLU doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_GULPIN_DOLL[] = _(
+    "A GULPIN doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_LOTAD_DOLL[] = _(
+    "A LOTAD doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_SEEDOT_DOLL[] = _(
+    "A SEEDOT doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_PIKA_CUSHION[] = _(
+    "A PIKACHU cushion.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_ROUND_CUSHION[] = _(
+    "A MARILL cushion.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_KISS_CUSHION[] = _(
+    "A SMOOCHUM\n"
+        "cushion. Place it on\n"
+        "a mat or a desk.");
+
+const u8 DecorDesc_ZIGZAG_CUSHION[] = _(
+    "A ZIGZAGOON\n"
+        "cushion. Place it on\n"
+        "a mat or a desk.");
+
+const u8 DecorDesc_SPIN_CUSHION[] = _(
+    "A SPINDA cushion.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_DIAMOND_CUSHION[] = _(
+    "A SABLEYE cushion.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_BALL_CUSHION[] = _(
+    "A BALL cushion.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_GRASS_CUSHION[] = _(
+    "A grass-mark\n"
+        "cushion. Place it on\n"
+        "a mat or a desk.");
+
+const u8 DecorDesc_FIRE_CUSHION[] = _(
+    "A fire-mark\n"
+        "cushion. Place it on\n"
+        "a mat or a desk.");
+
+const u8 DecorDesc_WATER_CUSHION[] = _(
+    "A water-mark\n"
+        "cushion. Place it on\n"
+        "a mat or a desk.");
+
+const u8 DecorDesc_SNORLAX_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_RHYDON_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_LAPRAS_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_VENUSAUR_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_CHARIZARD_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_BLASTOISE_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_WAILMER_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_REGIROCK_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_REGICE_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
+
+const u8 DecorDesc_REGISTEEL_DOLL[] = _(
+    "A large doll.\n"
+        "Place it on a mat\n"
+        "or a desk.");
diff --git a/src/data/decoration/header.h b/src/data/decoration/header.h
new file mode 100644
index 000000000..55458c7a3
--- /dev/null
+++ b/src/data/decoration/header.h
@@ -0,0 +1,1091 @@
+const struct Decoration gDecorations[] = {
+    {
+        DECOR_NONE,
+        _("SMALL DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_DESK,
+        0,
+        DecorDesc_SMALL_DESK,
+        DecorGfx_SMALL_DESK
+    }, {
+        DECOR_SMALL_DESK,
+        _("SMALL DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_DESK,
+        3000,
+        DecorDesc_SMALL_DESK,
+        DecorGfx_SMALL_DESK
+    }, {
+        DECOR_POKEMON_DESK,
+        _("POKéMON DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_DESK,
+        3000,
+        DecorDesc_POKEMON_DESK,
+        DecorGfx_POKEMON_DESK
+    }, {
+        DECOR_HEAVY_DESK,
+        _("HEAVY DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x2,
+        DECORCAT_DESK,
+        6000,
+        DecorDesc_HEAVY_DESK,
+        DecorGfx_HEAVY_DESK
+    }, {
+        DECOR_RAGGED_DESK,
+        _("RAGGED DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x2,
+        DECORCAT_DESK,
+        6000,
+        DecorDesc_RAGGED_DESK,
+        DecorGfx_RAGGED_DESK
+    }, {
+        DECOR_COMFORT_DESK,
+        _("COMFORT DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x2,
+        DECORCAT_DESK,
+        6000,
+        DecorDesc_COMFORT_DESK,
+        DecorGfx_COMFORT_DESK
+    }, {
+        DECOR_PRETTY_DESK,
+        _("PRETTY DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_DESK,
+        9000,
+        DecorDesc_PRETTY_DESK,
+        DecorGfx_PRETTY_DESK
+    }, {
+        DECOR_BRICK_DESK,
+        _("BRICK DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_DESK,
+        9000,
+        DecorDesc_BRICK_DESK,
+        DecorGfx_BRICK_DESK
+    }, {
+        DECOR_CAMP_DESK,
+        _("CAMP DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_DESK,
+        9000,
+        DecorDesc_CAMP_DESK,
+        DecorGfx_CAMP_DESK
+    }, {
+        DECOR_HARD_DESK,
+        _("HARD DESK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_DESK,
+        9000,
+        DecorDesc_HARD_DESK,
+        DecorGfx_HARD_DESK
+    }, {
+        DECOR_SMALL_CHAIR,
+        _("SMALL CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_SMALL_CHAIR,
+        DecorGfx_SMALL_CHAIR
+    }, {
+        DECOR_POKEMON_CHAIR,
+        _("POKéMON CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_POKEMON_CHAIR,
+        DecorGfx_POKEMON_CHAIR
+    }, {
+        DECOR_HEAVY_CHAIR,
+        _("HEAVY CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_HEAVY_CHAIR,
+        DecorGfx_HEAVY_CHAIR
+    }, {
+        DECOR_PRETTY_CHAIR,
+        _("PRETTY CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_PRETTY_CHAIR,
+        DecorGfx_PRETTY_CHAIR
+    }, {
+        DECOR_COMFORT_CHAIR,
+        _("COMFORT CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_COMFORT_CHAIR,
+        DecorGfx_COMFORT_CHAIR
+    }, {
+        DECOR_RAGGED_CHAIR,
+        _("RAGGED CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_RAGGED_CHAIR,
+        DecorGfx_RAGGED_CHAIR
+    }, {
+        DECOR_BRICK_CHAIR,
+        _("BRICK CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_BRICK_CHAIR,
+        DecorGfx_BRICK_CHAIR
+    }, {
+        DECOR_CAMP_CHAIR,
+        _("CAMP CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_CAMP_CHAIR,
+        DecorGfx_CAMP_CHAIR
+    }, {
+        DECOR_HARD_CHAIR,
+        _("HARD CHAIR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_CHAIR,
+        2000,
+        DecorDesc_HARD_CHAIR,
+        DecorGfx_HARD_CHAIR
+    }, {
+        DECOR_RED_PLANT,
+        _("RED PLANT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_PLANT,
+        3000,
+        DecorDesc_RED_PLANT,
+        DecorGfx_RED_PLANT
+    }, {
+        DECOR_TROPICAL_PLANT,
+        _("TROPICAL PLANT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_PLANT,
+        3000,
+        DecorDesc_TROPICAL_PLANT,
+        DecorGfx_TROPICAL_PLANT
+    }, {
+        DECOR_PRETTY_FLOWERS,
+        _("PRETTY FLOWERS"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_PLANT,
+        3000,
+        DecorDesc_PRETTY_FLOWERS,
+        DecorGfx_PRETTY_FLOWERS
+    }, {
+        DECOR_COLORFUL_PLANT,
+        _("COLORFUL PLANT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_2x2,
+        DECORCAT_PLANT,
+        5000,
+        DecorDesc_COLORFUL_PLANT,
+        DecorGfx_COLORFUL_PLANT
+    }, {
+        DECOR_BIG_PLANT,
+        _("BIG PLANT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_2x2,
+        DECORCAT_PLANT,
+        5000,
+        DecorDesc_BIG_PLANT,
+        DecorGfx_BIG_PLANT
+    }, {
+        DECOR_GORGEOUS_PLANT,
+        _("GORGEOUS PLANT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_2x2,
+        DECORCAT_PLANT,
+        5000,
+        DecorDesc_GORGEOUS_PLANT,
+        DecorGfx_GORGEOUS_PLANT
+    }, {
+        DECOR_RED_BRICK,
+        _("RED BRICK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_RED_BRICK,
+        DecorGfx_RED_BRICK
+    }, {
+        DECOR_YELLOW_BRICK,
+        _("YELLOW BRICK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_YELLOW_BRICK,
+        DecorGfx_YELLOW_BRICK
+    }, {
+        DECOR_BLUE_BRICK,
+        _("BLUE BRICK"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_BLUE_BRICK,
+        DecorGfx_BLUE_BRICK
+    }, {
+        DECOR_RED_BALLOON,
+        _("RED BALLOON"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_RED_BALLOON,
+        DecorGfx_RED_BALLOON
+    }, {
+        DECOR_BLUE_BALLOON,
+        _("BLUE BALLOON"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_BLUE_BALLOON,
+        DecorGfx_BLUE_BALLOON
+    }, {
+        DECOR_YELLOW_BALLOON,
+        _("YELLOW BALLOON"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_YELLOW_BALLOON,
+        DecorGfx_YELLOW_BALLOON
+    }, {
+        DECOR_RED_TENT,
+        _("RED TENT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_ORNAMENT,
+        10000,
+        DecorDesc_RED_TENT,
+        DecorGfx_RED_TENT
+    }, {
+        DECOR_BLUE_TENT,
+        _("BLUE TENT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_ORNAMENT,
+        10000,
+        DecorDesc_BLUE_TENT,
+        DecorGfx_BLUE_TENT
+    }, {
+        DECOR_SOLID_BOARD,
+        _("SOLID BOARD"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        3000,
+        DecorDesc_SOLID_BOARD,
+        DecorGfx_SOLID_BOARD
+    }, {
+        DECOR_SLIDE,
+        _("SLIDE"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_2x4,
+        DECORCAT_ORNAMENT,
+        8000,
+        DecorDesc_SLIDE,
+        DecorGfx_SLIDE
+    }, {
+        DECOR_FENCE_LENGTH,
+        _("FENCE LENGTH"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_FENCE_LENGTH,
+        DecorGfx_FENCE_LENGTH
+    }, {
+        DECOR_FENCE_WIDTH,
+        _("FENCE WIDTH"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        500,
+        DecorDesc_FENCE_WIDTH,
+        DecorGfx_FENCE_WIDTH
+    }, {
+        DECOR_TIRE,
+        _("TIRE"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_2x2,
+        DECORCAT_ORNAMENT,
+        800,
+        DecorDesc_TIRE,
+        DecorGfx_TIRE
+    }, {
+        DECOR_STAND,
+        _("STAND"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_4x2,
+        DECORCAT_ORNAMENT,
+        7000,
+        DecorDesc_STAND,
+        DecorGfx_STAND
+    }, {
+        DECOR_MUD_BALL,
+        _("MUD BALL"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        200,
+        DecorDesc_MUD_BALL,
+        DecorGfx_MUD_BALL
+    }, {
+        DECOR_BREAKABLE_DOOR,
+        _("BREAKABLE DOOR"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        3000,
+        DecorDesc_BREAKABLE_DOOR,
+        DecorGfx_BREAKABLE_DOOR
+    }, {
+        DECOR_SAND_ORNAMENT,
+        _("SAND ORNAMENT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        3000,
+        DecorDesc_SAND_ORNAMENT,
+        DecorGfx_SAND_ORNAMENT
+    }, {
+        DECOR_SILVER_SHIELD,
+        _("SILVER SHIELD"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        0,
+        DecorDesc_SILVER_SHIELD,
+        DecorGfx_SILVER_SHIELD
+    }, {
+        DECOR_GOLD_SHIELD,
+        _("GOLD SHIELD"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        0,
+        DecorDesc_GOLD_SHIELD,
+        DecorGfx_GOLD_SHIELD
+    }, {
+        DECOR_GLASS_ORNAMENT,
+        _("GLASS ORNAMENT"),
+        DECORPERM_BEHIND_FLOOR,
+        DECORSHAPE_1x2,
+        DECORCAT_ORNAMENT,
+        0,
+        DecorDesc_GLASS_ORNAMENT,
+        DecorGfx_GLASS_ORNAMENT
+    }, {
+        DECOR_TV,
+        _("TV"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        3000,
+        DecorDesc_TV,
+        DecorGfx_TV
+    }, {
+        DECOR_ROUND_TV,
+        _("ROUND TV"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        4000,
+        DecorDesc_ROUND_TV,
+        DecorGfx_ROUND_TV
+    }, {
+        DECOR_CUTE_TV,
+        _("CUTE TV"),
+        DECORPERM_SOLID_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_ORNAMENT,
+        4000,
+        DecorDesc_CUTE_TV,
+        DecorGfx_CUTE_TV
+    }, {
+        DECOR_GLITTER_MAT,
+        _("GLITTER MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        2000,
+        DecorDesc_GLITTER_MAT,
+        DecorGfx_GLITTER_MAT
+    }, {
+        DECOR_JUMP_MAT,
+        _("JUMP MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        2000,
+        DecorDesc_JUMP_MAT,
+        DecorGfx_JUMP_MAT
+    }, {
+        DECOR_SPIN_MAT,
+        _("SPIN MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        2000,
+        DecorDesc_SPIN_MAT,
+        DecorGfx_SPIN_MAT
+    }, {
+        DECOR_C_LOW_NOTE_MAT,
+        _("C Low NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_C_LOW_NOTE_MAT,
+        DecorGfx_C_LOW_NOTE_MAT
+    }, {
+        DECOR_D_NOTE_MAT,
+        _("D NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_D_NOTE_MAT,
+        DecorGfx_D_NOTE_MAT
+    }, {
+        DECOR_E_NOTE_MAT,
+        _("E NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_E_NOTE_MAT,
+        DecorGfx_E_NOTE_MAT
+    }, {
+        DECOR_F_NOTE_MAT,
+        _("F NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_F_NOTE_MAT,
+        DecorGfx_F_NOTE_MAT
+    }, {
+        DECOR_G_NOTE_MAT,
+        _("G NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_G_NOTE_MAT,
+        DecorGfx_G_NOTE_MAT
+    }, {
+        DECOR_A_NOTE_MAT,
+        _("A NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_A_NOTE_MAT,
+        DecorGfx_A_NOTE_MAT
+    }, {
+        DECOR_B_NOTE_MAT,
+        _("B NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_B_NOTE_MAT,
+        DecorGfx_B_NOTE_MAT
+    }, {
+        DECOR_C_HIGH_NOTE_MAT,
+        _("C High NOTE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_1x1,
+        DECORCAT_MAT,
+        500,
+        DecorDesc_C_HIGH_NOTE_MAT,
+        DecorGfx_C_HIGH_NOTE_MAT
+    }, {
+        DECOR_SURF_MAT,
+        _("SURF MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_SURF_MAT,
+        DecorGfx_SURF_MAT
+    }, {
+        DECOR_THUNDER_MAT,
+        _("THUNDER MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_THUNDER_MAT,
+        DecorGfx_THUNDER_MAT
+    }, {
+        DECOR_FIRE_BLAST_MAT,
+        _("FIRE BLAST MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_FIRE_BLAST_MAT,
+        DecorGfx_FIRE_BLAST_MAT
+    }, {
+        DECOR_POWDER_SNOW_MAT,
+        _("POWDER SNOW MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_POWDER_SNOW_MAT,
+        DecorGfx_POWDER_SNOW_MAT
+    }, {
+        DECOR_ATTRACT_MAT,
+        _("ATTRACT MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_ATTRACT_MAT,
+        DecorGfx_ATTRACT_MAT
+    }, {
+        DECOR_FISSURE_MAT,
+        _("FISSURE MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_FISSURE_MAT,
+        DecorGfx_FISSURE_MAT
+    }, {
+        DECOR_SPIKES_MAT,
+        _("SPIKES MAT"),
+        DECORPERM_PASS_FLOOR,
+        DECORSHAPE_3x3,
+        DECORCAT_MAT,
+        4000,
+        DecorDesc_SPIKES_MAT,
+        DecorGfx_SPIKES_MAT
+    }, {
+        DECOR_BALL_POSTER,
+        _("BALL POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_1x1,
+        DECORCAT_POSTER,
+        1000,
+        DecorDesc_BALL_POSTER,
+        DecorGfx_BALL_POSTER
+    }, {
+        DECOR_GREEN_POSTER,
+        _("GREEN POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_1x1,
+        DECORCAT_POSTER,
+        1000,
+        DecorDesc_GREEN_POSTER,
+        DecorGfx_GREEN_POSTER
+    }, {
+        DECOR_RED_POSTER,
+        _("RED POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_1x1,
+        DECORCAT_POSTER,
+        1000,
+        DecorDesc_RED_POSTER,
+        DecorGfx_RED_POSTER
+    }, {
+        DECOR_BLUE_POSTER,
+        _("BLUE POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_1x1,
+        DECORCAT_POSTER,
+        1000,
+        DecorDesc_BLUE_POSTER,
+        DecorGfx_BLUE_POSTER
+    }, {
+        DECOR_CUTE_POSTER,
+        _("CUTE POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_1x1,
+        DECORCAT_POSTER,
+        1000,
+        DecorDesc_CUTE_POSTER,
+        DecorGfx_CUTE_POSTER
+    }, {
+        DECOR_PIKA_POSTER,
+        _("PIKA POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_2x1,
+        DECORCAT_POSTER,
+        1500,
+        DecorDesc_PIKA_POSTER,
+        DecorGfx_PIKA_POSTER
+    }, {
+        DECOR_LONG_POSTER,
+        _("LONG POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_2x1,
+        DECORCAT_POSTER,
+        1500,
+        DecorDesc_LONG_POSTER,
+        DecorGfx_LONG_POSTER
+    }, {
+        DECOR_SEA_POSTER,
+        _("SEA POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_2x1,
+        DECORCAT_POSTER,
+        1500,
+        DecorDesc_SEA_POSTER,
+        DecorGfx_SEA_POSTER
+    }, {
+        DECOR_SKY_POSTER,
+        _("SKY POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_2x1,
+        DECORCAT_POSTER,
+        1500,
+        DecorDesc_SKY_POSTER,
+        DecorGfx_SKY_POSTER
+    }, {
+        DECOR_KISS_POSTER,
+        _("KISS POSTER"),
+        DECORPERM_NA_WALL,
+        DECORSHAPE_2x1,
+        DECORCAT_POSTER,
+        1500,
+        DecorDesc_KISS_POSTER,
+        DecorGfx_KISS_POSTER
+    }, {
+        DECOR_PICHU_DOLL,
+        _("PICHU DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_PICHU_DOLL,
+        DecorGfx_PICHU_DOLL
+    }, {
+        DECOR_PIKACHU_DOLL,
+        _("PIKACHU DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_PIKACHU_DOLL,
+        DecorGfx_PIKACHU_DOLL
+    }, {
+        DECOR_MARILL_DOLL,
+        _("MARILL DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_MARILL_DOLL,
+        DecorGfx_MARILL_DOLL
+    }, {
+        DECOR_TOGEPI_DOLL,
+        _("TOGEPI DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_TOGEPI_DOLL,
+        DecorGfx_TOGEPI_DOLL
+    }, {
+        DECOR_CYNDAQUIL_DOLL,
+        _("CYNDAQUIL DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_CYNDAQUIL_DOLL,
+        DecorGfx_CYNDAQUIL_DOLL
+    }, {
+        DECOR_CHIKORITA_DOLL,
+        _("CHIKORITA DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_CHIKORITA_DOLL,
+        DecorGfx_CHIKORITA_DOLL
+    }, {
+        DECOR_TOTODILE_DOLL,
+        _("TOTODILE DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_TOTODILE_DOLL,
+        DecorGfx_TOTODILE_DOLL
+    }, {
+        DECOR_JIGGLYPUFF_DOLL,
+        _("JIGGLYPUFF DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_JIGGLYPUFF_DOLL,
+        DecorGfx_JIGGLYPUFF_DOLL
+    }, {
+        DECOR_MEOWTH_DOLL,
+        _("MEOWTH DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_MEOWTH_DOLL,
+        DecorGfx_MEOWTH_DOLL
+    }, {
+        DECOR_CLEFAIRY_DOLL,
+        _("CLEFAIRY DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_CLEFAIRY_DOLL,
+        DecorGfx_CLEFAIRY_DOLL
+    }, {
+        DECOR_DITTO_DOLL,
+        _("DITTO DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_DITTO_DOLL,
+        DecorGfx_DITTO_DOLL
+    }, {
+        DECOR_SMOOCHUM_DOLL,
+        _("SMOOCHUM DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_SMOOCHUM_DOLL,
+        DecorGfx_SMOOCHUM_DOLL
+    }, {
+        DECOR_TREECKO_DOLL,
+        _("TREECKO DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_TREECKO_DOLL,
+        DecorGfx_TREECKO_DOLL
+    }, {
+        DECOR_TORCHIC_DOLL,
+        _("TORCHIC DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_TORCHIC_DOLL,
+        DecorGfx_TORCHIC_DOLL
+    }, {
+        DECOR_MUDKIP_DOLL,
+        _("MUDKIP DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_MUDKIP_DOLL,
+        DecorGfx_MUDKIP_DOLL
+    }, {
+        DECOR_DUSKULL_DOLL,
+        _("DUSKULL DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_DUSKULL_DOLL,
+        DecorGfx_DUSKULL_DOLL
+    }, {
+        DECOR_WYNAUT_DOLL,
+        _("WYNAUT DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_WYNAUT_DOLL,
+        DecorGfx_WYNAUT_DOLL
+    }, {
+        DECOR_BALTOY_DOLL,
+        _("BALTOY DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_BALTOY_DOLL,
+        DecorGfx_BALTOY_DOLL
+    }, {
+        DECOR_KECLEON_DOLL,
+        _("KECLEON DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_KECLEON_DOLL,
+        DecorGfx_KECLEON_DOLL
+    }, {
+        DECOR_AZURILL_DOLL,
+        _("AZURILL DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_AZURILL_DOLL,
+        DecorGfx_AZURILL_DOLL
+    }, {
+        DECOR_SKITTY_DOLL,
+        _("SKITTY DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_SKITTY_DOLL,
+        DecorGfx_SKITTY_DOLL
+    }, {
+        DECOR_SWABLU_DOLL,
+        _("SWABLU DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_SWABLU_DOLL,
+        DecorGfx_SWABLU_DOLL
+    }, {
+        DECOR_GULPIN_DOLL,
+        _("GULPIN DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_GULPIN_DOLL,
+        DecorGfx_GULPIN_DOLL
+    }, {
+        DECOR_LOTAD_DOLL,
+        _("LOTAD DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_LOTAD_DOLL,
+        DecorGfx_LOTAD_DOLL
+    }, {
+        DECOR_SEEDOT_DOLL,
+        _("SEEDOT DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_DOLL,
+        3000,
+        DecorDesc_SEEDOT_DOLL,
+        DecorGfx_SEEDOT_DOLL
+    }, {
+        DECOR_PIKA_CUSHION,
+        _("PIKA CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_PIKA_CUSHION,
+        DecorGfx_PIKA_CUSHION
+    }, {
+        DECOR_ROUND_CUSHION,
+        _("ROUND CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_ROUND_CUSHION,
+        DecorGfx_ROUND_CUSHION
+    }, {
+        DECOR_KISS_CUSHION,
+        _("KISS CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_KISS_CUSHION,
+        DecorGfx_KISS_CUSHION
+    }, {
+        DECOR_ZIGZAG_CUSHION,
+        _("ZIGZAG CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_ZIGZAG_CUSHION,
+        DecorGfx_ZIGZAG_CUSHION
+    }, {
+        DECOR_SPIN_CUSHION,
+        _("SPIN CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_SPIN_CUSHION,
+        DecorGfx_SPIN_CUSHION
+    }, {
+        DECOR_DIAMOND_CUSHION,
+        _("DIAMOND CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_DIAMOND_CUSHION,
+        DecorGfx_DIAMOND_CUSHION
+    }, {
+        DECOR_BALL_CUSHION,
+        _("BALL CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_BALL_CUSHION,
+        DecorGfx_BALL_CUSHION
+    }, {
+        DECOR_GRASS_CUSHION,
+        _("GRASS CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_GRASS_CUSHION,
+        DecorGfx_GRASS_CUSHION
+    }, {
+        DECOR_FIRE_CUSHION,
+        _("FIRE CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_FIRE_CUSHION,
+        DecorGfx_FIRE_CUSHION
+    }, {
+        DECOR_WATER_CUSHION,
+        _("WATER CUSHION"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x1,
+        DECORCAT_CUSHION,
+        2000,
+        DecorDesc_WATER_CUSHION,
+        DecorGfx_WATER_CUSHION
+    }, {
+        DECOR_SNORLAX_DOLL,
+        _("SNORLAX DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_SNORLAX_DOLL,
+        DecorGfx_SNORLAX_DOLL
+    }, {
+        DECOR_RHYDON_DOLL,
+        _("RHYDON DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_RHYDON_DOLL,
+        DecorGfx_RHYDON_DOLL
+    }, {
+        DECOR_LAPRAS_DOLL,
+        _("LAPRAS DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_LAPRAS_DOLL,
+        DecorGfx_LAPRAS_DOLL
+    }, {
+        DECOR_VENUSAUR_DOLL,
+        _("VENUSAUR DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_VENUSAUR_DOLL,
+        DecorGfx_VENUSAUR_DOLL
+    }, {
+        DECOR_CHARIZARD_DOLL,
+        _("CHARIZARD DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_CHARIZARD_DOLL,
+        DecorGfx_CHARIZARD_DOLL
+    }, {
+        DECOR_BLASTOISE_DOLL,
+        _("BLASTOISE DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_BLASTOISE_DOLL,
+        DecorGfx_BLASTOISE_DOLL
+    }, {
+        DECOR_WAILMER_DOLL,
+        _("WAILMER DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_WAILMER_DOLL,
+        DecorGfx_WAILMER_DOLL
+    }, {
+        DECOR_REGIROCK_DOLL,
+        _("REGIROCK DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_REGIROCK_DOLL,
+        DecorGfx_REGIROCK_DOLL
+    }, {
+        DECOR_REGICE_DOLL,
+        _("REGICE DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_REGICE_DOLL,
+        DecorGfx_REGICE_DOLL
+    }, {
+        DECOR_REGISTEEL_DOLL,
+        _("REGISTEEL DOLL"),
+        DECORPERM_SPRITE,
+        DECORSHAPE_1x2,
+        DECORCAT_DOLL,
+        10000,
+        DecorDesc_REGISTEEL_DOLL,
+        DecorGfx_REGISTEEL_DOLL}
+};
diff --git a/src/data/decoration/tiles.h b/src/data/decoration/tiles.h
new file mode 100644
index 000000000..ff6ef3e12
--- /dev/null
+++ b/src/data/decoration/tiles.h
@@ -0,0 +1,643 @@
+#include "constants/event_objects.h"
+
+const u16 DecorGfx_SMALL_DESK[] = {
+    0x87
+};
+
+const u16 DecorGfx_POKEMON_DESK[] = {
+    0x8F
+};
+
+const u16 DecorGfx_HEAVY_DESK[] = {
+    0x90,
+    0x91,
+    0x92,
+    0x98,
+    0x99,
+    0x9A
+};
+
+const u16 DecorGfx_RAGGED_DESK[] = {
+    0x93,
+    0x94,
+    0x95,
+    0x9B,
+    0x9C,
+    0x9D
+};
+
+const u16 DecorGfx_COMFORT_DESK[] = {
+    0x96,
+    0x97,
+    0xA3,
+    0x9E,
+    0x9F,
+    0xAB
+};
+
+const u16 DecorGfx_PRETTY_DESK[] = {
+    0xBD,
+    0xBE,
+    0xBF,
+    0xC5,
+    0xC6,
+    0xC7,
+    0xCD,
+    0xCE,
+    0xCF
+};
+
+const u16 DecorGfx_BRICK_DESK[] = {
+    0xA0,
+    0xA1,
+    0xA2,
+    0xA8,
+    0xA9,
+    0xAA,
+    0xB0,
+    0xB1,
+    0xB2
+};
+
+const u16 DecorGfx_CAMP_DESK[] = {
+    0xA4,
+    0xA5,
+    0xA6,
+    0xAC,
+    0xAD,
+    0xAE,
+    0xB4,
+    0xB5,
+    0xB6
+};
+
+const u16 DecorGfx_HARD_DESK[] = {
+    0xA7,
+    0xBB,
+    0xBC,
+    0xAF,
+    0xC3,
+    0xC4,
+    0xB7,
+    0xCB,
+    0xCC
+};
+
+const u16 DecorGfx_SMALL_CHAIR[] = {
+    0xB8
+};
+
+const u16 DecorGfx_POKEMON_CHAIR[] = {
+    0xB9
+};
+
+const u16 DecorGfx_HEAVY_CHAIR[] = {
+    0xBA
+};
+
+const u16 DecorGfx_PRETTY_CHAIR[] = {
+    0xC0
+};
+
+const u16 DecorGfx_COMFORT_CHAIR[] = {
+    0xC1
+};
+
+const u16 DecorGfx_RAGGED_CHAIR[] = {
+    0xC2
+};
+
+const u16 DecorGfx_BRICK_CHAIR[] = {
+    0xC8
+};
+
+const u16 DecorGfx_CAMP_CHAIR[] = {
+    0xC9
+};
+
+const u16 DecorGfx_HARD_CHAIR[] = {
+    0xCA
+};
+
+const u16 DecorGfx_RED_PLANT[] = {
+    0xD0,
+    0xD8
+};
+
+const u16 DecorGfx_TROPICAL_PLANT[] = {
+    0xD2,
+    0xDA
+};
+
+const u16 DecorGfx_PRETTY_FLOWERS[] = {
+    0xD4,
+    0xDC
+};
+
+const u16 DecorGfx_COLORFUL_PLANT[] = {
+    0xE0,
+    0xE2,
+    0xE8,
+    0xE9
+};
+
+const u16 DecorGfx_BIG_PLANT[] = {
+    0xE4,
+    0xE6,
+    0xEC,
+    0xED
+};
+
+const u16 DecorGfx_GORGEOUS_PLANT[] = {
+    0xF0,
+    0xF2,
+    0xF8,
+    0xF9
+};
+
+const u16 DecorGfx_RED_BRICK[] = {
+    0x25,
+    0x2D
+};
+
+const u16 DecorGfx_YELLOW_BRICK[] = {
+    0x26,
+    0x2E
+};
+
+const u16 DecorGfx_BLUE_BRICK[] = {
+    0x27,
+    0x2F
+};
+
+const u16 DecorGfx_RED_BALLOON[] = {
+    0x138
+};
+
+const u16 DecorGfx_BLUE_BALLOON[] = {
+    0x13C
+};
+
+const u16 DecorGfx_YELLOW_BALLOON[] = {
+    0x140
+};
+
+const u16 DecorGfx_RED_TENT[] = {
+    0x30,
+    0x31,
+    0x32,
+    0x38,
+    0x39,
+    0x3A,
+    0x40,
+    0x41,
+    0x3B
+};
+
+const u16 DecorGfx_BLUE_TENT[] = {
+    0x48,
+    0x49,
+    0x68,
+    0x50,
+    0x51,
+    0x70,
+    0x58,
+    0x59,
+    0x69
+};
+
+const u16 DecorGfx_SOLID_BOARD[] = {
+    0x34,
+    0x3C
+};
+
+const u16 DecorGfx_SLIDE[] = {
+    0x35,
+    0x36,
+    0x3D,
+    0x3E,
+    0x63,
+    0x64,
+    0x6F,
+    0x77
+};
+
+const u16 DecorGfx_FENCE_LENGTH[] = {
+    0x33
+};
+
+const u16 DecorGfx_FENCE_WIDTH[] = {
+    0x2C
+};
+
+const u16 DecorGfx_TIRE[] = {
+    0x80,
+    0x81,
+    0x88,
+    0x89
+};
+
+const u16 DecorGfx_STAND[] = {
+    0x6A,
+    0x6B,
+    0x6C,
+    0x6D,
+    0x72,
+    0x73,
+    0x74,
+    0x75
+};
+
+const u16 DecorGfx_MUD_BALL[] = {
+    0x28
+};
+
+const u16 DecorGfx_BREAKABLE_DOOR[] = {
+    0x37,
+    0x3F
+};
+
+const u16 DecorGfx_SAND_ORNAMENT[] = {
+    0x85,
+    0x8D
+};
+
+const u16 DecorGfx_SILVER_SHIELD[] = {
+    0xD6,
+    0xDE
+};
+
+const u16 DecorGfx_GOLD_SHIELD[] = {
+    0x12E,
+    0x136
+};
+
+const u16 DecorGfx_GLASS_ORNAMENT[] = {
+    0x82,
+    0x8A
+};
+
+const u16 DecorGfx_TV[] = {
+    0xF4
+};
+
+const u16 DecorGfx_ROUND_TV[] = {
+    0xF5
+};
+
+const u16 DecorGfx_CUTE_TV[] = {
+    0xF6
+};
+
+const u16 DecorGfx_GLITTER_MAT[] = {
+    0x60
+};
+
+const u16 DecorGfx_JUMP_MAT[] = {
+    0x61
+};
+
+const u16 DecorGfx_SPIN_MAT[] = {
+    0x62
+};
+
+const u16 DecorGfx_C_LOW_NOTE_MAT[] = {
+    0x78
+};
+
+const u16 DecorGfx_D_NOTE_MAT[] = {
+    0x79
+};
+
+const u16 DecorGfx_E_NOTE_MAT[] = {
+    0x7A
+};
+
+const u16 DecorGfx_F_NOTE_MAT[] = {
+    0x7B
+};
+
+const u16 DecorGfx_G_NOTE_MAT[] = {
+    0x7C
+};
+
+const u16 DecorGfx_A_NOTE_MAT[] = {
+    0x7D
+};
+
+const u16 DecorGfx_B_NOTE_MAT[] = {
+    0x7E
+};
+
+const u16 DecorGfx_C_HIGH_NOTE_MAT[] = {
+    0xB3
+};
+
+const u16 DecorGfx_SURF_MAT[] = {
+    0x42,
+    0x43,
+    0x44,
+    0x4A,
+    0x4B,
+    0x4C,
+    0x52,
+    0x53,
+    0x54
+};
+
+const u16 DecorGfx_THUNDER_MAT[] = {
+    0x45,
+    0x46,
+    0x47,
+    0x4D,
+    0x4E,
+    0x4F,
+    0x55,
+    0x56,
+    0x57
+};
+
+const u16 DecorGfx_FIRE_BLAST_MAT[] = {
+    0x5A,
+    0x5B,
+    0x5C,
+    0x5D,
+    0x5E,
+    0x5F,
+    0x65,
+    0x66,
+    0x67
+};
+
+const u16 DecorGfx_POWDER_SNOW_MAT[] = {
+    0x100,
+    0x101,
+    0x102,
+    0x108,
+    0x109,
+    0x10A,
+    0x110,
+    0x111,
+    0x112
+};
+
+const u16 DecorGfx_ATTRACT_MAT[] = {
+    0x103,
+    0x104,
+    0x105,
+    0x10B,
+    0x10C,
+    0x10D,
+    0x113,
+    0x114,
+    0x115
+};
+
+const u16 DecorGfx_FISSURE_MAT[] = {
+    0x106,
+    0x107,
+    0x118,
+    0x10E,
+    0x10F,
+    0x120,
+    0x116,
+    0x117,
+    0x128
+};
+
+const u16 DecorGfx_SPIKES_MAT[] = {
+    0x119,
+    0x11A,
+    0x11B,
+    0x121,
+    0x122,
+    0x123,
+    0x129,
+    0x12A,
+    0x12B
+};
+
+const u16 DecorGfx_BALL_POSTER[] = {
+    0x130
+};
+
+const u16 DecorGfx_GREEN_POSTER[] = {
+    0x131
+};
+
+const u16 DecorGfx_RED_POSTER[] = {
+    0x132
+};
+
+const u16 DecorGfx_BLUE_POSTER[] = {
+    0x133
+};
+
+const u16 DecorGfx_CUTE_POSTER[] = {
+    0x134
+};
+
+const u16 DecorGfx_PIKA_POSTER[] = {
+    0x11C,
+    0x11D
+};
+
+const u16 DecorGfx_LONG_POSTER[] = {
+    0x11E,
+    0x11F
+};
+
+const u16 DecorGfx_SEA_POSTER[] = {
+    0x124,
+    0x125
+};
+
+const u16 DecorGfx_SKY_POSTER[] = {
+    0x126,
+    0x127
+};
+
+const u16 DecorGfx_KISS_POSTER[] = {
+    0x12C,
+    0x12D
+};
+
+const u16 DecorGfx_PICHU_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_PIKACHU_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_MARILL_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_TOGEPI_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_CYNDAQUIL_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_CHIKORITA_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_TOTODILE_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_JIGGLYPUFF_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_MEOWTH_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_CLEFAIRY_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_DITTO_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SMOOCHUM_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_TREECKO_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_TORCHIC_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_MUDKIP_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_DUSKULL_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_WYNAUT_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_BALTOY_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_KECLEON_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_AZURILL_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SKITTY_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SWABLU_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_GULPIN_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_LOTAD_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SEEDOT_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_PIKA_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_ROUND_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_KISS_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_ZIGZAG_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SPIN_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_DIAMOND_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_BALL_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_GRASS_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_FIRE_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_WATER_CUSHION[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_SNORLAX_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_RHYDON_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_LAPRAS_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_VENUSAUR_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_CHARIZARD_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_BLASTOISE_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_WAILMER_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_REGIROCK_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_REGICE_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
+
+const u16 DecorGfx_REGISTEEL_DOLL[] = {
+    OBJ_EVENT_GFX_ITEM_BALL
+};
diff --git a/src/decoration.c b/src/decoration.c
new file mode 100644
index 000000000..4903735f0
--- /dev/null
+++ b/src/decoration.c
@@ -0,0 +1,7 @@
+#include "global.h"
+#include "decoration.h"
+#include "constants/decorations.h"
+
+#include "data/decoration/tiles.h"
+#include "data/decoration/description.h"
+#include "data/decoration/header.h"
diff --git a/src/event_object_lock.c b/src/event_object_lock.c
index a72845ac7..aa9a99895 100644
--- a/src/event_object_lock.c
+++ b/src/event_object_lock.c
@@ -28,7 +28,7 @@ bool8 sub_8069590(void)
         return FALSE;
     else
     {
-        sub_805C780();
+        StopPlayerAvatar();
         return TRUE;
     }
 }
@@ -65,7 +65,7 @@ bool8 sub_8069648(void)
         return FALSE;
     else
     {
-        sub_805C780();
+        StopPlayerAvatar();
         return TRUE;
     }
 }
diff --git a/src/field_control_avatar.c b/src/field_control_avatar.c
index ee413df2d..286f7519a 100644
--- a/src/field_control_avatar.c
+++ b/src/field_control_avatar.c
@@ -308,7 +308,7 @@ void FieldInput_HandleCancelSignpost(struct FieldInput * input)
         {
             if (input->dpadDirection != 0 && GetPlayerFacingDirection() != input->dpadDirection)
             {
-                if (sub_80699D4() == TRUE)
+                if (IsMsgBoxWalkawayDisabled() == TRUE)
                     return;
                 if (input->dpadDirection == DIR_NORTH)
                     RegisterQuestLogInput(QL_INPUT_UP);
@@ -657,9 +657,9 @@ static bool8 TryStartStepCountScript(u16 metatileBehavior)
 
     if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior))
     {
-        if (sub_810C4EC() == TRUE)
+        if (UpdateVsSeekerStepCounter() == TRUE)
         {
-            ScriptContext1_SetupScript(gUnknown_81A8CED);
+            ScriptContext1_SetupScript(EventScript_VsSeekerChargingDone);
             return TRUE;
         }
         else if (UpdatePoisonStepCounter() == TRUE)
@@ -1086,7 +1086,7 @@ void sub_806DE70(u16 x, u16 y)
         {
             if (events[i].x + 7 == x && events[i].y + 7 == y)
             {
-                sub_8112364();
+                QuestLog_OnInteractionWithSpecialNpc();
                 ScriptContext1_SetupScript(events[i].script);
                 ScriptContext2_Enable();
             }
diff --git a/src/field_effect.c b/src/field_effect.c
index c0d7d3463..b8269ae46 100644
--- a/src/field_effect.c
+++ b/src/field_effect.c
@@ -2889,7 +2889,7 @@ u8 FldEff_UseSurf(void)
     u8 taskId = CreateTask(Task_FldEffUseSurf, 0xff);
     gTasks[taskId].data[15] = gFieldEffectArguments[0];
     Overworld_ClearSavedMusic();
-    if (sub_8056124(MUS_NAMINORI))
+    if (Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI))
         Overworld_ChangeMusicTo(MUS_NAMINORI);
     return FALSE;
 }
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
index 6b51e7bc2..7e3ba59fe 100644
--- a/src/field_player_avatar.c
+++ b/src/field_player_avatar.c
@@ -66,7 +66,6 @@ static void PlayerNotOnBikeNotMoving(u8 direction, u16 heldKeys);
 static void PlayerNotOnBikeTurningInPlace(u8 direction, u16 heldKeys);
 static void PlayerNotOnBikeMoving(u8 direction, u16 heldKeys);
 static u8 CheckForPlayerAvatarCollision(u8 direction);
-u8 CheckForObjectEventCollision(struct ObjectEvent * objectEvent, s16 x, s16 y, u8 direction, u8 metatileBehavior);
 static bool8 CanStopSurfing(s16 x, s16 y, u8 direction);
 static bool8 ShouldJumpLedge(s16 x, s16 y, u8 direction);
 static bool8 TryPushBoulder(s16 x, s16 y, u8 direction);
@@ -722,7 +721,7 @@ static void PlayerAvatarTransition_Bike(struct ObjectEvent * playerObjEvent)
 {
     sub_8150474(1);
     sub_8150498(1);
-    sub_80BD620(0, 0);
+    InitPlayerAvatarBikeState(0, 0);
 }
 
 static void PlayerAvatarTransition_Surfing(struct ObjectEvent * playerObjEvent)
@@ -1115,7 +1114,7 @@ void sub_805C774(void)
     ForcedMovement_None();
 }
 
-void sub_805C780(void)
+void StopPlayerAvatar(void)
 {
     struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
 
@@ -1597,7 +1596,7 @@ void CreateStopSurfingTask_NoMusicChange(u8 direction)
     Task_StopSurfingInit(taskId);
 }
 
-void sub_805D1A8(void)
+void SeafoamIslandsB4F_CurrentDumpsPlayerOnLand(void)
 {
     if (gUnknown_3005E88 != 1 && gUnknown_3005E88 != 3)
     {
diff --git a/src/field_specials.c b/src/field_specials.c
index 657c80a40..4089f68e8 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -95,7 +95,7 @@ static u8 *const sStringVarPtrs[] = {
 
 void ShowDiploma(void)
 {
-    sub_8112364();
+    QuestLog_OnInteractionWithSpecialNpc();
     SetMainCallback2(CB2_ShowDiploma);
     ScriptContext2_Enable();
 }
@@ -187,7 +187,7 @@ u8 GetLeadMonFriendship(void)
 
 void ShowTownMap(void)
 {
-    sub_8112364();
+    QuestLog_OnInteractionWithSpecialNpc();
     sub_80BFF50(1, CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
diff --git a/src/ghost.c b/src/ghost.c
index 793c9838c..35dcd267b 100644
--- a/src/ghost.c
+++ b/src/ghost.c
@@ -984,7 +984,7 @@ static void sub_80B6468(u8 taskId)
         right = 240;
         top = 0;
         bottom = 112;
-        selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
         BeginNormalPaletteFade(selectedPalettes, 0, 16, 16, RGB(0, 0, 0));
         gTasks[taskId].func = sub_80B65F0;
     }
diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c
index 2284cbc3f..14f399f24 100644
--- a/src/hall_of_fame.c
+++ b/src/hall_of_fame.c
@@ -431,7 +431,7 @@ static void Task_Hof_InitTeamSaveData(u8 taskId)
     u16 i;
     struct HallofFameTeam* lastSavedTeam = (struct HallofFameTeam *)(gDecompressionBuffer);
 
-    sub_8112450();
+    SaveQuestLogData();
     if (!gHasHallOfFameRecords)
     {
         memset(gDecompressionBuffer, 0, 0x2000);
@@ -706,7 +706,7 @@ static void Task_Hof_HandleExit(u8 taskId)
 static void SetWarpsToRollCredits(void)
 {
     VarSet(VAR_MAP_SCENE_INDIGO_PLATEAU_EXTERIOR, 1);
-    FlagSet(FLAG_SPECIAL_FLAG_0x4000);
+    FlagSet(FLAG_DONT_SHOW_MAP_NAME_POPUP);
     gDisableMapMusicChangeOnMapLoad = 2;
     SetWarpDestination(MAP_GROUP(INDIGO_PLATEAU_EXTERIOR), MAP_NUM(INDIGO_PLATEAU_EXTERIOR), -1, 11, 6);
     DoWarp();
diff --git a/src/intro.c b/src/intro.c
index 837d4f905..ec15d7473 100644
--- a/src/intro.c
+++ b/src/intro.c
@@ -1,10 +1,6 @@
 #include "global.h"
+#include "gflib.h"
 #include "m4a.h"
-#include "malloc.h"
-#include "bg.h"
-#include "palette.h"
-#include "main.h"
-#include "gpu_regs.h"
 #include "task.h"
 #include "scanline_effect.h"
 #include "libgcnmultiboot.h"
@@ -12,7 +8,6 @@
 #include "link.h"
 #include "menu.h"
 #include "save.h"
-#include "sound.h"
 #include "new_game.h"
 #include "title_screen.h"
 #include "decompress.h"
@@ -21,29 +16,30 @@
 #include "constants/songs.h"
 #include "constants/species.h"
 
+struct IntroSequenceData;
+
+typedef void (*IntroCallback)(struct IntroSequenceData *);
+
 struct IntroSequenceData
 {
-    void (*field_0000)(struct IntroSequenceData *);
-    u8 field_0004;
-    u8 field_0005;
-    u8 field_0006;
-    u16 field_0008;
-    u16 field_000A;
-    u8 filler_000C[6];
-    u16 field_0012;
-    struct Sprite * field_0014;
-    struct Sprite * field_0018;
-    struct Sprite * field_001C;
-    struct Sprite * field_0020;
-    struct Sprite * field_0024;
-    struct Sprite * field_0028[4];
+    IntroCallback callback;
+    u8 state;
+    u8 taskId;
+    bool8 gengarAttackLanded;
+    u16 data[6];
+    struct Sprite * gameFreakLogoArtSprite;
+    struct Sprite * nidorinoAnimSprite;
+    struct Sprite * gengarStaticSprite;
+    struct Sprite * nidorinoStaticSprite;
+    struct Sprite * grassSprite;
+    struct Sprite * gengarBackSpriteArray[4];
     u8 filler_0038[0x4];
-    u8 field_003C[0x400];
-    u8 field_043C[0x400];
+    u8 gamefreakLogoArtSpriteTiles[0x400];
+    u8 gamefreakTextBitmap[0x400];
     u8 filler_083C[0x2080];
 }; // size: 0x28BC
 
-static EWRAM_DATA struct GcmbStruct gUnknown_203AAD4 = {0};
+static EWRAM_DATA struct GcmbStruct sGcmb = {0};
 static EWRAM_DATA u16 gUnknown_203AB00 = 0;
 static EWRAM_DATA u16 gUnknown_203AB02 = 0;
 static EWRAM_DATA u16 gUnknown_203AB04 = 0;
@@ -63,182 +59,177 @@ static EWRAM_DATA u16 gUnknown_203AB1E = 0;
 static EWRAM_DATA u16 gUnknown_203AB20 = 0;
 static EWRAM_DATA u16 gUnknown_203AB22 = 0;
 static EWRAM_DATA u16 gUnknown_203AB24 = 0;
-static EWRAM_DATA u16 gUnknown_203AB26 = 0;
-static EWRAM_DATA u32 gUnknown_203AB28 = 0;
-static EWRAM_DATA s16 gUnknown_203AB2C = 0;
-static EWRAM_DATA u16 gUnknown_203AB2E = 0;
-static EWRAM_DATA u32 gUnknown_203AB30 = 0;
-
-static void sub_80EC870(void);
-static void sub_80EC9D4(void);
-static void sub_80EC9EC(void);
-static void sub_80ECA00(void);
-static void sub_80ECA70(void);
-static void sub_80ECAB0(u8 taskId);
-static void sub_80ECAA8(struct IntroSequenceData * ptr, void (*cb)(struct IntroSequenceData *));
-static void sub_80ECAF0(struct IntroSequenceData * ptr);
-static void sub_80ECB98(struct IntroSequenceData * ptr);
-static void sub_80ECC3C(struct IntroSequenceData * ptr);
-static void sub_80ECCA8(struct IntroSequenceData * ptr);
-static void sub_80ECD60(struct IntroSequenceData * ptr);
-static void sub_80ECEA4(struct IntroSequenceData * ptr);
-static void sub_80ED0AC(u8 taskId);
-static void sub_80ED118(void);
-static void sub_80ED140(u8 taskId);
-static void sub_80ED188(struct IntroSequenceData * ptr);
-static void sub_80ED40C(u8 taskId);
-static void sub_80ED428(u8 taskId);
-static void sub_80ED444(struct IntroSequenceData * ptr);
-static void sub_80ED4A0(struct IntroSequenceData * ptr);
-static void sub_80ED4C0(struct IntroSequenceData * ptr);
-static void sub_80ED6D8(void);
-static void sub_80ED714(u8 taskId);
-static void sub_80ED7D4(struct IntroSequenceData * ptr);
-static void sub_80ED818(struct Sprite * sprite);
-static void sub_80ED898(struct IntroSequenceData * ptr);
-static void sub_80EDAF0(struct IntroSequenceData * ptr);
-static void sub_80EDB70(struct IntroSequenceData * ptr);
-static void sub_80EDBAC(struct IntroSequenceData * ptr);
-static void sub_80EDBE8(struct IntroSequenceData * ptr);
-static void sub_80EDC40(void);
-static void sub_80EDDF0(void);
-static void sub_80EDE04(u8 taskId);
-static void sub_80EDED8(void);
-static void sub_80EDEEC(u8 taskId);
-static struct Sprite * sub_80EDF68(void);
-static void sub_80EDF94(struct IntroSequenceData * ptr);
-static void sub_80EE024(u8 taskId);
-static void sub_80EE160(void);
-static void sub_80EE1C4(struct Sprite * sprite);
-static void sub_80EE200(u8 taskId);
-static void sub_80EE29C(struct Sprite * sprite);
-static void sub_80EE350(struct Sprite * sprite);
-static void sub_80EE40C(struct Sprite * sprite);
-static void sub_80EE4DC(struct Sprite * sprite);
-static void sub_80EE4F8(struct IntroSequenceData * ptr);
-static void sub_80EE528(struct Sprite * sprite, s16 a1, s16 a2, u16 a3);
-static void sub_80EE580(struct Sprite * sprite);
-static bool32 sub_80EE5C8(struct IntroSequenceData * ptr);
-static void sub_80EE5E4(struct IntroSequenceData * ptr);
-static void sub_80EE610(struct Sprite * sprite);
-static void sub_80EE6A4(struct IntroSequenceData * ptr);
-static void sub_80EE704(struct Sprite * sprite);
-static bool8 sub_80EE850(struct IntroSequenceData * ptr);
-static void sub_80EE864(s16 a1, s16 a2, s16 a3);
-static void sub_80EE8E4(struct Sprite * sprite);
-static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3);
-static void sub_80EE9D4(struct Sprite * sprite);
-static void sub_80EEA94(struct IntroSequenceData * ptr);
-static void sub_80EEB08(struct Sprite * sprite);
-static void sub_80EEBE4(void);
+
+static void CB2_SetUpIntro(void);
+static void CB2_Intro(void);
+static void VBlankCB_Intro(void);
+static void Intro_ResetGpuRegs(void);
+static void StartIntroSequence(void);
+static void Task_CallIntroCallback(u8 taskId);
+static void SetIntroCB(struct IntroSequenceData * ptr, IntroCallback cb);
+static void IntroCB_Init(struct IntroSequenceData * ptr);
+static void IntroCB_OpenWin1ToTheaterDimensions(struct IntroSequenceData * ptr);
+static void IntroCB_GameFreakStar(struct IntroSequenceData * ptr);
+static void IntroCB_GameFreakScene_RevealGameFreakText(struct IntroSequenceData * ptr);
+static void IntroCB_GameFreakScene_CreateGameFreakLogo(struct IntroSequenceData * ptr);
+static void IntroCB_FightScene(struct IntroSequenceData * ptr);
+static void Task_FightScene1_GrassyFieldAnim(u8 taskId);
+static void FightScene1_SignalEndGrassyFieldAnim(void);
+static void Task_FightScene1_ZoomEffect(u8 taskId);
+static void IntroCB_FightScene2(struct IntroSequenceData * ptr);
+static void Task_FightScene2_CameraHorizPanEffect(u8 taskId);
+static void Task_FightScene2_CameraVertPanEffect(u8 taskId);
+static void CreateMonStaticSprites(struct IntroSequenceData * ptr);
+static void DestroyStaticMonSprites(struct IntroSequenceData * ptr);
+static void IntroCB_FightScene3(struct IntroSequenceData * ptr);
+static void FightScene3_StartBg1Scroll(void);
+static void Task_FightScene3_ForestBgScroll(u8 taskId);
+static void CreateGrassSprite(struct IntroSequenceData * ptr);
+static void SpriteCB_Grass(struct Sprite * sprite);
+static void IntroCB_FightScene4(struct IntroSequenceData * ptr);
+static void CreateGengarBackSprite(struct IntroSequenceData * ptr);
+static void FightScene4_StartNidorinoAffineAnim(struct IntroSequenceData * ptr);
+static void FightScene4_StartGengarAffineAnim(struct IntroSequenceData * ptr);
+static void IntroCB_CleanUp(struct IntroSequenceData * ptr);
+static void GameFreakScene_LoadGfxCreateStar(void);
+static void GameFreakScene_StartTrailingSparkleSpawner(void);
+static void Task_GameFreakScene_TrailingSparkleSpawner(u8 taskId);
+static void GameFreakScene_StartRevealGameFreakTextSparklesSpawner(void);
+static void Task_RevealGameFreakTextSparklesSpawner(u8 taskId);
+static struct Sprite * CreateGameFreakLogoArtSprite(void);
+static void FightScene4_StartGengarAttack(struct IntroSequenceData * ptr);
+static void Task_FightScene4_GengarAttack(u8 taskId);
+static void FightScene4_CreateGengarSwipeSprites(void);
+static void SpriteCB_GengarSwipe(struct Sprite * sprite);
+static void Task_FightScene3_Bg0Scroll(u8 taskId);
+static void SpriteCB_LargeStar(struct Sprite * sprite);
+static void SpriteCB_TrailingSparkles(struct Sprite * sprite);
+static void SpriteCB_TrailingSparkles2(struct Sprite * sprite);
+static void SpriteCB_RevealGameFreakTextSparkles(struct Sprite * sprite);
+static void CreateNidorinoAnimSprite(struct IntroSequenceData * ptr);
+static void StartNidorinoAnimSpriteSlideIn(struct Sprite * sprite, s16 x0, s16 x1, u16 speed);
+static void SpriteCB_NidorinoAnimSpriteSlideIn(struct Sprite * sprite);
+static bool32 IsNidorinoAnimSpriteSlideInRunning(struct IntroSequenceData * ptr);
+static void FightScene4_NidorinoRearsUp(struct IntroSequenceData * ptr);
+static void SpriteCB_NidorinoRearsUp(struct Sprite * sprite);
+static void FightScene4_StartNidorinoRecoilAnim(struct IntroSequenceData * ptr);
+static void SpriteCB_NidorinoRecoil(struct Sprite * sprite);
+static bool8 FightScene4_NidorinoAnimIsRunning(struct IntroSequenceData * ptr);
+static void CreateNidorinoRecoilDustSprites(s16 a1, s16 a2, s16 a3);
+static void SpriteCB_NidorinoRecoilDust(struct Sprite * sprite);
+static void StartSpriteHopToPosAnim(struct Sprite * sprite, u16 a1, s16 a2, u8 a3);
+static void SpriteCB_HopToPos(struct Sprite * sprite);
+static void StartNidorinoAnim_LaunchSelfAtGengarAnim(struct IntroSequenceData * ptr);
+static void SpriteCB_NidorinoAnim_LaunchSelfAtGengar(struct Sprite * sprite);
+static void LoadFightSceneSpriteTilesAndPals(void);
 #if REVISION >= 1
-static void sub_rev1_80EDFAC(void);
+static void Rev1_GameFreakScene_CreatePresentsText(void);
 #else
-#define sub_rev1_80EDFAC()
+#define Rev1_GameFreakScene_CreatePresentsText()
 #endif
 
 extern const u32 gMultiBootProgram_PokemonColosseum_Start[];
 
-static const u16 gUnknown_8402260[] = INCBIN_U16("graphics/intro/unk_8402260.gbapal");
-static const u8 gUnknown_8402280[] = INCBIN_U8("graphics/intro/unk_8402280.4bpp.lz");
-static const u8 gUnknown_84024E4[] = INCBIN_U8("graphics/intro/unk_84024E4.bin.lz");
-static const u16 gUnknown_8402630[] = INCBIN_U16("graphics/intro/unk_8402630.gbapal");
-static const u8 gUnknown_8402650[] = INCBIN_U8("graphics/intro/unk_8402650.4bpp.lz");
-static const u8 gUnknown_8402668[] = INCBIN_U8("graphics/intro/unk_8402668.bin.lz");
-static const u16 gUnknown_840270C[] = INCBIN_U16("graphics/intro/unk_840270C.gbapal");
-static const u8 gUnknown_840272C[] = INCBIN_U8("graphics/intro/unk_840272C.4bpp.lz");
-static const u32 gUnknown_84028F8[] = INCBIN_U32("graphics/intro/unk_84028F8.bin.lz");
-static const u16 gUnknown_8402A44[] = INCBIN_U16("graphics/intro/unk_8402A64.gbapal");
-static const u32 gUnknown_8402A64[] = INCBIN_U32("graphics/intro/unk_8402A64.4bpp.lz");
-static const u16 gUnknown_8402ABC[] = INCBIN_U16("graphics/intro/unk_8402ADC.gbapal");
-static const u32 gUnknown_8402ADC[] = INCBIN_U32("graphics/intro/unk_8402ADC.4bpp.lz");
-static const u32 gUnknown_8402B2C[] = INCBIN_U32("graphics/intro/unk_8402B2C.4bpp.lz");
-static const u32 gUnknown_8402CD4[] = INCBIN_U32("graphics/intro/unk_8402CD4.4bpp.lz");
-static const u16 gUnknown_8402D34[] = INCBIN_U16("graphics/intro/unk_8402D34.gbapal");
-static const u8 gUnknown_8402D54[] = INCBIN_U8("graphics/intro/unk_8402D54.4bpp.lz");
-static const u8 gUnknown_8403FE8[] = INCBIN_U8("graphics/intro/unk_8403FE8.bin.lz");
-static const u16 gUnknown_84048CC[] = INCBIN_U16("graphics/intro/unk_84048CC.gbapal");
-static const u8 gUnknown_84048EC[] = INCBIN_U8("graphics/intro/unk_84048EC.4bpp.lz");
-static const u8 gUnknown_8404F7C[] = INCBIN_U8("graphics/intro/unk_8404F7C.bin.lz");
-static const u16 gUnknown_84053B4[] = INCBIN_U16("graphics/intro/unk_84053B4.gbapal");
-static const u8 gUnknown_8405414[] = INCBIN_U8("graphics/intro/unk_8405414.4bpp.lz");
-static const u8 gUnknown_8405890[] = INCBIN_U8("graphics/intro/unk_8405890.bin.lz");
-static const u16 gUnknown_8405B08[] = INCBIN_U16("graphics/intro/unk_8405B08.gbapal");
-static const u8 gUnknown_8405B28[] = INCBIN_U8("graphics/intro/unk_8405B28.4bpp.lz");
-static const u8 gUnknown_8405CDC[] = INCBIN_U8("graphics/intro/unk_8405CDC.bin.lz");
-static const u16 gUnknown_8405DA4[] = INCBIN_U16("graphics/intro/unk_8405DA4.gbapal");
-static const u8 gUnknown_8405DC4[] = INCBIN_U8("graphics/intro/unk_8405DC4.4bpp.lz");
-static const u8 gUnknown_840644C[] = INCBIN_U8("graphics/intro/unk_840644C.bin.lz");
-static const u16 gUnknown_8406634[] = INCBIN_U16("graphics/intro/unk_8406634.gbapal");
-static const u8 gUnknown_8406654[] = INCBIN_U8("graphics/intro/unk_8406654.4bpp.lz");
-static const u8 gUnknown_84071D0[] = INCBIN_U8("graphics/intro/unk_84071D0.bin.lz");
-static const u16 gUnknown_8407430[] = INCBIN_U16("graphics/intro/unk_8407430.gbapal");
-static const u8 gUnknown_8407470[] = INCBIN_U8("graphics/intro/unk_8407470.4bpp.lz");
-static const u8 gUnknown_8407A50[] = INCBIN_U8("graphics/intro/unk_8407A50.bin.lz");
-static const u8 gUnknown_8407B9C[] = INCBIN_U8("graphics/intro/unk_8407B9C.4bpp.lz");
-static const u8 gUnknown_8408D98[] = INCBIN_U8("graphics/intro/unk_8408D98.bin.lz");
-static const u32 gUnknown_840926C[] = INCBIN_U32("graphics/intro/unk_840926C.4bpp.lz");
-static const u16 gUnknown_84096AC[] = INCBIN_U16("graphics/intro/unk_84096AC.gbapal");
-static const u32 gUnknown_84096CC[] = INCBIN_U32("graphics/intro/unk_84096CC.4bpp.lz");
-static const u16 gUnknown_8409A1C[] = INCBIN_U16("graphics/intro/unk_8409A1C.gbapal");
-static const u32 gUnknown_8409A3C[] = INCBIN_U32("graphics/intro/unk_8409A3C.4bpp.lz");
-static const u32 gUnknown_8409D20[] = INCBIN_U32("graphics/intro/unk_8409D20.4bpp.lz");
-static const u32 gUnknown_840A3E4[] = INCBIN_U32("graphics/intro/unk_840A3E4.4bpp.lz");
-static const u16 gUnknown_840B834[] = INCBIN_U16("graphics/intro/unk_840B834.gbapal");
-static const u16 gUnknown_840B854[] = INCBIN_U16("graphics/intro/unk_840B854.gbapal");
-static const u32 gUnknown_840B874[] = INCBIN_U32("graphics/intro/unk_840B874.4bpp.lz");
-static const u32 gUnknown_840BAE0[] = INCBIN_U32("graphics/intro/unk_840BAE0.4bpp.lz");
-
-static const struct BgTemplate gUnknown_840BB80[] = {
+static const u16 sCopyrightGraphicsPal[] = INCBIN_U16("graphics/intro/unk_8402260.gbapal");
+static const u8 sCopyrightGraphicsTiles[] = INCBIN_U8("graphics/intro/unk_8402280.4bpp.lz");
+static const u8 sCopyrightGraphicsMap[] = INCBIN_U8("graphics/intro/unk_84024E4.bin.lz");
+static const u16 sBg3Pal_GameFreakPresents[] = INCBIN_U16("graphics/intro/unk_8402630.gbapal");
+static const u8 sBg3Tiles_GameFreakPresents[] = INCBIN_U8("graphics/intro/unk_8402650.4bpp.lz");
+static const u8 sBg3Map_GameFreakPresents[] = INCBIN_U8("graphics/intro/unk_8402668.bin.lz");
+static const u16 sSpritePals_GameFreakPresents[] = INCBIN_U16("graphics/intro/unk_840270C.gbapal");
+static const u8 sBlit_GameFreakText[] = INCBIN_U8("graphics/intro/unk_840272C.4bpp.lz");
+static const u32 sSpriteTiles_GameFreakLogoArt[] = INCBIN_U32("graphics/intro/unk_84028F8.4bpp.lz");
+static const u16 sSpritePals_LargeStar[] = INCBIN_U16("graphics/intro/unk_8402A64.gbapal");
+static const u32 sSpriteTiles_LargeStar[] = INCBIN_U32("graphics/intro/unk_8402A64.4bpp.lz");
+static const u16 sSpritePals_Sparkles[] = INCBIN_U16("graphics/intro/unk_8402ADC.gbapal");
+static const u32 sSpriteTiles_TrailingSparkles[] = INCBIN_U32("graphics/intro/unk_8402ADC.4bpp.lz");
+static const u32 sSpriteTiles_RevealGameFreakTextSparkles[] = INCBIN_U32("graphics/intro/unk_8402B2C.4bpp.lz");
+static const u32 sSpriteTiles_PresentsText[] = INCBIN_U32("graphics/intro/unk_8402CD4.4bpp.lz");
+static const u16 sBg0Pal_FightScene1[] = INCBIN_U16("graphics/intro/unk_8402D34.gbapal");
+static const u8 sBg0Tiles_FightScene1[] = INCBIN_U8("graphics/intro/unk_8402D54.4bpp.lz");
+static const u8 sBg0Map_FightScene1[] = INCBIN_U8("graphics/intro/unk_8403FE8.bin.lz");
+static const u16 sBg1Pal_FightScene1[] = INCBIN_U16("graphics/intro/unk_84048CC.gbapal");
+static const u8 sBg1Tiles_FightScene1[] = INCBIN_U8("graphics/intro/unk_84048EC.4bpp.lz");
+static const u8 sBg1Map_FightScene1[] = INCBIN_U8("graphics/intro/unk_8404F7C.bin.lz");
+static const u16 sBg3Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_84053B4.gbapal");
+static const u8 sBg3Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405414.4bpp.lz");
+static const u8 sBg3Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405890.bin.lz");
+static const u16 sBg0Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_8405B08.gbapal");
+static const u8 sBg0Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405B28.4bpp.lz");
+static const u8 sBg0Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405CDC.bin.lz");
+static const u16 sSpritePals_Gengar[] = INCBIN_U16("graphics/intro/unk_8405DA4.gbapal");
+static const u8 sBg2Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405DC4.4bpp.lz");
+static const u8 sBg2Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_840644C.bin.lz");
+static const u16 sBg1Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_8406634.gbapal");
+static const u8 sBg1Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8406654.4bpp.lz");
+static const u8 sBg1Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_84071D0.bin.lz");
+static const u16 sBg1Pal_FightScene3[] = INCBIN_U16("graphics/intro/unk_8407430.gbapal");
+static const u8 sBg1Tiles_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407470.4bpp.lz");
+static const u8 sBg1Map_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407A50.bin.lz");
+static const u8 sBg0Tiles_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407B9C.4bpp.lz");
+static const u8 sBg0Map_FightScene3[] = INCBIN_U8("graphics/intro/unk_8408D98.bin.lz");
+static const u32 sSpriteTiles_GengarStatic[] = INCBIN_U32("graphics/intro/unk_840926C.4bpp.lz");
+static const u16 sSpritePals_Nidorino[] = INCBIN_U16("graphics/intro/unk_84096AC.gbapal");
+static const u32 sSpriteTiles_NidorinoStatic[] = INCBIN_U32("graphics/intro/unk_84096CC.4bpp.lz");
+static const u16 sSpritePals_Grass[] = INCBIN_U16("graphics/intro/unk_8409A1C.gbapal");
+static const u32 sSpriteTiles_Grass[] = INCBIN_U32("graphics/intro/unk_8409A3C.4bpp.lz");
+static const u32 sSpriteTiles_GengarBack[] = INCBIN_U32("graphics/intro/unk_8409D20.4bpp.lz");
+static const u32 sSpriteTiles_NidorinoAnim[] = INCBIN_U32("graphics/intro/unk_840A3E4.4bpp.lz");
+static const u16 sSpritePals_GengarSwipe[] = INCBIN_U16("graphics/intro/unk_840B834.gbapal");
+static const u16 sSpritePals_NidorinoRecoilDust[] = INCBIN_U16("graphics/intro/unk_840B854.gbapal");
+static const u32 sSpriteTiles_GengarSwipe[] = INCBIN_U32("graphics/intro/unk_840B874.4bpp.lz");
+static const u32 sSpriteTiles_NidorinoRecoilDust[] = INCBIN_U32("graphics/intro/unk_840BAE0.4bpp.lz");
+
+static const struct BgTemplate sBgTemplates_GameFreakScene[] = {
 	{ 3, 3, 31, 0, 0, 3, 0x000 },
 	{ 2, 3, 30, 0, 0, 2, 0x010 }
 };
 
-static const struct BgTemplate gUnknown_840BB88[] = {
+static const struct BgTemplate sBgTemplates_FightScene1[] = {
 	{ 0, 0, 28, 2, 0, 0, 0x000 },
 	{ 1, 1, 30, 2, 0, 0, 0x000 }
 };
 
-static const struct BgTemplate gUnknown_840BB90[] = {
+static const struct BgTemplate sBgTemplates_FightScene2[] = {
 	{ 3, 1, 30, 2, 0, 3, 0x000 },
 	{ 0, 0, 29, 0, 0, 0, 0x000 },
 	{ 2, 3, 27, 0, 0, 2, 0x000 },
 	{ 1, 2, 28, 0, 0, 1, 0x000 }
 };
 
-static const struct BgTemplate gUnknown_840BBA0[] = {
+static const struct BgTemplate sBgTemplates_FightScene3[] = {
 	{ 1, 0, 29, 0, 0, 1, 0x000 },
 	{ 0, 1, 30, 2, 0, 0, 0x000 }
 };
 
-static const struct WindowTemplate gUnknown_840BBA8[] = {
+static const struct WindowTemplate sWindowTemplate[] = {
 	{ 2, 6, 4, 18, 9, 0xD, 0x000 },
 	DUMMY_WIN_TEMPLATE
 };
 
-static const u8 gUnknown_840BBB8[][2] = {
+static const u8 sGengarBackSpritePos2UpdateMods[][2] = {
 	{0x3f, 0x3f},
 	{0x00, 0x3f},
 	{0x3f, 0x00},
 	{0x00, 0x00}
 };
 
-static const struct CompressedSpriteSheet gUnknown_840BBC0[] = {
-	{gUnknown_8402A64, 0x0080, 0},
-	{gUnknown_8402ADC, 0x0080, 1},
-	{gUnknown_8402B2C, 0x0800, 2},
-	{gUnknown_84028F8, 0x0400, 3},
-	{gUnknown_8402CD4, 0x0100, 4}
+static const struct CompressedSpriteSheet sSpriteSheets_GameFreakScene[] = {
+	{sSpriteTiles_LargeStar, 0x0080, 0},
+	{sSpriteTiles_TrailingSparkles, 0x0080, 1},
+	{sSpriteTiles_RevealGameFreakTextSparkles, 0x0800, 2},
+	{sSpriteTiles_GameFreakLogoArt, 0x0400, 3},
+	{sSpriteTiles_PresentsText, 0x0100, 4}
 };
 
-static const struct SpritePalette gUnknown_840BBE8[] = {
-	{gUnknown_8402A44, 0},
-	{gUnknown_8402ABC, 1},
-	{gUnknown_840270C, 3},
+static const struct SpritePalette sSpritePalettes_GameFreakScene[] = {
+	{sSpritePals_LargeStar, 0},
+	{sSpritePals_Sparkles, 1},
+	{sSpritePals_GameFreakPresents, 3},
 	{0}
 };
 
-static const struct Coords16 gUnknown_840BC08[] = {
+static const struct Coords16 sTrailingSparkleCoords[] = {
 	{0x0048, 0x0050},
 	{0x0088, 0x004a},
 	{0x00a8, 0x0050},
@@ -275,9 +266,9 @@ static const union AnimCmd *const gAnimCmdTable_840BC64[] = {
 	gAnimCmd_840BC50
 };
 
-static const struct SpriteTemplate gUnknown_840BC6C = {0, 0, &gOamData_840BC2C, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, sub_80EE29C};
+static const struct SpriteTemplate sSpriteTemplate_LargeStar = {0, 0, &gOamData_840BC2C, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCB_LargeStar};
 
-static const struct SpriteTemplate gUnknown_840BC84 = {1, 1, &gOamData_840BC34, gAnimCmdTable_840BC64, NULL, gDummySpriteAffineAnimTable, sub_80EE350};
+static const struct SpriteTemplate sSpriteTemplate_TrailingSparkles = {1, 1, &gOamData_840BC34, gAnimCmdTable_840BC64, NULL, gDummySpriteAffineAnimTable, SpriteCB_TrailingSparkles};
 
 static const struct OamData gOamData_840BC9C = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_2, .tileNum = 0x000, .priority = 2, .paletteNum = 0 };
 
@@ -293,15 +284,15 @@ static const union AnimCmd *const gAnimCmdTable_840BCB8[] = {
 	gAnimCmd_840BCA4
 };
 
-static const struct SpriteTemplate gUnknown_840BCBC = {2, 1, &gOamData_840BC9C, gAnimCmdTable_840BCB8, NULL, gDummySpriteAffineAnimTable, sub_80EE4DC};
+static const struct SpriteTemplate sSpriteTemplate_RevealGameFreakTextSparkles = {2, 1, &gOamData_840BC9C, gAnimCmdTable_840BCB8, NULL, gDummySpriteAffineAnimTable, SpriteCB_RevealGameFreakTextSparkles};
 
 static const struct OamData gOamData_840BCD4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_BLEND, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_V_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 3, .paletteNum = 0 };
 
-static const struct SpriteTemplate gUnknown_840BCDC = {3, 3, &gOamData_840BCD4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_GameFreakLogoArt = {3, 3, &gOamData_840BCD4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BCF4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_BLEND, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_H_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_1, .tileNum = 0x000, .priority = 3, .paletteNum = 0 };
 
-static const struct SpriteTemplate gUnknown_840BCFC = {4, 3, &gOamData_840BCF4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_PresentsText = {4, 3, &gOamData_840BCF4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BD14 = { .affineMode = ST_OAM_AFFINE_DOUBLE, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 };
 
@@ -330,7 +321,7 @@ static const union AnimCmd gAnimCmd_840BD3C[] = {
 	ANIMCMD_END
 };
 
-static const union AnimCmd *const gAnimCmdTable_840BD44[] = {
+static const union AnimCmd *const sAnimTable_NidorinoAnim[] = {
 	gAnimCmd_840BD1C,
 	gAnimCmd_840BD24,
 	gAnimCmd_840BD2C,
@@ -349,18 +340,18 @@ static const union AffineAnimCmd gAffineAnimCmd_840BD68[] = {
 	AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd *const gAffineAnimCmdTable_840BD80[] = {
+static const union AffineAnimCmd *const sAffineAnimTable_NidorinoAnim[] = {
 	gAffineAnimCmd_840BD58,
 	gAffineAnimCmd_840BD68
 };
 
-static const struct SpriteTemplate gUnknown_840BD88 = {5, 7, &gOamData_840BD14, gAnimCmdTable_840BD44, NULL, gAffineAnimCmdTable_840BD80, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_NidorinoAnim = {5, 7, &gOamData_840BD14, sAnimTable_NidorinoAnim, NULL, sAffineAnimTable_NidorinoAnim, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BDA0 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 };
 
-static const struct SpriteTemplate gUnknown_840BDA8 = {7, 7, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_NidorinoStatic = {7, 7, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
 
-static const struct SpriteTemplate gUnknown_840BDC0 = {6, 6, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_GengarStatic = {6, 6, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BDD8 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_H_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 0, .paletteNum = 0 };
 
@@ -380,7 +371,7 @@ static const union AnimCmd *const gAnimCmdTable_840BDF4[] = {
 	gAnimCmds_840BDE8
 };
 
-static const struct SpriteTemplate gUnknown_840BDFC = {8, 8, &gOamData_840BDD8, gAnimCmdTable_840BDF4, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_Grass = {8, 8, &gOamData_840BDD8, gAnimCmdTable_840BDF4, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BE14 = { .affineMode = ST_OAM_AFFINE_DOUBLE, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 };
 
@@ -411,7 +402,7 @@ static const union AnimCmd *const gAnimCmdTable_840BE3C[] = {
 	gAnimCmd_840BE34
 };
 
-static const struct SpriteTemplate gUnknown_840BE4C = {9, 6, &gOamData_840BE14, gAnimCmdTable_840BE3C, NULL, gAffineAnimCmdTable_840BD80, SpriteCallbackDummy};
+static const struct SpriteTemplate sSpriteTemplate_GengarBack = {9, 6, &gOamData_840BE14, gAnimCmdTable_840BE3C, NULL, sAffineAnimTable_NidorinoAnim, SpriteCallbackDummy};
 
 static const struct OamData gOamData_840BE64 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_V_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 };
 
@@ -432,7 +423,7 @@ static const union AnimCmd *const gAnimCmdTable_840BE84[] = {
 	gAnimCmd_840BE78
 };
 
-static const struct SpriteTemplate gUnknown_840BE8C = {10, 10, &gOamData_840BE64, gAnimCmdTable_840BE84, NULL, gDummySpriteAffineAnimTable, sub_80EE1C4};
+static const struct SpriteTemplate sSpriteTemplate_GengarSwipe = {10, 10, &gOamData_840BE64, gAnimCmdTable_840BE84, NULL, gDummySpriteAffineAnimTable, SpriteCB_GengarSwipe};
 
 static const struct OamData gOamData_840BEA4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_1, .tileNum = 0x000, .priority = 1, .paletteNum = 0 };
 
@@ -448,58 +439,60 @@ static const union AnimCmd *const gAnimCmdTable_840BEC0[] = {
 	gAnimCmd_840BEAC
 };
 
-static const struct SpriteTemplate gUnknown_840BEC4 = {11, 11, &gOamData_840BEA4, gAnimCmdTable_840BEC0, NULL, gDummySpriteAffineAnimTable, sub_80EE8E4};
+static const struct SpriteTemplate sSpriteTemplate_NidorinoRecoilDust = {11, 11, &gOamData_840BEA4, gAnimCmdTable_840BEC0, NULL, gDummySpriteAffineAnimTable, SpriteCB_NidorinoRecoilDust};
 
-static const struct CompressedSpriteSheet gUnknown_840BEDC[] = {
-	{gUnknown_840926C, 0x0800, 6},
-	{gUnknown_84096CC, 0x0800, 7},
-	{gUnknown_840A3E4, 0x2800, 5},
-	{gUnknown_8409A3C, 0x0800, 8},
-	{gUnknown_8409D20, 0x1800, 9},
-	{gUnknown_840B874, 0x0a00, 10},
-	{gUnknown_840BAE0, 0x0200, 11}
+static const struct CompressedSpriteSheet sFightSceneSpriteSheets[] = {
+	{sSpriteTiles_GengarStatic, 0x0800, 6},
+	{sSpriteTiles_NidorinoStatic, 0x0800, 7},
+	{sSpriteTiles_NidorinoAnim, 0x2800, 5},
+	{sSpriteTiles_Grass, 0x0800, 8},
+	{sSpriteTiles_GengarBack, 0x1800, 9},
+	{sSpriteTiles_GengarSwipe, 0x0a00, 10},
+	{sSpriteTiles_NidorinoRecoilDust, 0x0200, 11}
 };
 
 // POTENTIAL UB
-// This array is passed to LoadSpritePalettes in sub_80EEBE4.
+// This array is passed to LoadSpritePalettes in LoadFightSceneSpriteTilesAndPals.
 // LoadSpritePalettes uses a {0} entry to signal end of array.
 // Because such an entry is absent in this case, the function
 // continues reading into the next .rodata section.
-static const struct SpritePalette gUnknown_840BF14[] = {
-	{gUnknown_8405DA4, 6},
-	{gUnknown_84096AC, 7},
-	{gUnknown_8409A1C, 8},
-	{gUnknown_840B834, 10},
-	{gUnknown_840B854, 11},
-    // {0}
+static const struct SpritePalette sFightSceneSpritePalettes[] = {
+	{sSpritePals_Gengar, 6},
+	{sSpritePals_Nidorino, 7},
+	{sSpritePals_Grass, 8},
+	{sSpritePals_GengarSwipe, 10},
+	{sSpritePals_NidorinoRecoilDust, 11},
+#ifdef BUGFIX
+    {0}
+#endif
 };
 
-static void sub_80EC5A4(void)
+static void VBlankCB_Copyright(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
 }
 
-static void sub_80EC5B8(void)
+static void CB2_WaitFadeBeforeSetUpIntro(void)
 {
     if (!UpdatePaletteFade())
-        SetMainCallback2(sub_80EC870);
+        SetMainCallback2(CB2_SetUpIntro);
 }
 
-static void load_copyright_graphics(u16 a, u16 b, u16 c)
+static void load_copyright_graphics(u16 charBase, u16 screenBase, u16 palOffset)
 {
-    LZ77UnCompVram(gUnknown_8402280, (void *)BG_VRAM + a);
-    LZ77UnCompVram(gUnknown_84024E4, (void *)BG_VRAM + b);
-    LoadPalette(gUnknown_8402260, c, 0x20);
+    LZ77UnCompVram(sCopyrightGraphicsTiles, (void *)BG_VRAM + charBase);
+    LZ77UnCompVram(sCopyrightGraphicsMap, (void *)BG_VRAM + screenBase);
+    LoadPalette(sCopyrightGraphicsPal, palOffset, 0x20);
 }
 
 static void SerialCb_CopyrightScreen(void)
 {
-    GameCubeMultiBoot_HandleSerialInterrupt(&gUnknown_203AAD4);
+    GameCubeMultiBoot_HandleSerialInterrupt(&sGcmb);
 }
 
-static bool8 sub_80EC62C(void)
+static bool8 RunCopyrightScreen(void)
 {
     switch (gMain.state)
     {
@@ -516,26 +509,27 @@ static bool8 sub_80EC62C(void)
         DmaFill32(3, 0, OAM, OAM_SIZE);
         DmaFill16(3, 0, PLTT + sizeof(vu16), PLTT_SIZE - sizeof(vu16));
         ResetPaletteFade();
-        load_copyright_graphics(0, 0x3800, 0);
+        load_copyright_graphics(0 * BG_CHAR_SIZE, 7 * BG_SCREEN_SIZE, 0);
         ScanlineEffect_Stop();
         ResetTasks();
         ResetSpriteData();
-        FreeAllSpritePalettes();BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0xFFFF);
-        SetGpuReg(REG_OFFSET_BG0CNT, 0x700);
+        FreeAllSpritePalettes();
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0xFFFF);
+        SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(0) | BGCNT_16COLOR | BGCNT_SCREENBASE(7));
         EnableInterrupts(INTR_FLAG_VBLANK);
-        SetVBlankCallback(sub_80EC5A4);
+        SetVBlankCallback(VBlankCB_Copyright);
         SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON);
         SetSerialCallback(SerialCb_CopyrightScreen);
-        GameCubeMultiBoot_Init(&gUnknown_203AAD4);
+        GameCubeMultiBoot_Init(&sGcmb);
         // fallthrough
     default:
         UpdatePaletteFade();
         gMain.state++;
-        GameCubeMultiBoot_Main(&gUnknown_203AAD4);
+        GameCubeMultiBoot_Main(&sGcmb);
         break;
     case 140:
-        GameCubeMultiBoot_Main(&gUnknown_203AAD4);
-        if (gUnknown_203AAD4.gcmb_field_2 != 1)
+        GameCubeMultiBoot_Main(&sGcmb);
+        if (sGcmb.gcmb_field_2 != 1)
         {
             BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
             gMain.state++;
@@ -545,16 +539,17 @@ static bool8 sub_80EC62C(void)
         if (!UpdatePaletteFade())
         {
             gMain.state++;
-            if (gUnknown_203AAD4.gcmb_field_2 != 0)
+            if (sGcmb.gcmb_field_2 != 0)
             {
-                if (gUnknown_203AAD4.gcmb_field_2 == 2)
+                if (sGcmb.gcmb_field_2 == 2)
                 {
+                    // Gc6e
                     if (*((u32 *)0x020000AC) == 0x65366347)
                     {
                         CpuCopy16(gMultiBootProgram_PokemonColosseum_Start, (void *)EWRAM_START, 0x28000);
                         *((u32 *)0x020000AC) = 0x65366347;
                     }
-                    GameCubeMultiBoot_ExecuteProgram(&gUnknown_203AAD4);
+                    GameCubeMultiBoot_ExecuteProgram(&sGcmb);
                 }
             }
             else
@@ -567,7 +562,7 @@ static bool8 sub_80EC62C(void)
         break;
     case 142:
         ResetSerial();
-        SetMainCallback2(sub_80EC5B8);
+        SetMainCallback2(CB2_WaitFadeBeforeSetUpIntro);
         break;
     }
     return TRUE;
@@ -575,7 +570,7 @@ static bool8 sub_80EC62C(void)
 
 void c2_copyright_1(void)
 {
-    if (!sub_80EC62C())
+    if (!RunCopyrightScreen())
     {
         ResetMenuAndMonGlobals();
         Save_ResetSaveCounters();
@@ -586,12 +581,12 @@ void c2_copyright_1(void)
     }
 }
 
-void sub_80EC864(void)
+void CB2_CopyrightScreen(void)
 {
-    sub_80EC62C();
+    RunCopyrightScreen();
 }
 
-static void sub_80EC870(void)
+static void CB2_SetUpIntro(void)
 {
     switch (gMain.state)
     {
@@ -606,34 +601,34 @@ static void sub_80EC870(void)
         ResetSpriteData();
         ResetPaletteFade();
         ResetTempTileDataBuffers();
-        sub_80ECA00();
+        Intro_ResetGpuRegs();
         DmaFill16(3, 0, VRAM, VRAM_SIZE);
         DmaFill32(3, 0, OAM, OAM_SIZE);
         DmaFill16(3, 0, PLTT, PLTT_SIZE);
-        FillPalette(0, 0, 0x400);
-        ResetBgsAndClearDma3BusyFlags(0);
-        InitBgsFromTemplates(0, gUnknown_840BB80, NELEMS(gUnknown_840BB80));
+        FillPalette(RGB_BLACK, 0, 0x400);
+        ResetBgsAndClearDma3BusyFlags(FALSE);
+        InitBgsFromTemplates(0, sBgTemplates_GameFreakScene, NELEMS(sBgTemplates_GameFreakScene));
         break;
     case 1:
-        LoadPalette(gUnknown_8402630, 0x00, 0x20);
-        DecompressAndCopyTileDataToVram(3, gUnknown_8402650, 0, 0, 0);
-        DecompressAndCopyTileDataToVram(3, gUnknown_8402668, 0, 0, 1);
-        LoadPalette(gUnknown_840270C, 0xD0, 0x20);
+        LoadPalette(sBg3Pal_GameFreakPresents, 0x00, 0x20);
+        DecompressAndCopyTileDataToVram(3, sBg3Tiles_GameFreakPresents, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(3, sBg3Map_GameFreakPresents, 0, 0, 1);
+        LoadPalette(sSpritePals_GameFreakPresents, 0xD0, 0x20);
         break;
     case 2:
         if (!FreeTempTileDataBuffersIfPossible())
         {
-            sub_80ECA70();
+            StartIntroSequence();
             BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
-            SetMainCallback2(sub_80EC9D4);
-            SetVBlankCallback(sub_80EC9EC);
+            SetMainCallback2(CB2_Intro);
+            SetVBlankCallback(VBlankCB_Intro);
         }
         return;
     }
     gMain.state++;
 }
 
-static void sub_80EC9D4(void)
+static void CB2_Intro(void)
 {
     RunTasks();
     AnimateSprites();
@@ -641,14 +636,14 @@ static void sub_80EC9D4(void)
     UpdatePaletteFade();
 }
 
-static void sub_80EC9EC(void)
+static void VBlankCB_Intro(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
 }
 
-static void sub_80ECA00(void)
+static void Intro_ResetGpuRegs(void)
 {
     SetGpuReg(REG_OFFSET_DISPCNT, 0);
     SetGpuReg(REG_OFFSET_BLDCNT, 0);
@@ -665,53 +660,53 @@ static void sub_80ECA00(void)
     SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
 }
 
-static void sub_80ECA70(void)
+static void StartIntroSequence(void)
 {
     struct IntroSequenceData * ptr = Alloc(sizeof(struct IntroSequenceData));
-    sub_80ECAA8(ptr, sub_80ECAF0);
-    ptr->field_0005 = CreateTask(sub_80ECAB0, 3);
-    SetWordTaskArg(ptr->field_0005, 0, (uintptr_t)ptr);
+    SetIntroCB(ptr, IntroCB_Init);
+    ptr->taskId = CreateTask(Task_CallIntroCallback, 3);
+    SetWordTaskArg(ptr->taskId, 0, (uintptr_t)ptr);
 }
 
-static void sub_80ECAA8(struct IntroSequenceData * ptr, void (*cb)(struct IntroSequenceData *))
+static void SetIntroCB(struct IntroSequenceData * ptr, IntroCallback cb)
 {
-    ptr->field_0000 = cb;
-    ptr->field_0004 = 0;
+    ptr->callback = cb;
+    ptr->state = 0;
 }
 
-static void sub_80ECAB0(u8 taskId)
+static void Task_CallIntroCallback(u8 taskId)
 {
     struct IntroSequenceData * ptr = (void *)GetWordTaskArg(taskId, 0);
-    if (JOY_NEW(A_BUTTON | START_BUTTON | SELECT_BUTTON) && ptr->field_0000 != sub_80EDBE8)
-        sub_80ECAA8(ptr, sub_80EDBE8);
-    ptr->field_0000(ptr);
+    if (JOY_NEW(A_BUTTON | START_BUTTON | SELECT_BUTTON) && ptr->callback != IntroCB_CleanUp)
+        SetIntroCB(ptr, IntroCB_CleanUp);
+    ptr->callback(ptr);
 }
 
-static void sub_80ECAF0(struct IntroSequenceData * this)
+static void IntroCB_Init(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
-        InitWindows(gUnknown_840BBA8);
-        LZ77UnCompWram(gUnknown_840272C, this->field_043C);
-        LZ77UnCompWram(gUnknown_84028F8, this->field_003C);
+        InitWindows(sWindowTemplate);
+        LZ77UnCompWram(sBlit_GameFreakText, this->gamefreakTextBitmap);
+        LZ77UnCompWram(sSpriteTiles_GameFreakLogoArt, this->gamefreakLogoArtSpriteTiles);
         FillBgTilemapBufferRect(2, 0x000, 0, 0, 32, 32, 0x11);
-        FillWindowPixelBuffer(0, 0x00);
-        BlitBitmapToWindow(0, this->field_043C, 0, 40, 144, 16);
+        FillWindowPixelBuffer(0, PIXEL_FILL(0));
+        BlitBitmapToWindow(0, this->gamefreakTextBitmap, 0, 40, 144, 16);
         PutWindowTilemap(0);
         CopyWindowToVram(0, 3);
-        this->field_0004++;
+        this->state++;
         break;
     case 1:
         if (!IsDma3ManagerBusyWithBgCopy())
-            sub_80ECAA8(this, sub_80ECB98);
+            SetIntroCB(this, IntroCB_OpenWin1ToTheaterDimensions);
         break;
     }
 }
 
-static void sub_80ECB98(struct IntroSequenceData * this)
+static void IntroCB_OpenWin1ToTheaterDimensions(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON);
@@ -719,232 +714,232 @@ static void sub_80ECB98(struct IntroSequenceData * this)
         SetGpuReg(REG_OFFSET_WINOUT, 0x0000);
         SetGpuReg(REG_OFFSET_WIN1H, 0x00F0);
         SetGpuReg(REG_OFFSET_WIN1V, 0x0000);
-        this->field_0012 = 0;
-        this->field_0004++;
+        this->data[5] = 0;
+        this->state++;
         break;
     case 1:
         ShowBg(3);
         BlendPalettes(0xFFFFFFFF, 0x00, RGB_BLACK);
-        this->field_0004++;
+        this->state++;
         break;
     case 2:
-        this->field_0012 += 8;
-        if (this->field_0012 >= 0x30)
-            this->field_0012 = 0x30;
-        SetGpuReg(REG_OFFSET_WIN1V, ((0x50 - this->field_0012) << 8) | (0x50 + this->field_0012));
-        if (this->field_0012 == 0x30)
-            sub_80ECAA8(this, sub_80ECC3C);
+        this->data[5] += 8;
+        if (this->data[5] >= 0x30)
+            this->data[5] = 0x30;
+        SetGpuReg(REG_OFFSET_WIN1V, ((0x50 - this->data[5]) << 8) | (0x50 + this->data[5]));
+        if (this->data[5] == 0x30)
+            SetIntroCB(this, IntroCB_GameFreakStar);
         break;
     }
 }
 
-static void sub_80ECC3C(struct IntroSequenceData * this)
+static void IntroCB_GameFreakStar(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         PlaySE(MUS_TITLEROG);
-        sub_80EDC40();
-        this->field_0012 = 0;
-        this->field_0004++;
+        GameFreakScene_LoadGfxCreateStar();
+        this->data[5] = 0;
+        this->state++;
         break;
     case 1:
-        this->field_0012++;
-        if (this->field_0012 == 30)
+        this->data[5]++;
+        if (this->data[5] == 30)
         {
-            sub_80EDDF0();
-            this->field_0012 = 0;
-            this->field_0004++;
+            GameFreakScene_StartTrailingSparkleSpawner();
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 2:
-        this->field_0012++;
-        if (this->field_0012 == 90)
-            sub_80ECAA8(this, sub_80ECCA8);
+        this->data[5]++;
+        if (this->data[5] == 90)
+            SetIntroCB(this, IntroCB_GameFreakScene_RevealGameFreakText);
         break;
     }
 }
 
-static void sub_80ECCA8(struct IntroSequenceData * this)
+static void IntroCB_GameFreakScene_RevealGameFreakText(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
-        sub_80EDED8();
-        this->field_0012 = 0;
-        this->field_0004++;
+        GameFreakScene_StartRevealGameFreakTextSparklesSpawner();
+        this->data[5] = 0;
+        this->state++;
         break;
     case 1:
-        this->field_0012++;
-        if (this->field_0012 >= 40)
-            this->field_0004++;
+        this->data[5]++;
+        if (this->data[5] >= 40)
+            this->state++;
         break;
     case 2:
         SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG0 | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD);
         StartBlendTask(0, 16, 16, 0, 48, 0);
-        this->field_0004++;
+        this->state++;
         break;
     case 3:
         ShowBg(2);
-        this->field_0004++;
+        this->state++;
         break;
     case 4:
         if (!IsBlendTaskActive())
         {
             SetGpuReg(REG_OFFSET_BLDCNT, 0);
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 5:
-        this->field_0012++;
-        if (this->field_0012 > 50)
-            sub_80ECAA8(this, sub_80ECD60);
+        this->data[5]++;
+        if (this->data[5] > 50)
+            SetIntroCB(this, IntroCB_GameFreakScene_CreateGameFreakLogo);
         break;
     }
 }
 
-static void sub_80ECD60(struct IntroSequenceData * this)
+static void IntroCB_GameFreakScene_CreateGameFreakLogo(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG0 | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD);
         StartBlendTask(0, 16, 16, 0, 16, 0);
-        this->field_0008 = 0;
-        this->field_000A = 16;
-        this->field_0012 = 0;
-        this->field_0004++;
+        this->data[0] = 0;
+        this->data[1] = 16;
+        this->data[5] = 0;
+        this->state++;
         break;
     case 1:
-        this->field_0014 = sub_80EDF68();
-        this->field_0004++;
+        this->gameFreakLogoArtSprite = CreateGameFreakLogoArtSprite();
+        this->state++;
         break;
     case 2:
         if (!IsBlendTaskActive())
         {
-            BlitBitmapToWindow(0, this->field_003C, 0x38, 0x06, 0x20, 0x40);
-            BlitBitmapToWindow(0, this->field_043C, 0x00, 0x28, 0x90, 0x10);
+            BlitBitmapToWindow(0, this->gamefreakLogoArtSpriteTiles, 0x38, 0x06, 0x20, 0x40);
+            BlitBitmapToWindow(0, this->gamefreakTextBitmap, 0x00, 0x28, 0x90, 0x10);
             CopyWindowToVram(0, 2);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 3:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            DestroySprite(this->field_0014);
-            sub_rev1_80EDFAC();
-            this->field_0012 = 0;
-            this->field_0004++;
+            DestroySprite(this->gameFreakLogoArtSprite);
+            Rev1_GameFreakScene_CreatePresentsText();
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 4:
-        this->field_0012++;
-        if (this->field_0012 > 90)
+        this->data[5]++;
+        if (this->data[5] > 90)
         {
             SetGpuRegBits(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2);
             StartBlendTask(16, 0, 0, 16, 20, 0);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 5:
         if (!IsBlendTaskActive())
         {
             HideBg(2);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 6:
         ResetSpriteData();
         FreeAllSpritePalettes();
-        this->field_0012 = 0;
-        this->field_0004++;
+        this->data[5] = 0;
+        this->state++;
         break;
     case 7:
-        this->field_0012++;
-        if (this->field_0012 > 20)
+        this->data[5]++;
+        if (this->data[5] > 20)
         {
             SetGpuReg(REG_OFFSET_BLDCNT, 0);
-            sub_80ECAA8(this, sub_80ECEA4);
+            SetIntroCB(this, IntroCB_FightScene);
         }
         break;
     }
 }
 
-static void sub_80ECEA4(struct IntroSequenceData * this)
+static void IntroCB_FightScene(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         SetVBlankCallback(NULL);
-        LoadPalette(gUnknown_8402D34, 0x10, 0x20);
-        LoadPalette(gUnknown_84048CC, 0x20, 0x20);
-        BlendPalettes(0x06, 0x10, RGB_WHITE);
-        InitBgsFromTemplates(0, gUnknown_840BB88, NELEMS(gUnknown_840BB88));
-        DecompressAndCopyTileDataToVram(1, gUnknown_84048EC, 0, 0, 0);
-        DecompressAndCopyTileDataToVram(1, gUnknown_8404F7C, 0, 0, 1);
+        LoadPalette(sBg0Pal_FightScene1, 0x10, 0x20);
+        LoadPalette(sBg1Pal_FightScene1, 0x20, 0x20);
+        BlendPalettes(0x00000006, 0x10, RGB_WHITE);
+        InitBgsFromTemplates(0, sBgTemplates_FightScene1, NELEMS(sBgTemplates_FightScene1));
+        DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene1, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene1, 0, 0, 1);
         ShowBg(1);
         HideBg(0);
         HideBg(2);
         HideBg(3);
-        sub_80EEBE4();
-        SetVBlankCallback(sub_80EC9EC);
-        this->field_0004++;
+        LoadFightSceneSpriteTilesAndPals();
+        SetVBlankCallback(VBlankCB_Intro);
+        this->state++;
         break;
     case 1:
         if (!FreeTempTileDataBuffersIfPossible())
         {
-            DecompressAndCopyTileDataToVram(0, gUnknown_8402D54, 0, 0, 0);
-            DecompressAndCopyTileDataToVram(0, gUnknown_8403FE8, 0, 0, 1);
+            DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene1, 0, 0, 0);
+            DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene1, 0, 0, 1);
             ResetBgPositions();
             ShowBg(1);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 2:
         if (!FreeTempTileDataBuffersIfPossible())
         {
             ShowBg(0);
-            CreateTask(sub_80ED0AC, 0);
+            CreateTask(Task_FightScene1_GrassyFieldAnim, 0);
             BeginNormalPaletteFade(0x00000006, -2, 16, 0, RGB_WHITE);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 3:
         if (!gPaletteFade.active)
         {
             m4aSongNumStart(MUS_DEMO);
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 4:
-        this->field_0012++;
-        if (this->field_0012 == 20)
+        this->data[5]++;
+        if (this->data[5] == 20)
         {
-            CreateTask(sub_80ED140, 0);
-            sub_80ED118();
+            CreateTask(Task_FightScene1_ZoomEffect, 0);
+            FightScene1_SignalEndGrassyFieldAnim();
         }
-        if (this->field_0012 >= 30)
+        if (this->data[5] >= 30)
         {
-            BlendPalettes(-2, 16, RGB_WHITE);
-            DestroyTask(FindTaskIdByFunc(sub_80ED0AC));
-            DestroyTask(FindTaskIdByFunc(sub_80ED140));
-            sub_80ECAA8(this, sub_80ED188);
+            BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE);
+            DestroyTask(FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim));
+            DestroyTask(FindTaskIdByFunc(Task_FightScene1_ZoomEffect));
+            SetIntroCB(this, IntroCB_FightScene2);
         }
         break;
     case 5:
         if (!gPaletteFade.active)
         {
-            DestroyTask(FindTaskIdByFunc(sub_80ED0AC));
-            DestroyTask(FindTaskIdByFunc(sub_80ED140));
-            sub_80ECAA8(this, sub_80ED188);
+            DestroyTask(FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim));
+            DestroyTask(FindTaskIdByFunc(Task_FightScene1_ZoomEffect));
+            SetIntroCB(this, IntroCB_FightScene2);
         }
         break;
     }
 }
 
-static void sub_80ED0AC(u8 taskId)
+static void Task_FightScene1_GrassyFieldAnim(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
 
@@ -964,13 +959,13 @@ static void sub_80ED0AC(u8 taskId)
     }
 }
 
-static void sub_80ED118(void)
+static void FightScene1_SignalEndGrassyFieldAnim(void)
 {
-    u8 taskId = FindTaskIdByFunc(sub_80ED0AC);
+    u8 taskId = FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim);
     gTasks[taskId].data[2] = TRUE;
 }
 
-static void sub_80ED140(u8 taskId)
+static void Task_FightScene1_ZoomEffect(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
 
@@ -984,146 +979,146 @@ static void sub_80ED140(u8 taskId)
     }
 }
 
-static void sub_80ED188(struct IntroSequenceData * this)
+static void IntroCB_FightScene2(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE);
-        InitBgsFromTemplates(0, gUnknown_840BB90, NELEMS(gUnknown_840BB90));
-        DecompressAndCopyTileDataToVram(3, gUnknown_8405414, 0, 0, 0);
-        DecompressAndCopyTileDataToVram(3, gUnknown_8405890, 0, 0, 1);
+        InitBgsFromTemplates(0, sBgTemplates_FightScene2, NELEMS(sBgTemplates_FightScene2));
+        DecompressAndCopyTileDataToVram(3, sBg3Tiles_FightScene2, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(3, sBg3Map_FightScene2, 0, 0, 1);
         ShowBg(3);
-        this->field_0004++;
+        this->state++;
         break;
     case 1:
         if (!FreeTempTileDataBuffersIfPossible())
         {
             SetVBlankCallback(NULL);
-            LoadPalette(gUnknown_84053B4, 0x10, 0x60);
-            LoadPalette(gUnknown_8405DA4, 0x50, 0x20);
-            LoadPalette(gUnknown_8406634, 0x60, 0x20);
+            LoadPalette(sBg3Pal_FightScene2, 0x10, 0x60);
+            LoadPalette(sSpritePals_Gengar, 0x50, 0x20);
+            LoadPalette(sBg1Pal_FightScene2, 0x60, 0x20);
             BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE);
-            DecompressAndCopyTileDataToVram(0, gUnknown_8405B28, 0, 0, 0);
-            DecompressAndCopyTileDataToVram(0, gUnknown_8405CDC, 0, 0, 1);
-            DecompressAndCopyTileDataToVram(1, gUnknown_8406654, 0, 0, 0);
-            DecompressAndCopyTileDataToVram(1, gUnknown_84071D0, 0, 0, 1);
-            DecompressAndCopyTileDataToVram(2, gUnknown_8405DC4, 0, 0, 0);
-            DecompressAndCopyTileDataToVram(2, gUnknown_840644C, 0, 0, 1);
+            DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene2, 0, 0, 0);
+            DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene2, 0, 0, 1);
+            DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene2, 0, 0, 0);
+            DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene2, 0, 0, 1);
+            DecompressAndCopyTileDataToVram(2, sBg2Tiles_FightScene2, 0, 0, 0);
+            DecompressAndCopyTileDataToVram(2, sBg2Map_FightScene2, 0, 0, 1);
             ResetBgPositions();
             ShowBg(0);
             HideBg(1);
             HideBg(2);
             ChangeBgY(2, 0x0001CE00, 0);
             ChangeBgY(1, 0x00002800, 0);
-            CreateTask(sub_80ED40C, 0);
-            sub_80ED444(this);
+            CreateTask(Task_FightScene2_CameraHorizPanEffect, 0);
+            CreateMonStaticSprites(this);
             BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE);
-            SetVBlankCallback(sub_80EC9EC);
-            this->field_0004++;
+            SetVBlankCallback(VBlankCB_Intro);
+            this->state++;
         }
         break;
     case 2:
         if (!FreeTempTileDataBuffersIfPossible())
         {
             BeginNormalPaletteFade(0xFFFFFFFE, -2, 16, 0, RGB_WHITE);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 3:
         if (!gPaletteFade.active)
         {
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 4:
-        this->field_0012++;
-        if (this->field_0012 >= 60)
+        this->data[5]++;
+        if (this->data[5] >= 60)
         {
-            this->field_0012 = 0;
-            DestroyTask(FindTaskIdByFunc(sub_80ED40C));
-            sub_80ED4A0(this);
-            CreateTask(sub_80ED428, 0);
+            this->data[5] = 0;
+            DestroyTask(FindTaskIdByFunc(Task_FightScene2_CameraHorizPanEffect));
+            DestroyStaticMonSprites(this);
+            CreateTask(Task_FightScene2_CameraVertPanEffect, 0);
             ChangeBgY(3, 0x00010000, 0);
             HideBg(0);
             ShowBg(3);
             ShowBg(1);
             ShowBg(2);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 5:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 6:
-        this->field_0012++;
-        if (this->field_0012 >= 60)
+        this->data[5]++;
+        if (this->data[5] >= 60)
         {
-            DestroyTask(FindTaskIdByFunc(sub_80ED428));
-            sub_80ECAA8(this, sub_80ED4C0);
+            DestroyTask(FindTaskIdByFunc(Task_FightScene2_CameraVertPanEffect));
+            SetIntroCB(this, IntroCB_FightScene3);
         }
         break;
     }
 }
 
-static void sub_80ED40C(u8 taskId)
+static void Task_FightScene2_CameraHorizPanEffect(u8 taskId)
 {
     ChangeBgX(3, 0x0E0, 2);
     ChangeBgX(0, 0x110, 1);
 }
 
-static void sub_80ED428(u8 taskId)
+static void Task_FightScene2_CameraVertPanEffect(u8 taskId)
 {
     ChangeBgY(2, 0x020, 1);
     ChangeBgY(1, 0x024, 2);
 }
 
-static void sub_80ED444(struct IntroSequenceData * this)
+static void CreateMonStaticSprites(struct IntroSequenceData * this)
 {
     u8 spriteId;
 
-    this->field_001C = NULL;
-    this->field_0020 = NULL;
+    this->gengarStaticSprite = NULL;
+    this->nidorinoStaticSprite = NULL;
 
-    spriteId = CreateSprite(&gUnknown_840BDA8, 168, 80, 11);
+    spriteId = CreateSprite(&sSpriteTemplate_NidorinoStatic, 168, 80, 11);
     if (spriteId != MAX_SPRITES)
-        this->field_0020 = &gSprites[spriteId];
+        this->nidorinoStaticSprite = &gSprites[spriteId];
 
-    spriteId = CreateSprite(&gUnknown_840BDC0, 72, 80, 12);
+    spriteId = CreateSprite(&sSpriteTemplate_GengarStatic, 72, 80, 12);
     if (spriteId != MAX_SPRITES)
-        this->field_001C = &gSprites[spriteId];
+        this->gengarStaticSprite = &gSprites[spriteId];
 }
 
-static void sub_80ED4A0(struct IntroSequenceData * this)
+static void DestroyStaticMonSprites(struct IntroSequenceData * this)
 {
-    if (this->field_001C != NULL)
-        DestroySprite(this->field_001C);
-    if (this->field_0020 != NULL)
-        DestroySprite(this->field_0020);
+    if (this->gengarStaticSprite != NULL)
+        DestroySprite(this->gengarStaticSprite);
+    if (this->nidorinoStaticSprite != NULL)
+        DestroySprite(this->nidorinoStaticSprite);
 }
 
-static void sub_80ED4C0(struct IntroSequenceData * this)
+static void IntroCB_FightScene3(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
-        LoadPalette(gUnknown_8407430, 0x10, 0x40);
-        LoadPalette(gUnknown_8405DA4, 0x50, 0x20);
+        LoadPalette(sBg1Pal_FightScene3, 0x10, 0x40);
+        LoadPalette(sSpritePals_Gengar, 0x50, 0x20);
         BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE);
-        InitBgsFromTemplates(0, gUnknown_840BBA0, NELEMS(gUnknown_840BBA0));
-        DecompressAndCopyTileDataToVram(1, gUnknown_8407470, 0, 0, 0);
-        DecompressAndCopyTileDataToVram(1, gUnknown_8407A50, 0, 0, 1);
+        InitBgsFromTemplates(0, sBgTemplates_FightScene3, NELEMS(sBgTemplates_FightScene3));
+        DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene3, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene3, 0, 0, 1);
         ShowBg(1);
         HideBg(0);
         HideBg(2);
         HideBg(3);
         ResetBgPositions();
-        this->field_0004++;
+        this->state++;
         SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
         SetGpuRegBits(REG_OFFSET_WININ, 0x12);
         ClearGpuRegBits(REG_OFFSET_WININ, 0x01);
@@ -1134,13 +1129,13 @@ static void sub_80ED4C0(struct IntroSequenceData * this)
     case 1:
         if (!FreeTempTileDataBuffersIfPossible())
         {
-            DecompressAndCopyTileDataToVram(0, gUnknown_8407B9C, 0, 0, 0);
-            DecompressAndCopyTileDataToVram(0, gUnknown_8408D98, 0, 0, 1);
+            DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene3, 0, 0, 0);
+            DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene3, 0, 0, 1);
             gUnknown_203AB00 = 4;
             gUnknown_203AB02 = 52;
             ChangeBgX(0, 0x00001800, 0);
             ChangeBgY(0, 0x0001F000, 0);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 2:
@@ -1148,26 +1143,26 @@ static void sub_80ED4C0(struct IntroSequenceData * this)
         {
             BlendPalettes(0xFFFFFFFE, 0, RGB_WHITE);
             ShowBg(0);
-            CreateTask(sub_80ED714, 0);
-            sub_80EE4F8(this);
-            sub_80EE528(this->field_0018, 0, 0xB4, 0x34);
-            CreateTask(sub_80EE200, 0);
-            sub_80ED6D8();
-            this->field_0012 = 0;
-            this->field_0004++;
+            CreateTask(Task_FightScene3_ForestBgScroll, 0);
+            CreateNidorinoAnimSprite(this);
+            StartNidorinoAnimSpriteSlideIn(this->nidorinoAnimSprite, 0, 0xB4, 0x34);
+            CreateTask(Task_FightScene3_Bg0Scroll, 0);
+            FightScene3_StartBg1Scroll();
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 3:
-        this->field_0012++;
-        if (this->field_0012 == 16)
-            sub_80ED7D4(this);
-        if (!sub_80EE5C8(this) && !FuncIsActiveTask(sub_80EE200))
-            sub_80ECAA8(this, sub_80ED898);
+        this->data[5]++;
+        if (this->data[5] == 16)
+            CreateGrassSprite(this);
+        if (!IsNidorinoAnimSpriteSlideInRunning(this) && !FuncIsActiveTask(Task_FightScene3_Bg0Scroll))
+            SetIntroCB(this, IntroCB_FightScene4);
         break;
     }
 }
 
-static void sub_80ED69C(u8 taskId)
+static void Task_FightScene3_Bg1Scroll(u8 taskId)
 {
     if (gTasks[taskId].data[0] == 0)
         ChangeBgX(1, 0x400, 2);
@@ -1175,18 +1170,18 @@ static void sub_80ED69C(u8 taskId)
         ChangeBgX(1, 0x020, 2);
 }
 
-static void sub_80ED6D8(void)
+static void FightScene3_StartBg1Scroll(void)
 {
-    CreateTask(sub_80ED69C, 0);
+    CreateTask(Task_FightScene3_Bg1Scroll, 0);
 }
 
-static void sub_80ED6EC(void)
+static void FightScene3_SlowBg1Scroll(void)
 {
-    u8 taskId = FindTaskIdByFunc(sub_80ED69C);
+    u8 taskId = FindTaskIdByFunc(Task_FightScene3_Bg1Scroll);
     gTasks[taskId].data[0] = 1;
 }
 
-static void sub_80ED714(u8 taskId)
+static void Task_FightScene3_ForestBgScroll(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
     if (data[0] == 0)
@@ -1201,37 +1196,37 @@ static void sub_80ED714(u8 taskId)
     }
 }
 
-static void sub_80ED760(void)
+static void FightScene3_PauseForestBgScroll(void)
 {
-    u8 taskId = FindTaskIdByFunc(sub_80ED714);
+    u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll);
     gTasks[taskId].data[0] = 1;
 }
 
-static void sub_80ED788(void)
+static void FightScene3_ResumeForestBgScroll(void)
 {
-    u8 taskId = FindTaskIdByFunc(sub_80ED714);
+    u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll);
     gTasks[taskId].data[0] = 0;
 }
 
-static u8 sub_80ED7B0(void)
+static bool8 FightScene3_GetForestBgScrollState(void)
 {
-    u8 taskId = FindTaskIdByFunc(sub_80ED714);
+    u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll);
     return gTasks[taskId].data[2];
 }
 
-static void sub_80ED7D4(struct IntroSequenceData * this)
+static void CreateGrassSprite(struct IntroSequenceData * this)
 {
-    u8 spriteId = CreateSprite(&gUnknown_840BDFC, 296, 112, 7);
+    u8 spriteId = CreateSprite(&sSpriteTemplate_Grass, 296, 112, 7);
     if (spriteId != MAX_SPRITES)
     {
-        this->field_0024 = &gSprites[spriteId];
-        this->field_0024->callback = sub_80ED818;
+        this->grassSprite = &gSprites[spriteId];
+        this->grassSprite->callback = SpriteCB_Grass;
     }
     else
-        this->field_0024 = NULL;
+        this->grassSprite = NULL;
 }
 
-static void sub_80ED818(struct Sprite * sprite)
+static void SpriteCB_Grass(struct Sprite * sprite)
 {
     s16 * data = sprite->data;
 
@@ -1247,7 +1242,7 @@ static void sub_80ED818(struct Sprite * sprite)
         sprite->pos1.x = data[1] >> 5;
         if (sprite->pos1.x <= 52)
         {
-            sub_80ED6EC();
+            FightScene3_SlowBg1Scroll();
             data[0]++;
         }
         break;
@@ -1264,206 +1259,207 @@ static void sub_80ED818(struct Sprite * sprite)
     }
 }
 
-static void sub_80ED898(struct IntroSequenceData * this)
+static void IntroCB_FightScene4(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
-        this->field_0012 = 0;
-        this->field_0004++;
+        this->data[5] = 0;
+        this->state++;
         break;
     case 1:
-        this->field_0012++;
-        if (this->field_0012 > 30)
+        this->data[5]++;
+        if (this->data[5] > 30)
         {
-            sub_80EE5E4(this);
-            this->field_0004++;
+            FightScene4_NidorinoRearsUp(this);
+            this->state++;
         }
         break;
     case 2:
-        if (!sub_80EE850(this))
+        if (!FightScene4_NidorinoAnimIsRunning(this))
         {
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 3:
-        this->field_0012++;
-        if (this->field_0012 > 30)
+        this->data[5]++;
+        if (this->data[5] > 30)
         {
-            sub_80ED760();
-            sub_80EDF94(this);
-            this->field_0012 = 0;
-            this->field_0004++;
+            FightScene3_PauseForestBgScroll();
+            FightScene4_StartGengarAttack(this);
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 4:
-        if (this->field_0006)
+        if (this->gengarAttackLanded)
         {
-            sub_80EE6A4(this);
-            this->field_0004++;
+            FightScene4_StartNidorinoRecoilAnim(this);
+            this->state++;
         }
         break;
     case 5:
-        if (!sub_80EE850(this))
+        if (!FightScene4_NidorinoAnimIsRunning(this))
         {
-            sub_80ED788();
-            this->field_0012 = 0;
-            this->field_0004++;
+            FightScene3_ResumeForestBgScroll();
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 6:
-        this->field_0012++;
-        if (this->field_0012 > 16)
+        this->data[5]++;
+        if (this->data[5] > 16)
         {
-            sub_80EE970(this->field_0018, 8, 12, 5);
-            this->field_0004++;
+            StartSpriteHopToPosAnim(this->nidorinoAnimSprite, 8, 12, 5);
+            this->state++;
         }
         break;
     case 7:
-        if (!sub_80EE850(this))
+        if (!FightScene4_NidorinoAnimIsRunning(this))
         {
-            sub_80EE970(this->field_0018, 8, 12, 5);
-            this->field_0004++;
+            StartSpriteHopToPosAnim(this->nidorinoAnimSprite, 8, 12, 5);
+            this->state++;
         }
         break;
     case 8:
-        if (!sub_80EE850(this))
+        if (!FightScene4_NidorinoAnimIsRunning(this))
         {
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 9:
-        this->field_0012++;
-        if (this->field_0012 > 20)
+        this->data[5]++;
+        if (this->data[5] > 20)
         {
-            sub_80EEA94(this);
-            this->field_0012 = 0;
-            this->field_0004++;
+            StartNidorinoAnim_LaunchSelfAtGengarAnim(this);
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 10:
-        if (!sub_80ED7B0())
+        if (!FightScene3_GetForestBgScrollState())
         {
-            sub_80ED760();
-            sub_80EDAF0(this);
-            this->field_0004++;
+            FightScene3_PauseForestBgScroll();
+            CreateGengarBackSprite(this);
+            this->state++;
         }
         break;
     case 11:
         HideBg(0);
-        this->field_0012 = 0;
-        this->field_0004++;
+        this->data[5] = 0;
+        this->state++;
         break;
     case 12:
-        this->field_0012++;
-        if (this->field_0012 == 48)
+        this->data[5]++;
+        if (this->data[5] == 48)
             BeginNormalPaletteFade(0x00000006, 2, 0, 16, RGB_WHITE);
-        if (this->field_0012 > 120)
+        if (this->data[5] > 120)
         {
-            sub_80EDB70(this);
-            sub_80EDBAC(this);
-            this->field_0004++;
-            this->field_0012 = 0;
+            FightScene4_StartNidorinoAffineAnim(this);
+            FightScene4_StartGengarAffineAnim(this);
+            this->state++;
+            this->data[5] = 0;
         }
         break;
     case 13:
-        this->field_0012++;
-        if (this->field_0012 > 8)
+        this->data[5]++;
+        if (this->data[5] > 8)
         {
             CpuFill16(RGB_WHITE, gPlttBufferUnfaded + 16, 64);
             BeginNormalPaletteFade(0xFFFFFFFE, -2, 0, 16, RGB_BLACK);
-            this->field_0004++;
+            this->state++;
         }
         break;
     case 14:
         if (!gPaletteFade.active)
         {
-            this->field_0012 = 0;
-            this->field_0004++;
+            this->data[5] = 0;
+            this->state++;
         }
         break;
     case 15:
-        this->field_0012++;
-        if (this->field_0012 > 60)
-            sub_80ECAA8(this, sub_80EDBE8);
+        this->data[5]++;
+        if (this->data[5] > 60)
+            SetIntroCB(this, IntroCB_CleanUp);
         break;
     default:
         if (JOY_NEW(R_BUTTON))
         {
             BlendPalettes(0xFFFF0064, 0, RGB_WHITE);
-            this->field_0018->pos2.x = 0;
-            this->field_0018->pos1.x = 0xB4;
-            this->field_0004 = 1;
-            this->field_0012 = 30;
+            this->nidorinoAnimSprite->pos2.x = 0;
+            this->nidorinoAnimSprite->pos1.x = 0xB4;
+            this->state = 1;
+            this->data[5] = 30;
         }
         break;
     }
 }
 
-static void sub_80EDAD8(struct Sprite * sprite)
+static void FightScene_CalcCenterToCornerVec(struct Sprite * sprite)
 {
     CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode);
 }
 
-static void sub_80EDAF0(struct IntroSequenceData * this)
+static void CreateGengarBackSprite(struct IntroSequenceData * this)
 {
     int i;
 
+    // Not using a subsprite table for this
     for (i = 0; i < 4; i++)
     {
         int x = (i & 1) * 48 + 49;
         int y = (i / 2) * 64 + 72;
-        u8 spriteId = CreateSprite(&gUnknown_840BE4C, x, y, 8);
+        u8 spriteId = CreateSprite(&sSpriteTemplate_GengarBack, x, y, 8);
         if (spriteId != MAX_SPRITES)
         {
             StartSpriteAnim(&gSprites[spriteId], i);
-            this->field_0028[i] = &gSprites[spriteId];
+            this->gengarBackSpriteArray[i] = &gSprites[spriteId];
             if (i & 1)
-                this->field_0028[i]->oam.shape = ST_OAM_V_RECTANGLE;
-            sub_80EDAD8(this->field_0028[i]);
+                this->gengarBackSpriteArray[i]->oam.shape = ST_OAM_V_RECTANGLE;
+            FightScene_CalcCenterToCornerVec(this->gengarBackSpriteArray[i]);
         }
     }
 }
 
-static void sub_80EDB70(struct IntroSequenceData * this)
+static void FightScene4_StartNidorinoAffineAnim(struct IntroSequenceData * this)
 {
-    this->field_0018->pos1.x += this->field_0018->pos2.x;
-    this->field_0018->pos1.y += this->field_0018->pos2.y;
-    obj_pos2_update_enable(this->field_0018, 0, 0x2A);
-    this->field_0018->callback = SpriteCallbackDummy;
-    StartSpriteAffineAnim(this->field_0018, 1);
+    this->nidorinoAnimSprite->pos1.x += this->nidorinoAnimSprite->pos2.x;
+    this->nidorinoAnimSprite->pos1.y += this->nidorinoAnimSprite->pos2.y;
+    obj_pos2_update_enable(this->nidorinoAnimSprite, 0, 0x2A);
+    this->nidorinoAnimSprite->callback = SpriteCallbackDummy;
+    StartSpriteAffineAnim(this->nidorinoAnimSprite, 1);
 }
 
-static void nullsub_83(struct Sprite * sprite)
+static void SpriteCB_DummyButNotDummy(struct Sprite * sprite)
 {
 }
 
-static void sub_80EDBAC(struct IntroSequenceData * this)
+static void FightScene4_StartGengarAffineAnim(struct IntroSequenceData * this)
 {
     int i;
 
     for (i = 0; i < 4; i++)
     {
-        StartSpriteAffineAnim(this->field_0028[i], 1);
-        this->field_0028[i]->callback = nullsub_83;
-        obj_pos2_update_enable(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]);
+        StartSpriteAffineAnim(this->gengarBackSpriteArray[i], 1);
+        this->gengarBackSpriteArray[i]->callback = SpriteCB_DummyButNotDummy;
+        obj_pos2_update_enable(this->gengarBackSpriteArray[i], sGengarBackSpritePos2UpdateMods[i][0], sGengarBackSpritePos2UpdateMods[i][1]);
     }
 }
 
-static void sub_80EDBE8(struct IntroSequenceData * this)
+static void IntroCB_CleanUp(struct IntroSequenceData * this)
 {
-    switch (this->field_0004)
+    switch (this->state)
     {
     case 0:
         FillPalette(RGB_BLACK, 0, 0x400);
-        this->field_0004++;
+        this->state++;
         break;
     case 1:
         if (!FreeTempTileDataBuffersIfPossible())
         {
-            DestroyTask(this->field_0005);
+            DestroyTask(this->taskId);
             Free(this);
             DisableInterrupts(INTR_FLAG_HBLANK);
             SetHBlankCallback(NULL);
@@ -1473,16 +1469,17 @@ static void sub_80EDBE8(struct IntroSequenceData * this)
     }
 }
 
-static void sub_80EDC40(void)
+static void GameFreakScene_LoadGfxCreateStar(void)
 {
     int i;
     u8 spriteId;
+    static EWRAM_DATA u32 gUnknown_203AB28 = 0;
 
-    for (i = 0; i < NELEMS(gUnknown_840BBC0); i++)
+    for (i = 0; i < NELEMS(sSpriteSheets_GameFreakScene); i++)
     {
-        LoadCompressedSpriteSheet(&gUnknown_840BBC0[i]);
+        LoadCompressedSpriteSheet(&sSpriteSheets_GameFreakScene[i]);
     }
-    LoadSpritePalettes(gUnknown_840BBE8);
+    LoadSpritePalettes(sSpritePalettes_GameFreakScene);
     gUnknown_203AB0E = 0x60;
     gUnknown_203AB10 = 0x10;
     gUnknown_203AB12 = 0x07;
@@ -1496,19 +1493,21 @@ static void sub_80EDC40(void)
     gUnknown_203AB24 = 0x05;
     if (gUnknown_203AB28 == 0)
         gUnknown_203AB28 = 354128453;
-    spriteId = CreateSprite(&gUnknown_840BC6C, 0xF8, 0x37, 0);
+    spriteId = CreateSprite(&sSpriteTemplate_LargeStar, 0xF8, 0x37, 0);
     if (spriteId != MAX_SPRITES)
     {
         gSprites[spriteId].data[0] = 0xF80;
         gSprites[spriteId].data[1] = 0x370;
         gSprites[spriteId].data[2] = gUnknown_203AB0E;
         gSprites[spriteId].data[3] = gUnknown_203AB10;
-        StoreWordInTwoHalfwords(&gSprites[spriteId].data[6], gUnknown_203AB28);
+        StoreWordInTwoHalfwords((u16 *)&gSprites[spriteId].data[6], gUnknown_203AB28);
     }
 }
 
-static void sub_80EDD28(s16 x, s16 y, u16 a2)
+static void GameFreakScene_TrailingSparklesGen(s16 x, s16 y, u16 a2)
 {
+    static EWRAM_DATA s16 gUnknown_203AB2C = 0;
+
     u8 spriteId;
     s16 r4 = (a2 & gUnknown_203AB12) + 2;
     s16 r2 = gUnknown_203AB2C;
@@ -1519,7 +1518,7 @@ static void sub_80EDD28(s16 x, s16 y, u16 a2)
     y += r2;
     if (x >= 1 && x <= 0xEF)
     {
-        spriteId = CreateSprite(&gUnknown_840BC84, x, y, 1);
+        spriteId = CreateSprite(&sSpriteTemplate_TrailingSparkles, x, y, 1);
         if (spriteId != MAX_SPRITES)
         {
             gSprites[spriteId].data[0] = x << gUnknown_203AB22;
@@ -1530,12 +1529,12 @@ static void sub_80EDD28(s16 x, s16 y, u16 a2)
     }
 }
 
-static void sub_80EDDF0(void)
+static void GameFreakScene_StartTrailingSparkleSpawner(void)
 {
-    CreateTask(sub_80EDE04, 1);
+    CreateTask(Task_GameFreakScene_TrailingSparkleSpawner, 1);
 }
 
-static void sub_80EDE04(u8 taskId)
+static void Task_GameFreakScene_TrailingSparkleSpawner(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
     u8 r6;
@@ -1546,16 +1545,16 @@ static void sub_80EDE04(u8 taskId)
     {
         data[2] = 0;
         r6 = data[0];
-        spriteId = CreateSprite(&gUnknown_840BC84, gUnknown_840BC08[r6].x, gUnknown_840BC08[r6].y, 2);
+        spriteId = CreateSprite(&sSpriteTemplate_TrailingSparkles, sTrailingSparkleCoords[r6].x, sTrailingSparkleCoords[r6].y, 2);
         StartSpriteAnim(&gSprites[spriteId], 1);
-        gSprites[spriteId].callback = sub_80EE40C;
-        gSprites[spriteId].data[1] = gUnknown_840BC08[r6].y << 4;
+        gSprites[spriteId].callback = SpriteCB_TrailingSparkles2;
+        gSprites[spriteId].data[1] = sTrailingSparkleCoords[r6].y << 4;
         gSprites[spriteId].data[2] = 120;
         gSprites[spriteId].data[3] = data[1];
         if (gSprites[spriteId].data[3] < 0)
             gSprites[spriteId].data[3] = 1;
         data[0]++;
-        if (data[0] < 0 || data[0] > 8)
+        if (data[0] >= NELEMS(sTrailingSparkleCoords))
         {
             data[1]++;
             if (data[1] > 1)
@@ -1566,12 +1565,12 @@ static void sub_80EDE04(u8 taskId)
     }
 }
 
-static void sub_80EDED8(void)
+static void GameFreakScene_StartRevealGameFreakTextSparklesSpawner(void)
 {
-    CreateTask(sub_80EDEEC, 2);
+    CreateTask(Task_RevealGameFreakTextSparklesSpawner, 2);
 }
 
-static void sub_80EDEEC(u8 taskId)
+static void Task_RevealGameFreakTextSparklesSpawner(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
     u8 r2;
@@ -1580,9 +1579,9 @@ static void sub_80EDEEC(u8 taskId)
     {
         r2 = data[1];
         data[1] += 4;
-        if (data[1] < 0 || data[1] > 8)
-            data[1] -= 9;
-        CreateSprite(&gUnknown_840BCBC, gUnknown_840BC08[r2].x, gUnknown_840BC08[r2].y, 3);
+        if (data[1] >= NELEMS(sTrailingSparkleCoords))
+            data[1] -= NELEMS(sTrailingSparkleCoords);
+        CreateSprite(&sSpriteTemplate_RevealGameFreakTextSparkles, sTrailingSparkleCoords[r2].x, sTrailingSparkleCoords[r2].y, 3);
         data[2]++;
         if (data[2] > 8)
             DestroyTask(taskId);
@@ -1592,34 +1591,34 @@ static void sub_80EDEEC(u8 taskId)
         data[0] = 0;
 }
 
-static struct Sprite * sub_80EDF68(void)
+static struct Sprite * CreateGameFreakLogoArtSprite(void)
 {
-    u8 spriteId = CreateSprite(&gUnknown_840BCDC, 120, 70, 4);
+    u8 spriteId = CreateSprite(&sSpriteTemplate_GameFreakLogoArt, 120, 70, 4);
     return &gSprites[spriteId];
 }
 
 #if REVISION >= 1
-static void sub_rev1_80EDFAC(void)
+static void Rev1_GameFreakScene_CreatePresentsText(void)
 {
     int i;
     for (i = 0; i < 2; i++)
     {
-        gSprites[CreateSprite(&gUnknown_840BCFC, 0x68 + 32 * i, 0x6c, 5)].oam.tileNum += i * 4;
+        gSprites[CreateSprite(&sSpriteTemplate_PresentsText, 0x68 + 32 * i, 0x6c, 5)].oam.tileNum += i * 4;
     }
 }
 #endif
 
-static void sub_80EDF94(struct IntroSequenceData * this)
+static void FightScene4_StartGengarAttack(struct IntroSequenceData * this)
 {
     u8 taskId;
-    this->field_0006 = 0;
-    taskId = CreateTask(sub_80EE024, 4);
+    this->gengarAttackLanded = FALSE;
+    taskId = CreateTask(Task_FightScene4_GengarAttack, 4);
     SetWordTaskArg(taskId, 5, (uintptr_t)this);
     gTasks[taskId].data[3] = 64;
     gTasks[taskId].data[4] = GetBgX(0);
 }
 
-static void sub_80EDFD8(int a, int b, int c, int d)
+static void FightScene4_ApplyGengarAnim(int a, int b, int c, int d)
 {
     ChangeBgY(0, (a << 15) + 0x1F000, 0);
     ChangeBgX(0, d, 0);
@@ -1627,7 +1626,7 @@ static void sub_80EDFD8(int a, int b, int c, int d)
     ChangeBgY(0, c << 8, 2);
 }
 
-static void sub_80EE024(u8 taskId)
+static void Task_FightScene4_GengarAttack(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
     int b, c;
@@ -1653,7 +1652,7 @@ static void sub_80EE024(u8 taskId)
     case 2:
         data[1]++;
         if (data[1] == 14)
-            ((struct IntroSequenceData *)GetWordTaskArg(taskId, 5))->field_0006 = 1;
+            ((struct IntroSequenceData *)GetWordTaskArg(taskId, 5))->gengarAttackLanded = TRUE;
         if (data[1] > 15)
         {
             data[1] = 0;
@@ -1665,7 +1664,7 @@ static void sub_80EE024(u8 taskId)
         data[1]++;
         if (data[1] == 4)
         {
-            sub_80EE160();
+            FightScene4_CreateGengarSwipeSprites();
             data[8] = 32;
             data[9] = 48;
             data[7] = 3;
@@ -1694,34 +1693,35 @@ static void sub_80EE024(u8 taskId)
     angle = data[3];
     b = -((gSineTable[angle + 0x40] * data[9]) >> 8);
     c = data[8] - ((gSineTable[angle] * data[8]) >> 8);
-    sub_80EDFD8(data[7], b, c, data[4]);
+    FightScene4_ApplyGengarAnim(data[7], b, c, data[4]);
 }
 
-static void sub_80EE160(void)
+static void FightScene4_CreateGengarSwipeSprites(void)
 {
     u8 spriteId;
     
-    spriteId = CreateSprite(&gUnknown_840BE8C, 132,  78, 6);
-    spriteId = CreateSprite(&gUnknown_840BE8C, 132, 118, 6);
+    spriteId = CreateSprite(&sSpriteTemplate_GengarSwipe, 132,  78, 6);
+    spriteId = CreateSprite(&sSpriteTemplate_GengarSwipe, 132, 118, 6);
     if (spriteId != MAX_SPRITES)
     {
         gSprites[spriteId].oam.shape = ST_OAM_H_RECTANGLE;
         gSprites[spriteId].oam.size = ST_OAM_SIZE_2;
-        sub_80EDAD8(&gSprites[spriteId]);
+        FightScene_CalcCenterToCornerVec(&gSprites[spriteId]);
         StartSpriteAnim(&gSprites[spriteId], 1);
     }
 }
 
-static void sub_80EE1C4(struct Sprite * sprite)
+static void SpriteCB_GengarSwipe(struct Sprite * sprite)
 {
     sprite->invisible ^= TRUE;
     if (sprite->animEnded)
         DestroySprite(sprite);
 }
 
-static void sub_80EE200(u8 taskId)
+static void Task_FightScene3_Bg0Scroll(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
+    static EWRAM_DATA u32 gUnknown_203AB30 = 0;
 
     switch (data[0])
     {
@@ -1745,7 +1745,7 @@ static void sub_80EE200(u8 taskId)
     }
 }
 
-static void sub_80EE29C(struct Sprite * sprite)
+static void SpriteCB_LargeStar(struct Sprite * sprite)
 {
     u32 v;
     sprite->data[0] -= sprite->data[2];
@@ -1761,13 +1761,13 @@ static void sub_80EE29C(struct Sprite * sprite)
         v = v * 1103515245 + 24691;
         StoreWordInTwoHalfwords(&sprite->data[6], v);
         v >>= 16;
-        sub_80EDD28(sprite->pos1.x, sprite->pos1.y + sprite->pos2.y, v);
+        GameFreakScene_TrailingSparklesGen(sprite->pos1.x, sprite->pos1.y + sprite->pos2.y, v);
     }
     if (sprite->pos1.x < -8)
         DestroySprite(sprite);
 }
 
-static void sub_80EE350(struct Sprite * sprite)
+static void SpriteCB_TrailingSparkles(struct Sprite * sprite)
 {
     u32 v;
 
@@ -1790,7 +1790,7 @@ static void sub_80EE350(struct Sprite * sprite)
         DestroySprite(sprite);
 }
 
-static void sub_80EE40C(struct Sprite * sprite)
+static void SpriteCB_TrailingSparkles2(struct Sprite * sprite)
 {
     if (sprite->data[2])
     {
@@ -1839,31 +1839,31 @@ static void sub_80EE40C(struct Sprite * sprite)
     }
 }
 
-static void sub_80EE4DC(struct Sprite * sprite)
+static void SpriteCB_RevealGameFreakTextSparkles(struct Sprite * sprite)
 {
     if (sprite->animEnded)
         DestroySprite(sprite);
 }
 
-static void sub_80EE4F8(struct IntroSequenceData * this)
+static void CreateNidorinoAnimSprite(struct IntroSequenceData * this)
 {
-    u8 spriteId = CreateSprite(&gUnknown_840BD88, 0, 0, 9);
-    this->field_0018 = &gSprites[spriteId];
+    u8 spriteId = CreateSprite(&sSpriteTemplate_NidorinoAnim, 0, 0, 9);
+    this->nidorinoAnimSprite = &gSprites[spriteId];
 }
 
-static void sub_80EE528(struct Sprite * sprite, s16 a1, s16 a2, u16 a3)
+static void StartNidorinoAnimSpriteSlideIn(struct Sprite * sprite, s16 x0, s16 x1, u16 speed)
 {
-    sprite->data[0] = a1 << 4;
-    sprite->data[1] = ((a2 - a1) << 4) / a3;
-    sprite->data[2] = a3;
-    sprite->data[3] = a2;
+    sprite->data[0] = x0 << 4;
+    sprite->data[1] = ((x1 - x0) << 4) / speed;
+    sprite->data[2] = speed;
+    sprite->data[3] = x1;
     sprite->data[4] = 0;
-    sprite->pos1.x = a1;
+    sprite->pos1.x = x0;
     sprite->pos1.y = 100;
-    sprite->callback = sub_80EE580;
+    sprite->callback = SpriteCB_NidorinoAnimSpriteSlideIn;
 }
 
-static void sub_80EE580(struct Sprite * sprite)
+static void SpriteCB_NidorinoAnimSpriteSlideIn(struct Sprite * sprite)
 {
     sprite->data[4]++;
     if (sprite->data[4] >= 40)
@@ -1880,21 +1880,21 @@ static void sub_80EE580(struct Sprite * sprite)
     }
 }
 
-static bool32 sub_80EE5C8(struct IntroSequenceData * ptr)
+static bool32 IsNidorinoAnimSpriteSlideInRunning(struct IntroSequenceData * ptr)
 {
-    return ptr->field_0018->callback == sub_80EE580 ? TRUE : FALSE;
+    return ptr->nidorinoAnimSprite->callback == SpriteCB_NidorinoAnimSpriteSlideIn ? TRUE : FALSE;
 }
 
-static void sub_80EE5E4(struct IntroSequenceData * ptr)
+static void FightScene4_NidorinoRearsUp(struct IntroSequenceData * ptr)
 {
-    StartSpriteAnim(ptr->field_0018, 2);
-    ptr->field_0018->data[0] = 0;
-    ptr->field_0018->data[1] = 0;
-    ptr->field_0018->pos2.y = 3;
-    ptr->field_0018->callback = sub_80EE610;
+    StartSpriteAnim(ptr->nidorinoAnimSprite, 2);
+    ptr->nidorinoAnimSprite->data[0] = 0;
+    ptr->nidorinoAnimSprite->data[1] = 0;
+    ptr->nidorinoAnimSprite->pos2.y = 3;
+    ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoRearsUp;
 }
 
-static void sub_80EE610(struct Sprite * sprite)
+static void SpriteCB_NidorinoRearsUp(struct Sprite * sprite)
 {
     switch (sprite->data[0])
     {
@@ -1930,23 +1930,23 @@ static void sub_80EE610(struct Sprite * sprite)
     }
 }
 
-static void sub_80EE6A4(struct IntroSequenceData * ptr)
+static void FightScene4_StartNidorinoRecoilAnim(struct IntroSequenceData * ptr)
 {
     gUnknown_203AB0A = 16;
     gUnknown_203AB04 = 3;
     gUnknown_203AB08 = 5;
     gUnknown_203AB06 = 0;
-    StartSpriteAnim(ptr->field_0018, 2);
-    ptr->field_0018->data[0] = 0;
-    ptr->field_0018->data[1] = 0;
-    ptr->field_0018->data[2] = 0;
-    ptr->field_0018->data[3] = 0;
-    ptr->field_0018->data[4] = 0;
-    ptr->field_0018->data[7] = 40;
-    ptr->field_0018->callback = sub_80EE704;
+    StartSpriteAnim(ptr->nidorinoAnimSprite, 2);
+    ptr->nidorinoAnimSprite->data[0] = 0;
+    ptr->nidorinoAnimSprite->data[1] = 0;
+    ptr->nidorinoAnimSprite->data[2] = 0;
+    ptr->nidorinoAnimSprite->data[3] = 0;
+    ptr->nidorinoAnimSprite->data[4] = 0;
+    ptr->nidorinoAnimSprite->data[7] = 40;
+    ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoRecoil;
 }
 
-static void sub_80EE704(struct Sprite * sprite)
+static void SpriteCB_NidorinoRecoil(struct Sprite * sprite)
 {
     switch (sprite->data[0])
     {
@@ -1985,7 +1985,7 @@ static void sub_80EE704(struct Sprite * sprite)
         sprite->data[1]++;
         if (sprite->data[1] > 6)
         {
-            sub_80EE864(sprite->pos1.x + sprite->pos2.x, sprite->pos1.y + sprite->pos2.y, sprite->data[6]);
+            CreateNidorinoRecoilDustSprites(sprite->pos1.x + sprite->pos2.x, sprite->pos1.y + sprite->pos2.y, sprite->data[6]);
             sprite->data[6] *= 1103515245;
         }
         if (sprite->data[1] > 12)
@@ -1999,36 +1999,36 @@ static void sub_80EE704(struct Sprite * sprite)
         sprite->data[1]++;
         if (sprite->data[1] > 16)
         {
-            sub_80EE970(sprite, gUnknown_203AB0A, -sprite->pos2.x, 4);
+            StartSpriteHopToPosAnim(sprite, gUnknown_203AB0A, -sprite->pos2.x, 4);
         }
         break;
     }
 }
 
-static bool8 sub_80EE850(struct IntroSequenceData * ptr)
+static bool8 FightScene4_NidorinoAnimIsRunning(struct IntroSequenceData * ptr)
 {
-    return ptr->field_0018->callback == SpriteCallbackDummy ? FALSE : TRUE;
+    return ptr->nidorinoAnimSprite->callback == SpriteCallbackDummy ? FALSE : TRUE;
 }
 
-static void sub_80EE864(s16 a1, s16 a2, s16 a3)
+static void CreateNidorinoRecoilDustSprites(s16 x, s16 y, s16 seed)
 {
     int i;
     u8 spriteId;
 
     for (i = 0; i < 2; i++)
     {
-        spriteId = CreateSprite(&gUnknown_840BEC4, a1 - 22, a2 + 24, 10);
+        spriteId = CreateSprite(&sSpriteTemplate_NidorinoRecoilDust, x - 22, y + 24, 10);
         if (spriteId != MAX_SPRITES)
         {
-            gSprites[spriteId].data[3] = (a3 % 13) + 8;
-            gSprites[spriteId].data[4] = a3 % 3;
+            gSprites[spriteId].data[3] = (seed % 13) + 8;
+            gSprites[spriteId].data[4] = seed % 3;
             gSprites[spriteId].data[7] = i;
-            a3 *= 1103515245;
+            seed *= 1103515245;
         }
     }
 }
 
-static void sub_80EE8E4(struct Sprite * sprite)
+static void SpriteCB_NidorinoRecoilDust(struct Sprite * sprite)
 {
     s16 * data = sprite->data;
 
@@ -2056,7 +2056,7 @@ static void sub_80EE8E4(struct Sprite * sprite)
     }
 }
 
-static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3)
+static void StartSpriteHopToPosAnim(struct Sprite * sprite, u16 a1, s16 a2, u8 a3)
 {
     sprite->data[0] = 0;
     sprite->data[1] = a1;
@@ -2067,10 +2067,10 @@ static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3)
     sprite->data[6] = 0;
     sprite->data[7] = a3;
     StartSpriteAnim(sprite, 2);
-    sprite->callback = sub_80EE9D4;
+    sprite->callback = SpriteCB_HopToPos;
 }
 
-static void sub_80EE9D4(struct Sprite * sprite)
+static void SpriteCB_HopToPos(struct Sprite * sprite)
 {
     switch (sprite->data[0])
     {
@@ -2117,26 +2117,26 @@ static void sub_80EE9D4(struct Sprite * sprite)
     }
 }
 
-static void sub_80EEA94(struct IntroSequenceData * ptr)
+static void StartNidorinoAnim_LaunchSelfAtGengarAnim(struct IntroSequenceData * ptr)
 {
-    ptr->field_0018->data[0] = 0;
-    ptr->field_0018->data[1] = 0;
-    ptr->field_0018->data[2] = 0;
-    ptr->field_0018->data[3] = 0;
-    ptr->field_0018->data[4] = 0;
-    ptr->field_0018->data[5] = 0;
-    ptr->field_0018->pos1.x += ptr->field_0018->pos2.x;
-    ptr->field_0018->pos2.x = 0;
+    ptr->nidorinoAnimSprite->data[0] = 0;
+    ptr->nidorinoAnimSprite->data[1] = 0;
+    ptr->nidorinoAnimSprite->data[2] = 0;
+    ptr->nidorinoAnimSprite->data[3] = 0;
+    ptr->nidorinoAnimSprite->data[4] = 0;
+    ptr->nidorinoAnimSprite->data[5] = 0;
+    ptr->nidorinoAnimSprite->pos1.x += ptr->nidorinoAnimSprite->pos2.x;
+    ptr->nidorinoAnimSprite->pos2.x = 0;
     gUnknown_203AB0C = 0x24;
     gUnknown_203AB06 = 0x28;
     gUnknown_203AB04 = 0x03;
     gUnknown_203AB08 = 0x04;
-    ptr->field_0018->data[7] = 36;
-    StartSpriteAnim(ptr->field_0018, 2);
-    ptr->field_0018->callback = sub_80EEB08;
+    ptr->nidorinoAnimSprite->data[7] = 36;
+    StartSpriteAnim(ptr->nidorinoAnimSprite, 2);
+    ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoAnim_LaunchSelfAtGengar;
 }
 
-static void sub_80EEB08(struct Sprite * sprite)
+static void SpriteCB_NidorinoAnim_LaunchSelfAtGengar(struct Sprite * sprite)
 {
     switch (sprite->data[0])
     {
@@ -2178,15 +2178,15 @@ static void sub_80EEB08(struct Sprite * sprite)
     }
 }
 
-static void sub_80EEBE4(void)
+static void LoadFightSceneSpriteTilesAndPals(void)
 {
     int i;
     
-    for (i = 0; i < NELEMS(gUnknown_840BEDC); i++)
+    for (i = 0; i < NELEMS(sFightSceneSpriteSheets); i++)
     {
-        LoadCompressedSpriteSheet(&gUnknown_840BEDC[i]);
+        LoadCompressedSpriteSheet(&sFightSceneSpriteSheets[i]);
     }
-    // gUnknown_840BF14 is not properly terminated, so this
+    // sFightSceneSpritePalettes is not properly terminated, so this
     // call exhibits undefined behavior.
-    LoadSpritePalettes(gUnknown_840BF14);
+    LoadSpritePalettes(sFightSceneSpritePalettes);
 }
diff --git a/src/item_menu.c b/src/item_menu.c
index e048b4b78..ebad0640d 100644
--- a/src/item_menu.c
+++ b/src/item_menu.c
@@ -377,7 +377,7 @@ static void CB2_OpenBagMenu(void)
 {
     while (1)
     {
-        if ((u8)sub_80BF72C() == TRUE)
+        if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
             break;
         if (LoadBagMenuGraphics() == TRUE)
             break;
@@ -1050,7 +1050,7 @@ static void Task_BagMenu_HandleInput(u8 taskId)
         return;
     if (FuncIsActiveTask(Task_AnimateWin0v) == TRUE)
         return;
-    if ((u8)sub_80BF72C() == TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
         return;
     switch (ProcessPocketSwitchInput(taskId, gBagMenuState.pocket))
     {
@@ -1244,7 +1244,7 @@ static void Task_MoveItemInPocket_HandleInput(u8 taskId)
     s32 input;
     u16 itemsAbove;
     u16 cursorPos;
-    if ((u8)sub_80BF72C() == TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
         return;
     input = ListMenu_ProcessInput(data[0]);
     ListMenuGetScrollAndRow(data[0], &gBagMenuState.cursorPos[gBagMenuState.pocket], &gBagMenuState.itemsAbove[gBagMenuState.pocket]);
@@ -1447,7 +1447,7 @@ static void Task_ItemContext_FieldOrBattle(u8 taskId)
 static void Task_FieldItemContextMenuHandleInput(u8 taskId)
 {
     s8 input;
-    if ((u8)sub_80BF72C() != TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() != TRUE)
     {
         input = Menu_ProcessInputNoWrapAround();
         switch (input)
@@ -2036,7 +2036,7 @@ bool8 UseRegisteredKeyItemOnField(void)
             ScriptContext2_Enable();
             FreezeObjectEvents();
             sub_805C270();
-            sub_805C780();
+            StopPlayerAvatar();
             gSpecialVar_ItemId = gSaveBlock1Ptr->registeredItem;
             taskId = CreateTask(ItemId_GetFieldFunc(gSaveBlock1Ptr->registeredItem), 8);
             gTasks[taskId].data[3] = 1;
diff --git a/src/item_pc.c b/src/item_pc.c
index af57d9f03..1fda50d6f 100644
--- a/src/item_pc.c
+++ b/src/item_pc.c
@@ -385,7 +385,7 @@ static bool8 ItemPc_DoGfxSetup(void)
         gMain.state++;
         break;
     case 20:
-        if ((u8)sub_80BF72C() != TRUE)
+        if ((u8)MenuHelpers_CallLinkSomething() != TRUE)
             gMain.state++;
         break;
     default:
diff --git a/src/item_use.c b/src/item_use.c
index af3243678..45bed65e8 100644
--- a/src/item_use.c
+++ b/src/item_use.c
@@ -268,7 +268,7 @@ void FieldUseFunc_MachBike(u8 taskId)
      || MetatileBehavior_IsIsolatedVerticalRail(behavior) == TRUE
      || MetatileBehavior_IsIsolatedHorizontalRail(behavior) == TRUE)
         sub_80A10C4(taskId, gTasks[taskId].data[3], 2, gUnknown_8416451);
-    else if (Overworld_IsBikingAllowed() == TRUE && !sub_80BD540())
+    else if (Overworld_IsBikingAllowed() == TRUE && !MetatileAtPlayerPositionForbidsBiking())
     {
         sItemUseOnFieldCB = ItemUseOnFieldCB_Bicycle;
         sub_80A103C(taskId);
diff --git a/src/mail.c b/src/mail.c
index b5c0343b3..9a28fae41 100644
--- a/src/mail.c
+++ b/src/mail.c
@@ -588,7 +588,7 @@ static bool8 DoInitMailView(void)
         }
         break;
     case 15:
-        if (sub_8058244() == TRUE)
+        if (Overworld_LinkRecvQueueLengthMoreThan2() == TRUE)
             return FALSE;
         break;
     case 16:
diff --git a/src/map_name_popup.c b/src/map_name_popup.c
index 87df371ce..6f7fa5d3c 100644
--- a/src/map_name_popup.c
+++ b/src/map_name_popup.c
@@ -18,26 +18,36 @@ static u16 MapNamePopupCreateWindow(bool32 palIntoFadedBuffer);
 static void MapNamePopupPrintMapNameOnWindow(u16 windowId);
 static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags);
 
+#define tState              data[0]
+#define tTimer              data[1]
+#define tPos                data[2]
+#define tReshow             data[3]
+#define tWindowId           data[4]
+#define tWindowExists       data[5]
+#define tWindowCleared      data[6]
+#define tWindowDestroyed    data[7]
+#define tPalIntoFadedBuffer data[8]
+
 void ShowMapNamePopup(bool32 palIntoFadedBuffer)
 {
     u8 taskId;
-    if (FlagGet(FLAG_SPECIAL_FLAG_0x4000) != TRUE && !(gQuestLogState == 2 || gQuestLogState == 3))
+    if (FlagGet(FLAG_DONT_SHOW_MAP_NAME_POPUP) != TRUE && !(gQuestLogState == QL_STATE_2 || gQuestLogState == QL_STATE_3))
     {
         taskId = FindTaskIdByFunc(Task_MapNamePopup);
         if (taskId == 0xFF)
         {
             taskId = CreateTask(Task_MapNamePopup, 90);
-            ChangeBgX(0, 0x00000000, 0);
-            ChangeBgY(0, 0xFFFFEF7F, 0);
-            gTasks[taskId].data[0] = 0;
-            gTasks[taskId].data[2] = 0;
-            gTasks[taskId].data[8] = palIntoFadedBuffer;
+            ChangeBgX(0,  0x0000, 0);
+            ChangeBgY(0, -0x1081, 0);
+            gTasks[taskId].tState = 0;
+            gTasks[taskId].tPos = 0;
+            gTasks[taskId].tPalIntoFadedBuffer = palIntoFadedBuffer;
         }
         else
         {
-            if (gTasks[taskId].data[0] != 4)
-                gTasks[taskId].data[0] = 4;
-            gTasks[taskId].data[3] = 1;
+            if (gTasks[taskId].tState != 4)
+                gTasks[taskId].tState = 4;
+            gTasks[taskId].tReshow = TRUE;
         }
     }
 }
@@ -45,71 +55,71 @@ void ShowMapNamePopup(bool32 palIntoFadedBuffer)
 static void Task_MapNamePopup(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
-    switch (task->data[0])
+    switch (task->tState)
     {
     case 0:
-        task->data[4] = MapNamePopupCreateWindow(task->data[8]);
-        task->data[5] = 1;
-        task->data[0] = 1;
+        task->tWindowId = MapNamePopupCreateWindow(task->tPalIntoFadedBuffer);
+        task->tWindowExists = TRUE;
+        task->tState = 1;
         break;
     case 1:
         if (IsDma3ManagerBusyWithBgCopy())
             break;
         // fallthrough
     case 2:
-        task->data[2] -= 2;
-        if (task->data[2] <= -24)
+        task->tPos -= 2;
+        if (task->tPos <= -24)
         {
-            task->data[0] = 3;
-            task->data[1] = 0;
+            task->tState = 3;
+            task->tTimer = 0;
         }
         break;
     case 3:
-        task->data[1]++;
-        if (task->data[1] > 120)
+        task->tTimer++;
+        if (task->tTimer > 120)
         {
-            task->data[1] = 0;
-            task->data[0] = 4;
+            task->tTimer = 0;
+            task->tState = 4;
         }
         break;
     case 4:
-        task->data[2] += 2;
-        if (task->data[2] >= 0)
+        task->tPos += 2;
+        if (task->tPos >= 0)
         {
-            if (task->data[3])
+            if (task->tReshow)
             {
-                MapNamePopupPrintMapNameOnWindow(task->data[4]);
-                CopyWindowToVram(task->data[4], 2);
-                task->data[0] = 1;
-                task->data[3] = 0;
+                MapNamePopupPrintMapNameOnWindow(task->tWindowId);
+                CopyWindowToVram(task->tWindowId, 2);
+                task->tState = 1;
+                task->tReshow = FALSE;
             }
             else
             {
-                task->data[0] = 6;
+                task->tState = 6;
                 return;
             }
         }
     case 5:
         break;
     case 6:
-        if (task->data[5] && !task->data[6])
+        if (task->tWindowExists && !task->tWindowCleared)
         {
-            rbox_fill_rectangle(task->data[4]);
-            CopyWindowToVram(task->data[4], 1);
-            task->data[6] = 1;
+            rbox_fill_rectangle(task->tWindowId);
+            CopyWindowToVram(task->tWindowId, 1);
+            task->tWindowCleared = TRUE;
         }
-        task->data[0] = 7;
+        task->tState = 7;
         return;
     case 7:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            if (task->data[5])
+            if (task->tWindowExists)
             {
-                RemoveWindow(task->data[4]);
-                task->data[5] = 0;
-                task->data[7] = 1;
+                RemoveWindow(task->tWindowId);
+                task->tWindowExists = FALSE;
+                task->tWindowDestroyed = TRUE;
             }
-            task->data[0] = 8;
+            task->tState = 8;
             ChangeBgY(0, 0x00000000, 0);
         }
         return;
@@ -117,7 +127,7 @@ static void Task_MapNamePopup(u8 taskId)
         DestroyTask(taskId);
         return;
     }
-    SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]);
+    SetGpuReg(REG_OFFSET_BG0VOFS, task->tPos);
 }
 
 void DismissMapNamePopup(void)
@@ -128,8 +138,8 @@ void DismissMapNamePopup(void)
     if (taskId != 0xFF)
     {
         data = gTasks[taskId].data;
-        if (data[0] < 6)
-            data[0] = 6;
+        if (tState < 6)
+            tState = 6;
     }
 }
 
@@ -160,6 +170,7 @@ static u16 MapNamePopupCreateWindow(bool32 palintoFadedBuffer)
         }
         else
         {
+            // ROOFTOP
             windowTemplate.width += 8;
             r6 = 0x02D;
         }
@@ -194,7 +205,7 @@ static void MapNamePopupPrintMapNameOnWindow(u16 windowId)
     }
     xpos = (maxWidth - GetStringWidth(2, mapName, -1)) / 2;
     FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
-    AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, 0xFF, NULL);
+    AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, TEXT_SPEED_FF, NULL);
 }
 
 static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum)
@@ -203,7 +214,7 @@ static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum)
         return dest;
     *dest++ = CHAR_SPACE;
     if (floorNum == 0x7F)
-        return StringCopy(dest, gUnknown_841D18D);
+        return StringCopy(dest, gText_Rooftop2);
     if (floorNum < 0)
     {
         *dest++ = CHAR_B;
@@ -214,3 +225,13 @@ static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum)
     *dest = EOS;
     return dest;
 }
+
+#undef tPalIntoFadedBuffer
+#undef tWindowDestroyed
+#undef tWindowCleared
+#undef tWindowExists
+#undef tWindowId
+#undef tReshow
+#undef tPos
+#undef tTimer
+#undef tState
diff --git a/src/menu_helpers.c b/src/menu_helpers.c
index dedd7aa9e..8e63ea99d 100644
--- a/src/menu_helpers.c
+++ b/src/menu_helpers.c
@@ -125,17 +125,17 @@ bool8 MenuHelpers_LinkSomething(void)
         return FALSE;
 }
 
-bool32 sub_80BF72C(void)
+bool32 MenuHelpers_CallLinkSomething(void)
 {
     if (!MenuHelpers_LinkSomething())
         return FALSE;
     else
-        return (u8)sub_8058244();
+        return (u8)Overworld_LinkRecvQueueLengthMoreThan2();
 }
 
 bool8 sub_80BF748(void)
 {
-    if ((u8)sub_80BF72C() == TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
         return TRUE;
     else if (sub_800B270() != TRUE)
         return FALSE;
diff --git a/src/normal.c b/src/normal.c
index 4e045340f..366219c72 100644
--- a/src/normal.c
+++ b/src/normal.c
@@ -326,7 +326,7 @@ u32 UnpackSelectedBattleAnimPalettes(s16 selector)
     u8 arg5 = (selector >> 5) & 1;
     u8 arg6 = (selector >> 6) & 1;
 
-    return sub_8075BE8(battleBackground, attacker, target, attackerPartner, targetPartner, arg5, arg6);
+    return SelectBattleAnimSpriteAndBgPalettes(battleBackground, attacker, target, attackerPartner, targetPartner, arg5, arg6);
 }
 
 static void AnimSimplePaletteBlendStep(struct Sprite *sprite)
@@ -406,7 +406,7 @@ static void sub_80B9B8C(struct Sprite *sprite)
     sprite->callback(sprite);
 }
 
-void sub_80B9BDC(u8 taskId)
+void AnimTask_CurseBlendEffect(u8 taskId)
 {
     gTasks[taskId].data[0] = gBattleAnimArgs[0];
     gTasks[taskId].data[1] = gBattleAnimArgs[1];
@@ -659,7 +659,7 @@ void sub_80BA0E8(u8 taskId)
     u8 targetBattler = gBattleAnimTarget;
 
     if (gBattleAnimArgs[0] & 0x100)
-        selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0);
+        selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0);
     if (gBattleAnimArgs[1] & 0x100)
         selectedPalettes |= (0x10000 << attackerBattler);
     if (gBattleAnimArgs[2] & 0x100)
diff --git a/src/option_menu.c b/src/option_menu.c
index 87306c98f..54cca0501 100644
--- a/src/option_menu.c
+++ b/src/option_menu.c
@@ -43,11 +43,10 @@ enum
 struct OptionMenu
 {
     /*0x00*/ u16 option[MENUITEM_COUNT];
-    /*0x0E*/ u16 unkE;
-    /*0x10*/ u8 state3;
+    /*0x0E*/ u16 cursorPos;
+    /*0x10*/ u8 loadState;
     /*0x11*/ u8 state;
-    /*0x12*/ u8 state2;
-    /*0x13*/ u8 unk13;
+    /*0x12*/ u8 loadPaletteState;
 };
 
 static EWRAM_DATA struct OptionMenu *sOptionMenuPtr = NULL;
@@ -68,9 +67,9 @@ static u8 OptionMenu_ProcessInput(void);
 static void BufferOptionMenuString(u8 selection);
 static void CloseAndSaveOptionMenu(u8 taskId);
 static void PrintOptionMenuHeader(void);
-static void sub_8088C0C(void);
+static void DrawOptionMenuBg(void);
 static void LoadOptionMenuItemNames(void);
-static void sub_8088DE0(u16 selection);
+static void UpdateSettingSelectionDisplay(u16 selection);
 
 // Data Definitions
 static const struct WindowTemplate sOptionMenuWinTemplates[] =
@@ -208,10 +207,10 @@ void CB2_OptionsMenuFromStartMenu(void)
     if (gMain.savedCallback == NULL)
         gMain.savedCallback = CB2_ReturnToFieldWithOpenMenu;
     sOptionMenuPtr = AllocZeroed(sizeof(struct OptionMenu));
-    sOptionMenuPtr->state3 = 0;
-    sOptionMenuPtr->state2 = 0;
+    sOptionMenuPtr->loadState = 0;
+    sOptionMenuPtr->loadPaletteState = 0;
     sOptionMenuPtr->state = 0;
-    sOptionMenuPtr->unkE = 0;
+    sOptionMenuPtr->cursorPos = 0;
     sOptionMenuPtr->option[MENUITEM_TEXTSPEED] = gSaveBlock2Ptr->optionsTextSpeed;
     sOptionMenuPtr->option[MENUITEM_BATTLESCENE] = gSaveBlock2Ptr->optionsBattleSceneOff;
     sOptionMenuPtr->option[MENUITEM_BATTLESTYLE] = gSaveBlock2Ptr->optionsBattleStyle;
@@ -262,7 +261,7 @@ static void CB2_OptionMenu(void)
         PrintOptionMenuHeader();
         break;
     case 5:
-        sub_8088C0C();
+        DrawOptionMenuBg();
         break;
     case 6:
         LoadOptionMenuItemNames();
@@ -272,7 +271,7 @@ static void CB2_OptionMenu(void)
             BufferOptionMenuString(i);
         break;
     case 8:
-        sub_8088DE0(sOptionMenuPtr->unkE);
+        UpdateSettingSelectionDisplay(sOptionMenuPtr->cursorPos);
         break;
     case 9:
         OptionMenu_PickSwitchCancel();
@@ -340,7 +339,7 @@ static void OptionMenu_ResetSpriteData(void)
 
 static bool8 LoadOptionMenuPalette(void)
 {
-    switch (sOptionMenuPtr->state2)
+    switch (sOptionMenuPtr->loadPaletteState)
     {
     case 0:
         LoadBgTiles(1, GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->tiles, 0x120, 0x1AA);
@@ -358,51 +357,55 @@ static bool8 LoadOptionMenuPalette(void)
     default:
         return TRUE;
     }
-    sOptionMenuPtr->state2++;
+    sOptionMenuPtr->loadPaletteState++;
     return FALSE;
 }
 
 static void Task_OptionMenu(u8 taskId)
 {
-    switch (sOptionMenuPtr->state3)
+    switch (sOptionMenuPtr->loadState)
     {
     case 0:
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK);
         OptionMenu_SetVBlankCallback();
-        sOptionMenuPtr->state3++;
+        sOptionMenuPtr->loadState++;
+        break;
+    case 1:
+        if (gPaletteFade.active)
+            return;
+        sOptionMenuPtr->loadState++;
         break;
     case 2:
-        if (sub_80BF72C() == TRUE)
+        if (MenuHelpers_CallLinkSomething() == TRUE)
             break;
         switch (OptionMenu_ProcessInput())
         {
         case 0:
             break;
         case 1:
-            sOptionMenuPtr->state3++;
+            sOptionMenuPtr->loadState++;
             break;
         case 2:
             LoadBgTiles(1, GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->tiles, 0x120, 0x1AA);
             LoadPalette(GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->palette, 0x20, 0x20);
-            BufferOptionMenuString(sOptionMenuPtr->unkE);
+            BufferOptionMenuString(sOptionMenuPtr->cursorPos);
             break;
         case 3:
-            sub_8088DE0(sOptionMenuPtr->unkE);
+            UpdateSettingSelectionDisplay(sOptionMenuPtr->cursorPos);
             break;
         case 4:
-            BufferOptionMenuString(sOptionMenuPtr->unkE);
+            BufferOptionMenuString(sOptionMenuPtr->cursorPos);
             break;
         }
         break;
     case 3:
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK);
-        sOptionMenuPtr->state3++;
+        sOptionMenuPtr->loadState++;
         break;
-    case 1:
     case 4:
         if (gPaletteFade.active)
             return;
-        sOptionMenuPtr->state3++;
+        sOptionMenuPtr->loadState++;
         break;
     case 5:
         CloseAndSaveOptionMenu(taskId);
@@ -416,43 +419,43 @@ static u8 OptionMenu_ProcessInput(void)
     u16* curr;
     if (JOY_REPT(DPAD_RIGHT))
     {
-        current = sOptionMenuPtr->option[(sOptionMenuPtr->unkE)];
-        if (current == (sOptionMenuItemCounts[sOptionMenuPtr->unkE] - 1))
-            sOptionMenuPtr->option[sOptionMenuPtr->unkE] = 0;
+        current = sOptionMenuPtr->option[(sOptionMenuPtr->cursorPos)];
+        if (current == (sOptionMenuItemCounts[sOptionMenuPtr->cursorPos] - 1))
+            sOptionMenuPtr->option[sOptionMenuPtr->cursorPos] = 0;
         else
-            sOptionMenuPtr->option[sOptionMenuPtr->unkE] = current + 1;
-        if (sOptionMenuPtr->unkE == MENUITEM_FRAMETYPE)
+            sOptionMenuPtr->option[sOptionMenuPtr->cursorPos] = current + 1;
+        if (sOptionMenuPtr->cursorPos == MENUITEM_FRAMETYPE)
             return 2;
         else
             return 4;
     }
     else if (JOY_REPT(DPAD_LEFT))
     {
-        curr = &sOptionMenuPtr->option[sOptionMenuPtr->unkE];
+        curr = &sOptionMenuPtr->option[sOptionMenuPtr->cursorPos];
         if (*curr == 0)
-            *curr = sOptionMenuItemCounts[sOptionMenuPtr->unkE] - 1;
+            *curr = sOptionMenuItemCounts[sOptionMenuPtr->cursorPos] - 1;
         else
             --*curr;
         
-        if (sOptionMenuPtr->unkE == MENUITEM_FRAMETYPE)
+        if (sOptionMenuPtr->cursorPos == MENUITEM_FRAMETYPE)
             return 2;
         else
             return 4;
     }
     else if (JOY_REPT(DPAD_UP))
     {
-        if (sOptionMenuPtr->unkE == MENUITEM_TEXTSPEED)
-            sOptionMenuPtr->unkE = MENUITEM_CANCEL;
+        if (sOptionMenuPtr->cursorPos == MENUITEM_TEXTSPEED)
+            sOptionMenuPtr->cursorPos = MENUITEM_CANCEL;
         else
-            sOptionMenuPtr->unkE = sOptionMenuPtr->unkE - 1;
+            sOptionMenuPtr->cursorPos = sOptionMenuPtr->cursorPos - 1;
         return 3;        
     }
     else if (JOY_REPT(DPAD_DOWN))
     {
-        if (sOptionMenuPtr->unkE == MENUITEM_CANCEL)
-            sOptionMenuPtr->unkE = MENUITEM_TEXTSPEED;
+        if (sOptionMenuPtr->cursorPos == MENUITEM_CANCEL)
+            sOptionMenuPtr->cursorPos = MENUITEM_TEXTSPEED;
         else
-            sOptionMenuPtr->unkE = sOptionMenuPtr->unkE + 1;
+            sOptionMenuPtr->cursorPos = sOptionMenuPtr->cursorPos + 1;
         return 3;
     }
     else if (JOY_NEW(B_BUTTON) || JOY_NEW(A_BUTTON))
@@ -531,7 +534,7 @@ static void PrintOptionMenuHeader(void)
     CopyWindowToVram(0, 3);
 }
 
-static void sub_8088C0C(void)
+static void DrawOptionMenuBg(void)
 {
     u8 h;
     h = 2;
@@ -566,12 +569,12 @@ static void LoadOptionMenuItemNames(void)
     }
 }
 
-static void sub_8088DE0(u16 selection)
+static void UpdateSettingSelectionDisplay(u16 selection)
 {
-    u16 v1, v2;
+    u16 maxLetterHeight, y;
     
-    v1 = GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT);
-    v2 = selection * (v1 - 1) + 0x3A;
-    SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(v2, v2 + v1));
+    maxLetterHeight = GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT);
+    y = selection * (maxLetterHeight - 1) + 0x3A;
+    SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(y, y + maxLetterHeight));
     SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0x10, 0xE0));
 }
diff --git a/src/overworld.c b/src/overworld.c
index e86939f10..a4a6213e6 100644
--- a/src/overworld.c
+++ b/src/overworld.c
@@ -120,7 +120,7 @@ u8 gFieldLinkPlayerCount;
 
 static u8 sPlayerTradingStates[4];
 static KeyInterCB sPlayerKeyInterceptCallback;
-static bool8 gUnknown_3000E88;
+static bool8 sReceivingFromLink;
 static u8 sRfuKeepAliveTimer;
 
 static u8 CountBadgesForOverworldWhiteOutLossCalculation(void);
@@ -1037,7 +1037,7 @@ void Overworld_PlaySpecialMapMusic(void)
 
     if (gSaveBlock1Ptr->savedMusic)
         music = gSaveBlock1Ptr->savedMusic;
-    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) &&sub_8056124(MUS_NAMINORI))
+    else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI))
         music = MUS_NAMINORI;
 
     if (music != GetCurrentMapMusic())
@@ -1075,7 +1075,7 @@ static void Overworld_TryMapConnectionMusicTransition(void)
         currentMusic = GetCurrentMapMusic();
         if (currentMusic == MUS_NAMINORI)
             return;
-        if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && sub_8056124(MUS_NAMINORI))
+        if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI))
             newMusic = MUS_NAMINORI;
         if (newMusic != currentMusic)
         {
@@ -1193,7 +1193,7 @@ static void ChooseAmbientCrySpecies(void)
     sAmbientCrySpecies = GetLocalWildMon(&sIsAmbientCryWaterMon);
 }
 
-bool32 sub_8056124(u16 music)
+bool32 Overworld_MusicCanOverrideMapMusic(u16 music)
 {
     if (music == MUS_CYCLING || music == MUS_NAMINORI)
     {
@@ -1427,7 +1427,7 @@ static void DoCB1_Overworld_QuestLogPlayback(void)
     sub_805BEB8();
     sub_8111C68();
     FieldClearPlayerInput(&fieldInput);
-    fieldInput = gUnknown_3005E90;
+    fieldInput = gQuestLogFieldInput;
     FieldInput_HandleCancelSignpost(&fieldInput);
     if (!ScriptContext2_IsEnabled())
     {
@@ -1445,7 +1445,7 @@ static void DoCB1_Overworld_QuestLogPlayback(void)
     {
         RunQuestLogCB();
     }
-    FieldClearPlayerInput(&gUnknown_3005E90);
+    FieldClearPlayerInput(&gQuestLogFieldInput);
 }
 
 void CB1_Overworld(void)
@@ -1555,7 +1555,7 @@ void CB2_WhiteOut(void)
         gFieldCallback = FieldCB_RushInjuredPokemonToCenter;
         val = 0;
         do_load_map_stuff_loop(&val);
-        sub_8112364();
+        QuestLog_OnInteractionWithSpecialNpc();
         SetFieldVBlankCallback();
         SetMainCallback1(CB1_Overworld);
         SetMainCallback2(CB2_Overworld);
@@ -1629,7 +1629,7 @@ static void CB2_ReturnToFieldLocal(void)
 
 static void CB2_ReturnToFieldLink(void)
 {
-    if (!sub_8058244() && map_loading_iteration_2_link(&gMain.state))
+    if (!Overworld_LinkRecvQueueLengthMoreThan2() && map_loading_iteration_2_link(&gMain.state))
         SetMainCallback2(CB2_Overworld);
 }
 
@@ -3181,15 +3181,15 @@ static void sub_8058230(void)
     ScriptContext2_Enable();
 }
 
-bool32 sub_8058244(void)
+bool32 Overworld_LinkRecvQueueLengthMoreThan2(void)
 {
     if (!IsUpdateLinkStateCBActive())
         return FALSE;
     if (GetLinkRecvQueueLength() >= 3)
-        gUnknown_3000E88 = TRUE;
+        sReceivingFromLink = TRUE;
     else
-        gUnknown_3000E88 = FALSE;
-    return gUnknown_3000E88;
+        sReceivingFromLink = FALSE;
+    return sReceivingFromLink;
 }
 
 bool32 sub_8058274(void)
@@ -3207,8 +3207,8 @@ bool32 sub_8058274(void)
     else if (sPlayerKeyInterceptCallback != KeyInterCB_DeferToEventScript)
         return FALSE;
 
-    temp = gUnknown_3000E88;
-    gUnknown_3000E88 = FALSE;
+    temp = sReceivingFromLink;
+    sReceivingFromLink = FALSE;
 
     if (temp == TRUE)
         return TRUE;
diff --git a/src/quest_log.c b/src/quest_log.c
index 3c6b88d3d..51e09e899 100644
--- a/src/quest_log.c
+++ b/src/quest_log.c
@@ -45,8 +45,6 @@
 #include "constants/field_weather.h"
 #include "constants/event_object_movement.h"
 
-u8 gUnknown_3005E88;
-
 struct TrainerFanClub
 {
     u8 timer:7;
@@ -96,7 +94,7 @@ struct UnkStruct_203B044
 
 u8 gUnknown_3005E88;
 u16 sNumEventsInLogEntry;
-struct FieldInput gUnknown_3005E90;
+struct FieldInput gQuestLogFieldInput;
 struct QuestLogEntry * sCurQuestLogEntry;
 
 static struct UnkStruct_300201C * sFlagOrVarRecords;
@@ -108,7 +106,7 @@ EWRAM_DATA u8 gQuestLogState = 0;
 static EWRAM_DATA u16 gUnknown_203ADFC = 0;
 static EWRAM_DATA u8 sQuestLogHeaderWindowIds[3] = {0};
 static EWRAM_DATA u16 *gUnknown_203AE04 = NULL;
-static EWRAM_DATA u16 *gUnknown_203AE08 = NULL;
+static EWRAM_DATA u16 *sEventRecordingPointer = NULL;
 static EWRAM_DATA u16 *gUnknown_203AE0C[32] = {NULL};
 static EWRAM_DATA void (* sQuestLogCB)(void) = NULL;
 static EWRAM_DATA u16 *gUnknown_203AE90 = NULL;
@@ -131,7 +129,7 @@ static void sub_8110A00(void);
 static void sub_8110A3C(void);
 static void SetPlayerInitialCoordsAtScene(u8);
 static void SetNPCInitialCoordsAtScene(u8);
-static void sub_8110E3C(void);
+static void TryRecordEvent39_GoToNextScene(void);
 static void BackUpTrainerRematchesToVars(void);
 static void BackUpMapLayoutToVar(void);
 static void SetGameStateAtScene(u8);
@@ -184,7 +182,7 @@ static bool8 sub_81137E4(u16, const u16 *);
 static u16 *sub_8113828(u16, const u16 *);
 static bool8 TrySetLinkQuestLogEvent(u16, const u16 *);
 static bool8 TrySetTrainerBattleQuestLogEvent(u16, const u16 *);
-static void sub_8113A1C(u16);
+static void TryRecordEvent41_IncCursor(u16);
 static void sub_811381C(void);
 static bool8 IsQuestLogEventWithSpecialEncounterSpecies(u16, const u16 *);
 static u16 *QuestLog_SkipCommand(u16 *, u16 **);
@@ -194,9 +192,9 @@ static bool8 sub_8113B44(const u16 *);
 static void sub_8113B88(void);
 static void sub_8113B94(u16);
 static void sub_8113BD8(void);
-static u16 *sub_8113BF4(u16 *);
+static u16 *TryRecordEvent39_NoParams(u16 *);
 static u16 *sub_8113C20(u16 *, struct QuestLogEntry *);
-static u16 *sub_8113C5C(u16 *, u16);
+static u16 *TryRecordEvent41(u16 *, u16);
 static u16 *sub_8113C8C(u16 *, struct QuestLogEntry *);
 static u16 *sub_8113CC8(u16 *, struct QuestLogEntry *);
 static u16 *sub_8113D08(u16 *, struct QuestLogEntry *);
@@ -302,8 +300,8 @@ void sub_8110840(void * oldPointer)
         gUnknown_203AE04 = (void *)gUnknown_203AE04 + offset;
     if (gQuestLogState != 0)
     {
-        if (gUnknown_203AE08)
-            gUnknown_203AE08 = (void *)gUnknown_203AE08 + offset;
+        if (sEventRecordingPointer)
+            sEventRecordingPointer = (void *)sEventRecordingPointer + offset;
         if (gQuestLogState == QL_STATE_2)
         {
             int r3;
@@ -320,7 +318,7 @@ void ResetQuestLog(void)
     sCurrentSceneNum = 0;
     gQuestLogState = 0;
     sQuestLogCB = NULL;
-    gUnknown_203AE08 = NULL;
+    sEventRecordingPointer = NULL;
     gUnknown_203AE04 = NULL;
     sub_8113BD8();
     sub_81138F8();
@@ -353,12 +351,12 @@ bool8 sub_8110944(const void * a0, size_t cmdSize)
     return TRUE;
 }
 
-bool8 sub_8110988(u16 *a0, size_t a1)
+static bool8 WillCommandOfSizeFitInSav1Record(u16 *cursor, size_t size)
 {
-    void * r2 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568;
-    void * r0 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].end;
-    r0 -= a1;
-    if ((void *)a0 < r2 || (void *)a0 > r0)
+    void * start = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568;
+    void * end = gSaveBlock1Ptr->questLog[sCurrentSceneNum].end;
+    end -= size;
+    if ((void *)cursor < start || (void *)cursor > end)
         return FALSE;
     return TRUE;
 }
@@ -377,7 +375,7 @@ static void sub_8110A00(void)
     if (TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer) != 1)
     {
         gUnknown_3005E88 = 0;
-        sub_8110E3C();
+        TryRecordEvent39_GoToNextScene();
         gQuestLogState = 0;
         sQuestLogCB = NULL;
     }
@@ -418,7 +416,7 @@ static void StartRecordingQuestLogEntry(u16 eventId)
 
     DestroySav1QuestLogEntry(sCurrentSceneNum);
     sub_8113B88();
-    gUnknown_203AE08 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568;
+    sEventRecordingPointer = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568;
     if (IS_LINK_QL_EVENT(eventId) || eventId == QL_EVENT_DEPARTED)
         gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_000 = 2;
     else
@@ -511,9 +509,9 @@ static void BackUpMapLayoutToVar(void)
     VarSet(VAR_QLBAK_MAP_LAYOUT, gSaveBlock1Ptr->mapLayoutId);
 }
 
-static void sub_8110E3C(void)
+static void TryRecordEvent39_GoToNextScene(void)
 {
-    sub_8113BF4(gUnknown_203AE08);
+    TryRecordEvent39_NoParams(sEventRecordingPointer);
     if (++sCurrentSceneNum >= QUEST_LOG_SCENE_COUNT)
         sCurrentSceneNum = 0;
 }
@@ -524,19 +522,19 @@ static bool8 TryRecordQuestLogEntrySequence(struct QuestLogEntry * entry)
 
     for (i = gUnknown_203ADFC; i < sQuestLogCursor; i++)
     {
-        if (gUnknown_203AE08 == NULL)
+        if (sEventRecordingPointer == NULL)
             return FALSE;
         switch (entry[i].unk_6)
         {
         case 0:
         case 1:
-            gUnknown_203AE08 = sub_8113D48(gUnknown_203AE08, &entry[i]);
+            sEventRecordingPointer = sub_8113D48(sEventRecordingPointer, &entry[i]);
             break;
         default:
-            gUnknown_203AE08 = sub_8113CC8(gUnknown_203AE08, &entry[i]);
+            sEventRecordingPointer = sub_8113CC8(sEventRecordingPointer, &entry[i]);
             break;
         }
-        if (gUnknown_203AE08 == NULL)
+        if (sEventRecordingPointer == NULL)
         {
             gUnknown_3005E88 = 0;
             return FALSE;
@@ -545,7 +543,7 @@ static bool8 TryRecordQuestLogEntrySequence(struct QuestLogEntry * entry)
 
     if (gUnknown_3005E88 == 0)
     {
-        gUnknown_203AE08 = sub_8113BF4(gUnknown_203AE08);
+        sEventRecordingPointer = TryRecordEvent39_NoParams(sEventRecordingPointer);
         return FALSE;
     }
     gUnknown_203ADFC = sQuestLogCursor;
@@ -968,7 +966,7 @@ bool8 QuestLog_SchedulePlaybackCB(void (*callback)(void))
     switch (gQuestLogState)
     {
         case 1:
-            sub_8112364();
+            QuestLog_OnInteractionWithSpecialNpc();
             break;
         case 2:
             gUnknown_3005E88 = 3;
@@ -1089,13 +1087,13 @@ void sub_8111C68(void)
 {
     if (gUnknown_203AE94.unk_0_6 == 0)
     {
-        if (gMain.newKeys & A_BUTTON)
+        if (JOY_NEW(A_BUTTON))
         {
             gUnknown_203AE94.unk_0_6 = 2;
             gUnknown_3005E88 = 0;
             sub_81118F4(-3);
         }
-        else if (gMain.newKeys & B_BUTTON)
+        else if (JOY_NEW(B_BUTTON))
         {
             gUnknown_203AE94.unk_0_6 = 1;
             gUnknown_3005E88 = 0;
@@ -1230,7 +1228,7 @@ static void sub_8111F8C(u8 taskId)
     {
         FreezeObjectEvents();
         sub_805C270();
-        sub_805C780();
+        StopPlayerAvatar();
         ScriptContext2_Enable();
         task->func = Task_QuestLogScene_SavedGame;
     }
@@ -1262,7 +1260,7 @@ static void Task_WaitAtEndOfQuestLog(u8 taskId)
 {
     struct Task *task = &gTasks[taskId];
 
-    if (gMain.newKeys & (A_BUTTON | B_BUTTON) || task->tTimer >= 127 || gUnknown_203AE94.unk_0_6 == 1)
+    if (JOY_NEW(A_BUTTON | B_BUTTON) || task->tTimer >= 127 || gUnknown_203AE94.unk_0_6 == 1)
     {
         QuestLog_CloseTextWindow();
         task->tTimer = 0;
@@ -1313,7 +1311,7 @@ static void Task_EndQuestLog(u8 taskId)
         break;
     default:
         if (gUnknown_203AE94.unk_0_6 == 1)
-            ShowMapNamePopup(1);
+            ShowMapNamePopup(TRUE);
         CpuCopy16(gUnknown_203AE90, gPlttBufferUnfaded, 0x400);
         Free(gUnknown_203AE90);
         gUnknown_203AE94 = (struct UnkStruct_203AE94){};
@@ -1366,31 +1364,31 @@ void sub_811231C(void)
     if (gQuestLogState == QL_STATE_1)
     {
         TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer);
-        sub_8110E3C();
+        TryRecordEvent39_GoToNextScene();
         gQuestLogState = 0;
         sQuestLogCB = NULL;
         gUnknown_203AE04 = NULL;
-        gUnknown_203AE08 = NULL;
+        sEventRecordingPointer = NULL;
         gUnknown_3005E88 = 0;
     }
 }
 
-void sub_8112364(void)
+void QuestLog_OnInteractionWithSpecialNpc(void)
 {
     if (gUnknown_3005E88 && gQuestLogState == QL_STATE_1)
     {
         TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer);
-        sub_8113A1C(1);
-        sub_8110E3C();
+        TryRecordEvent41_IncCursor(1);
+        TryRecordEvent39_GoToNextScene();
         gUnknown_3005E88 = 0;
         gQuestLogState = 0;
         sQuestLogCB = NULL;
     }
     gUnknown_203AE04 = NULL;
-    gUnknown_203AE08 = NULL;
+    sEventRecordingPointer = NULL;
 }
 
-void sub_81123BC(void)
+static void SortQuestLogInSav1(void)
 {
     struct QuestLog * buffer = AllocZeroed(QUEST_LOG_SCENE_COUNT * sizeof(struct QuestLog));
     u8 i;
@@ -1412,12 +1410,12 @@ void sub_81123BC(void)
     Free(buffer);
 }
 
-void sub_8112450(void)
+void SaveQuestLogData(void)
 {
     if (MenuHelpers_LinkSomething() != TRUE)
     {
-        sub_8112364();
-        sub_81123BC();
+        QuestLog_OnInteractionWithSpecialNpc();
+        SortQuestLogInSav1();
     }
 }
 
@@ -1616,7 +1614,7 @@ static void SetUpQuestLogEntry(u8 kind, struct QuestLogEntry *entry, u16 size)
         }
         sQuestLogCursor = 0;
         gUnknown_203B01C = 0;
-        gUnknown_3005E90 = (struct FieldInput){};
+        gQuestLogFieldInput = (struct FieldInput){};
         sNextStepDelay = sCurQuestLogEntry[sQuestLogCursor].unk_4;
         sMovementScripts[0][0] = sCurQuestLogEntry[sQuestLogCursor].unk_3;
         sMovementScripts[0][1] = 0xFF;
@@ -1688,7 +1686,8 @@ void sub_8112B3C(void)
                         sMovementScripts[sCurQuestLogEntry[sQuestLogCursor].unk_0][1] = sCurQuestLogEntry[sQuestLogCursor].unk_3;
                         break;
                     case 2:
-                        *(u32 *)&gUnknown_3005E90 = ((sCurQuestLogEntry[sQuestLogCursor].unk_3 << 24) | (sCurQuestLogEntry[sQuestLogCursor].unk_2 << 16) | (sCurQuestLogEntry[sQuestLogCursor].unk_1 << 8) | (sCurQuestLogEntry[sQuestLogCursor].unk_0 << 0));
+                        // Player input command
+                        *(u32 *)&gQuestLogFieldInput = ((sCurQuestLogEntry[sQuestLogCursor].unk_3 << 24) | (sCurQuestLogEntry[sQuestLogCursor].unk_2 << 16) | (sCurQuestLogEntry[sQuestLogCursor].unk_1 << 8) | (sCurQuestLogEntry[sQuestLogCursor].unk_0 << 0));
                         break;
                     case 3:
                         gUnknown_3005E88 = 3;
@@ -2443,7 +2442,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData)
     {
         if (gUnknown_203AE04 == NULL)
         {
-            gUnknown_203AE04 = gUnknown_203AE08;
+            gUnknown_203AE04 = sEventRecordingPointer;
             r1 = sQuestLogStorageCBs[eventId](gUnknown_203AE04, eventData);
         }
         else
@@ -2455,7 +2454,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData)
     else
     {
         gUnknown_203AE04 = NULL;
-        r1 = sQuestLogStorageCBs[eventId](gUnknown_203AE08, eventData);
+        r1 = sQuestLogStorageCBs[eventId](sEventRecordingPointer, eventData);
     }
 
     if (r1 == NULL)
@@ -2466,7 +2465,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData)
             return;
     }
 
-    gUnknown_203AE08 = r1;
+    sEventRecordingPointer = r1;
     if (gUnknown_203B048 == 0)
         return;
     sub_811231C();
@@ -2518,7 +2517,7 @@ bool8 sub_8113748(void)
         return TRUE;
 
     if (gQuestLogState == QL_STATE_1)
-        sub_8112364();
+        QuestLog_OnInteractionWithSpecialNpc();
 
     return FALSE;
 }
@@ -2584,11 +2583,11 @@ static u16 *sub_8113828(u16 eventId, const u16 *eventData)
     sub_8113B94(eventId);
 
     if (eventId == QL_EVENT_DEFEATED_WILD_MON)
-        gUnknown_203AE04 = gUnknown_203AE08;
+        gUnknown_203AE04 = sEventRecordingPointer;
     else
         gUnknown_203AE04 = NULL;
 
-    return sQuestLogStorageCBs[eventId](gUnknown_203AE08, eventData);
+    return sQuestLogStorageCBs[eventId](sEventRecordingPointer, eventData);
 }
 
 static bool8 TrySetLinkQuestLogEvent(u16 eventId, const u16 *eventData)
@@ -2614,15 +2613,15 @@ void sub_81138F8(void)
     gUnknown_203B024 = (struct UnkStruct_203B024){};
 }
 
-void sub_811390C(void)
+void QuestLog_StartRecordingInputsAfterDeferredEvent(void)
 {
     if (gUnknown_203B024.unk_00 != QL_EVENT_0)
     {
         u16 *resp;
         gUnknown_203B04A = 0;
         StartRecordingQuestLogEntry(gUnknown_203B024.unk_00);
-        resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](gUnknown_203AE08, gUnknown_203B024.unk_04);
-        gUnknown_203AE08 = resp;
+        resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](sEventRecordingPointer, gUnknown_203B024.unk_04);
+        sEventRecordingPointer = resp;
         sub_81138F8();
     }
 }
@@ -2655,17 +2654,17 @@ void sub_81139BC(void)
             StartRecordingQuestLogEntry(gUnknown_203B024.unk_00);
         }
         sub_8113B94(gUnknown_203B024.unk_00);
-        resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](gUnknown_203AE08, gUnknown_203B024.unk_04);
-        gUnknown_203AE08 = resp;
-        sub_8113A1C(1);
+        resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](sEventRecordingPointer, gUnknown_203B024.unk_04);
+        sEventRecordingPointer = resp;
+        TryRecordEvent41_IncCursor(1);
         sub_81138F8();
         sub_811231C();
     }
 }
 
-static void sub_8113A1C(u16 a0)
+static void TryRecordEvent41_IncCursor(u16 a0)
 {
-    gUnknown_203AE08 = sub_8113C5C(gUnknown_203AE08, a0);
+    sEventRecordingPointer = TryRecordEvent41(sEventRecordingPointer, a0);
     sQuestLogCursor++;
 }
 
@@ -2854,9 +2853,9 @@ static void sub_8113BD8(void)
     gUnknown_203B04B = FALSE;
 }
 
-static u16 *sub_8113BF4(u16 *a0)
+static u16 *TryRecordEvent39_NoParams(u16 *a0)
 {
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_39]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_39]))
         return NULL;
     a0[0] = QL_EVENT_39;
     return a0 + 1;
@@ -2864,7 +2863,7 @@ static u16 *sub_8113BF4(u16 *a0)
 
 static u16 *sub_8113C20(u16 *a0, struct QuestLogEntry * a1)
 {
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_39]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_39]))
         return NULL;
     a1->unk_6 = 0xFF;
     a1->unk_4 = 0;
@@ -2875,9 +2874,9 @@ static u16 *sub_8113C20(u16 *a0, struct QuestLogEntry * a1)
     return a0 + 1;
 }
 
-static u16 *sub_8113C5C(u16 *a0, u16 a1)
+static u16 *TryRecordEvent41(u16 *a0, u16 a1)
 {
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_41]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_41]))
         return NULL;
     a0[0] = QL_EVENT_41;
     a0[1] = a1;
@@ -2886,7 +2885,7 @@ static u16 *sub_8113C5C(u16 *a0, u16 a1)
 
 static u16 *sub_8113C8C(u16 *a0, struct QuestLogEntry * a1)
 {
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_41]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_41]))
         return NULL;
     a1->unk_6 = 0xFE;
     a1->unk_4 = a0[1];
@@ -2901,7 +2900,7 @@ static u16 *sub_8113CC8(u16 *a0, struct QuestLogEntry * a1)
 {
     u8 *r6 = (u8 *)a0 + 4;
 
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_0]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_0]))
         return NULL;
     a0[0] = 0;
     a0[1] = a1->unk_4;
@@ -2916,7 +2915,7 @@ static u16 *sub_8113D08(u16 *a0, struct QuestLogEntry * a1)
 {
     u8 *r6 = (u8 *)a0 + 4;
 
-    if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_0]))
+    if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_0]))
         return NULL;
     a1->unk_6 = 2;
     a1->unk_4 = a0[1];
@@ -2932,7 +2931,7 @@ static u16 *sub_8113D48(u16 *a0, struct QuestLogEntry * a1)
     u16 *r4 = a0;
     u8 *r6 = (u8 *)a0 + 4;
 
-    if (!sub_8110988(r4, sQuestLogEventCmdSizes[QL_EVENT_2]))
+    if (!WillCommandOfSizeFitInSav1Record(r4, sQuestLogEventCmdSizes[QL_EVENT_2]))
         return NULL;
     if (a1->unk_6 == 0)
         r4[0] = 2;
@@ -2951,7 +2950,7 @@ static u16 *sub_8113D94(u16 *a0, struct QuestLogEntry * a1)
     u16 *r5 = a0;
     u8 *r6 = (u8 *)a0 + 4;
 
-    if (!sub_8110988(r5, sQuestLogEventCmdSizes[QL_EVENT_2]))
+    if (!WillCommandOfSizeFitInSav1Record(r5, sQuestLogEventCmdSizes[QL_EVENT_2]))
         return NULL;
     if (r5[0] == 2)
         a1->unk_6 = 0;
diff --git a/src/quest_log_player.c b/src/quest_log_player.c
index 42233999e..8abf7fab5 100644
--- a/src/quest_log_player.c
+++ b/src/quest_log_player.c
@@ -68,7 +68,7 @@ static void sub_81504E8(void)
     sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(1));
     ObjectEventTurn(objectEvent, objectEvent->movementDirection);
     SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_MACH_BIKE);
-    sub_80BD620(0, 0);
+    InitPlayerAvatarBikeState(0, 0);
 }
 
 static void sub_8150530(void)
diff --git a/src/save_location.c b/src/save_location.c
index 561fd2ff2..1fef9e8cf 100644
--- a/src/save_location.c
+++ b/src/save_location.c
@@ -93,16 +93,16 @@ void TrySetMapSaveWarpStatus(void)
     sub_810B7CC();
 }
 
-void sub_810B810(void)
+void SetUnlockedPokedexFlags(void)
 {
     gSaveBlock2Ptr->field_A8 |= 0x1;
     gSaveBlock2Ptr->field_A8 |= 0x10;
     gSaveBlock2Ptr->field_A8 |= 0x20;
 }
 
-void sub_810B82C(void)
+void SetPostgameFlags(void)
 {
-    gSaveBlock2Ptr->specialSaveWarpFlags |= 0x80;
+    gSaveBlock2Ptr->specialSaveWarpFlags |= CHAMPION_SAVEWARP;
     gSaveBlock2Ptr->field_A8 |= 0x2;
     gSaveBlock2Ptr->field_A8 |= 0x4;
     gSaveBlock2Ptr->field_A8 |= 0x8;
diff --git a/src/script.c b/src/script.c
index 13c571bac..097f6d3f3 100644
--- a/src/script.c
+++ b/src/script.c
@@ -28,7 +28,7 @@ static struct ScriptContext sScriptContext1;
 static u32 sUnusedVariable2;
 static struct ScriptContext sScriptContext2;
 static bool8 sScriptContext2Enabled;
-static u8 gUnknown_3000F9D;
+static u8 sMsgBoxWalkawayDisabled;
 static u8 sMsgBoxIsCancelable;
 static u8 sQuestLogInput;
 static u8 sQuestLogInputIsDpad;
@@ -235,19 +235,19 @@ u8 GetRegisteredQuestLogInput(void)
     return sQuestLogInput;
 }
 
-void sub_80699BC(void)
+void DisableMsgBoxWalkaway(void)
 {
-    gUnknown_3000F9D = TRUE;
+    sMsgBoxWalkawayDisabled = TRUE;
 }
 
-void sub_80699C8(void)
+void EnableMsgBoxWalkaway(void)
 {
-    gUnknown_3000F9D = FALSE;
+    sMsgBoxWalkawayDisabled = FALSE;
 }
 
-bool8 sub_80699D4(void)
+bool8 IsMsgBoxWalkawayDisabled(void)
 {
-    return gUnknown_3000F9D;
+    return sMsgBoxWalkawayDisabled;
 }
 
 void SetWalkingIntoSignVars(void)
@@ -330,7 +330,7 @@ bool8 ScriptContext2_RunScript(void)
 void ScriptContext1_SetupScript(const u8 *ptr)
 {
     ClearMsgBoxCancelableState();
-    sub_80699C8();
+    EnableMsgBoxWalkaway();
     ClearQuestLogInputIsDpadFlag();
     InitScriptContext(&sScriptContext1, gScriptCmdTable, gScriptCmdTableEnd);
     SetupBytecodeScript(&sScriptContext1, ptr);
diff --git a/src/shop.c b/src/shop.c
index ddeaf6a68..b84007bed 100644
--- a/src/shop.c
+++ b/src/shop.c
@@ -120,7 +120,7 @@ static void CB2_InitBuyMenu(void);
 static bool8 InitShopData(void);
 static void BuyMenuInitBgs(void);
 static void BuyMenuDecompressBgGraphics(void);
-static void sub_809B10C(bool32 a0);
+static void RecolorItemDescriptionBox(bool32 a0);
 static void BuyMenuDrawGraphics(void);
 static bool8 BuyMenuBuildListMenuTemplate(void);
 static void PokeMartWriteNameAndIdAt(struct ListMenuItem *list, u16 index, u8* dst);
@@ -134,7 +134,7 @@ static void SetShopExitCallback(void);
 static void BuyMenuAddScrollIndicatorArrows(void);
 static void BuyQuantityAddScrollIndicatorArrows(void);
 static void BuyMenuRemoveScrollIndicatorArrows(void);
-static void sub_809B764(void);
+static void BuyMenuDrawMapView(void);
 static void BuyMenuDrawMapBg(void);
 static void BuyMenuDrawMapMetatile(s16 x, s16 y, const u16 *src, u8 metatileLayerType);
 static void BuyMenuDrawMapMetatileLayer(u16 *dest, s16 offset1, s16 offset2, const u16 *src);
@@ -152,8 +152,8 @@ static void Task_ReturnToItemListAfterItemPurchase(u8 taskId);
 static void BuyMenuReturnToItemList(u8 taskId);
 static void ExitBuyMenu(u8 taskId);
 static void Task_ExitBuyMenu(u8 taskId);
-static void nullsub_52(u8 taskId);
-static void nullsub_53(void);
+static void DebugFunc_PrintPurchaseDetails(u8 taskId);
+static void DebugFunc_PrintShopMenuHistoryBeforeClearMaybe(void);
 static void RecordQuestLogItemPurchase(void);
 
 static const struct MenuAction sShopMenuActions_BuySellQuit[] =
@@ -496,26 +496,26 @@ static void BuyMenuDecompressBgGraphics(void)
     Free(pal);
 }
 
-static void sub_809B10C(bool32 a0)
+static void RecolorItemDescriptionBox(bool32 a0)
 {
-    u8 v;
+    u8 paletteNum;
     
     if (a0 == FALSE)
-        v = 0xB;
+        paletteNum = 0xB;
     else 
-        v = 6;
+        paletteNum = 0x6;
     
     if ((gShopData.martType) != MART_TYPE_TMHM)
-        SetBgTilemapPalette(1, 0, 0xE, 0x1E, 6, v);
+        SetBgTilemapPalette(1, 0, 14, 30, 6, paletteNum);
     else
-        SetBgTilemapPalette(1, 0, 0xC, 0x1E, 8, v);
+        SetBgTilemapPalette(1, 0, 12, 30, 8, paletteNum);
     
     ScheduleBgCopyTilemapToVram(1);
 }
 
 static void BuyMenuDrawGraphics(void)
 {
-    sub_809B764();
+    BuyMenuDrawMapView();
     BuyMenuCopyTilemapData();
     BuyMenuDrawMoneyBox();
     ScheduleBgCopyTilemapToVram(0);
@@ -732,7 +732,7 @@ static void BuyMenuRemoveScrollIndicatorArrows(void)
     gShopData.unk16_11 = 0x1F;
 }
 
-static void sub_809B764(void)
+static void BuyMenuDrawMapView(void)
 {
     BuyMenuCollectObjectEventData();
     BuyMenuDrawObjectEvents();
@@ -913,7 +913,7 @@ static void Task_BuyMenu(u8 taskId)
             ClearWindowTilemap(5);
             BuyMenuRemoveScrollIndicatorArrows();
             BuyMenuPrintCursor(tListTaskId, 2);
-            sub_809B10C(1);
+            RecolorItemDescriptionBox(1);
             gShopData.itemPrice = itemid_get_market_price(itemId);
             if (!IsEnoughMoney(&gSaveBlock1Ptr->money, gShopData.itemPrice))
             {
@@ -1006,7 +1006,7 @@ static void BuyMenuTryMakePurchase(u8 taskId)
     if (AddBagItem(tItemId, tItemCount) == TRUE)
     {
         BuyMenuDisplayMessage(taskId, gText_HereYouGoThankYou, BuyMenuSubtractMoney);
-        nullsub_52(taskId);
+        DebugFunc_PrintPurchaseDetails(taskId);
         RecordItemPurchase(tItemId, tItemCount, 1);
     }
     else
@@ -1039,7 +1039,7 @@ static void BuyMenuReturnToItemList(u8 taskId)
 
     ClearDialogWindowAndFrameToTransparent(2, 0);
     BuyMenuPrintCursor(tListTaskId, 1);
-    sub_809B10C(0);
+    RecolorItemDescriptionBox(0);
     PutWindowTilemap(4);
     PutWindowTilemap(5);
     if (gShopData.martType == MART_TYPE_TMHM)
@@ -1070,11 +1070,11 @@ static void Task_ExitBuyMenu(u8 taskId)
     }
 }
 
-static void nullsub_52(u8 taskId)
+static void DebugFunc_PrintPurchaseDetails(u8 taskId)
 {
 }
 
-static void nullsub_53(void)
+static void DebugFunc_PrintShopMenuHistoryBeforeClearMaybe(void)
 {
 }
 
@@ -1138,7 +1138,7 @@ void CreatePokemartMenu(const u16 *itemsForSale)
     SetShopItemsForSale(itemsForSale);
     CreateShopMenu(MART_TYPE_REGULAR);
     SetShopMenuCallback(EnableBothScriptContexts);
-    nullsub_53();
+    DebugFunc_PrintShopMenuHistoryBeforeClearMaybe();
     memset(&gShopMenuHistory, 0, sizeof(gShopMenuHistory));
     gShopMenuHistory[0].unk8 = gMapHeader.regionMapSectionId;
     gShopMenuHistory[1].unk8 = gMapHeader.regionMapSectionId;
diff --git a/src/sprite.c b/src/sprite.c
index fd824494b..a71edce1c 100644
--- a/src/sprite.c
+++ b/src/sprite.c
@@ -1,7 +1,5 @@
 #include "global.h"
-#include "sprite.h"
-#include "main.h"
-#include "palette.h"
+#include "gflib.h"
 
 #define MAX_SPRITE_COPY_REQUESTS 64
 
diff --git a/src/start_menu.c b/src/start_menu.c
index 867e469e0..6fd69d9e0 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -1,7 +1,5 @@
 #include "global.h"
-#include "palette.h"
-#include "bg.h"
-#include "gpu_regs.h"
+#include "gflib.h"
 #include "scanline_effect.h"
 #include "overworld.h"
 #include "link.h"
@@ -17,7 +15,6 @@
 #include "menu.h"
 #include "load_save.h"
 #include "strings.h"
-#include "string_util.h"
 #include "menu_helpers.h"
 #include "text_window.h"
 #include "field_fadetransition.h"
@@ -26,7 +23,6 @@
 #include "event_object_movement.h"
 #include "event_object_lock.h"
 #include "script.h"
-#include "sound.h"
 #include "quest_log.h"
 #include "new_game.h"
 #include "event_scripts.h"
@@ -395,7 +391,7 @@ void ShowStartMenu(void)
     {
         FreezeObjectEvents();
         sub_805C270();
-        sub_805C780();
+        StopPlayerAvatar();
     }
     OpenStartMenuWithFollowupFunc(Task_StartMenuHandleInput);
     ScriptContext2_Enable();
@@ -779,7 +775,7 @@ static u8 SaveDialogCB_AskOverwriteOrReplacePreviousFileHandleInput(void)
 
 static u8 SaveDialogCB_PrintSavingDontTurnOffPower(void)
 {
-    sub_8112450();
+    SaveQuestLogData();
     PrintSaveTextWithFollowupFunc(gText_SavingDontTurnOffThePower, SaveDialogCB_DoSave);
     return SAVECB_RETURN_CONTINUE;
 }
diff --git a/src/strings.c b/src/strings.c
index fbe51254c..de428ddd9 100644
--- a/src/strings.c
+++ b/src/strings.c
@@ -1059,7 +1059,7 @@ ALIGNED(4) const u8 gText_Ghost[] = _("GHOST");
 const u8 gText_PokemonOnHook[] = _("A POKéMON's on the hook!{PAUSE_UNTIL_PRESS}");
 const u8 gText_NotEvenANibble[] = _("Not even a nibble‥{PAUSE_UNTIL_PRESS}");
 const u8 gText_ItGotAway[] = _("It got away‥{PAUSE_UNTIL_PRESS}");
-const u8 gUnknown_841D18D[] = _("ROOFTOP");
+const u8 gText_Rooftop2[] = _("ROOFTOP");
 ALIGNED(4) const u8 gString_PokemonFireRed_Staff[] = _("Pokémon FireRed Version\nStaff");
 ALIGNED(4) const u8 gString_PokemonLeafGreen_Staff[] = _("Pokémon LeafGreen Version\nStaff");
 ALIGNED(4) const u8 gCreditsString_Director[] = _("\n\nDirector\n\n\n\n");
diff --git a/src/title_screen.c b/src/title_screen.c
index e1bcf5dd2..14f7a8732 100644
--- a/src/title_screen.c
+++ b/src/title_screen.c
@@ -668,7 +668,7 @@ static void SetTitleScreenScene_Restart(s16 * data)
     case 4:
         HelpSystem_Disable();
         DestroyTask(FindTaskIdByFunc(Task_TitleScreenMain));
-        SetMainCallback2(sub_80EC864);
+        SetMainCallback2(CB2_CopyrightScreen);
         break;
     }
 }
diff --git a/src/tm_case.c b/src/tm_case.c
index 7bb471719..57eee6faf 100644
--- a/src/tm_case.c
+++ b/src/tm_case.c
@@ -304,7 +304,7 @@ static void CB2_SetUpTMCaseUI_Blocking(void)
 {
     while (1)
     {
-        if ((u8)sub_80BF72C() == TRUE)
+        if ((u8)MenuHelpers_CallLinkSomething() == TRUE)
             break;
         if (DoSetUpTMCaseUI() == TRUE)
             break;
@@ -733,7 +733,7 @@ static void Task_TMCaseMain(u8 taskId)
 
     if (!gPaletteFade.active)
     {
-        if ((u8)sub_80BF72C() != TRUE)
+        if ((u8)MenuHelpers_CallLinkSomething() != TRUE)
         {
             input = ListMenu_ProcessInput(data[0]);
             ListMenuGetScrollAndRow(data[0], &sTMCaseStaticResources.scrollOffset, &sTMCaseStaticResources.selectedRow);
@@ -814,7 +814,7 @@ static void Task_TMContextMenu_HandleInput(u8 taskId)
 {
     s8 input;
 
-    if ((u8)sub_80BF72C() != TRUE)
+    if ((u8)MenuHelpers_CallLinkSomething() != TRUE)
     {
         input = Menu_ProcessInputNoWrapAround();
         switch (input)
diff --git a/src/trainer_card.c b/src/trainer_card.c
index df116d379..01bd2c228 100644
--- a/src/trainer_card.c
+++ b/src/trainer_card.c
@@ -589,7 +589,7 @@ static void Task_TrainerCard(u8 taskId)
         }
         break;
     case STATE_WAIT_FLIP_TO_BACK:
-        if (IsCardFlipTaskActive() && sub_8058244() != TRUE)
+        if (IsCardFlipTaskActive() && Overworld_LinkRecvQueueLengthMoreThan2() != TRUE)
         {
             PlaySE(SE_CARD3);
             sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_BACK;
@@ -647,7 +647,7 @@ static void Task_TrainerCard(u8 taskId)
             CloseTrainerCard(taskId);
         break;
     case STATE_WAIT_FLIP_TO_FRONT:
-        if (IsCardFlipTaskActive() && sub_8058244() != TRUE)
+        if (IsCardFlipTaskActive() && Overworld_LinkRecvQueueLengthMoreThan2() != TRUE)
         {
             sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_FRONT;
             PlaySE(SE_CARD3);
@@ -1727,7 +1727,7 @@ static bool8 Task_AnimateCardFlipDown(struct Task* task)
 static bool8 Task_DrawFlippedCardSide(struct Task* task)
 {
     sTrainerCardDataPtr->allowDMACopy = FALSE;
-    if (sub_8058244() == TRUE)
+    if (Overworld_LinkRecvQueueLengthMoreThan2() == TRUE)
         return FALSE;
 
     do
diff --git a/src/vs_seeker.c b/src/vs_seeker.c
index 7054a13ed..849c599e8 100644
--- a/src/vs_seeker.c
+++ b/src/vs_seeker.c
@@ -80,7 +80,9 @@ extern u8 gSelectedObjectEvent;
 // static declarations
 static EWRAM_DATA struct VsSeekerStruct *sVsSeeker = NULL;
 
-static void sub_810C3B8(u8 taskId);
+static void VsSeekerResetInBagStepCounter(void);
+static void VsSeekerResetChargingStepCounter(void);
+static void Task_ResetObjectsRematchWantedState(u8 taskId);
 static void sub_810C594(void);
 static void Task_VsSeeker_1(u8 taskId);
 static void Task_VsSeeker_2(u8 taskId);
@@ -103,6 +105,7 @@ static u8 GetRematchableTrainerLocalId(void);
 static void StartTrainerObjectMovementScript(struct VsSeekerTrainerInfo *, const u8 *);
 static u8 GetCurVsSeekerResponse(s32, u16);
 static void StartAllRespondantIdleMovements(void);
+static u8 GetRandomFaceDirectionMovementType();
 
 // rodata
 static const VsSeekerData sVsSeekerData[] = {
@@ -581,16 +584,14 @@ static const u8 gUnknown_8453F67[] = {
     MOVEMENT_TYPE_FACE_RIGHT
 };
 
-
 // text
 
-
-void sub_810C3A4(void)
+void VsSeekerFreezeObjectsAfterChargeComplete(void)
 {
-    CreateTask(sub_810C3B8, 80);
+    CreateTask(Task_ResetObjectsRematchWantedState, 80);
 }
 
-static void sub_810C3B8(u8 taskId)
+static void Task_ResetObjectsRematchWantedState(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     u8 i;
@@ -618,36 +619,36 @@ static void sub_810C3B8(u8 taskId)
     if (task->data[0] != 0)
     {
         DestroyTask(taskId);
-        sub_805C780();
+        StopPlayerAvatar();
         EnableBothScriptContexts();
     }
 }
 
-void sub_810C444(void)
+void VsSeekerResetObjectMovementAfterChargeComplete(void)
 {
     struct ObjectEventTemplate * templates = gSaveBlock1Ptr->objectEventTemplates;
     u8 i;
-    u8 r6;
-    u8 sp0;
+    u8 movementType;
+    u8 objEventId;
     struct ObjectEvent * objectEvent;
 
     for (i = 0; i < gMapHeader.events->objectEventCount; i++)
     {
         if ((templates[i].trainerType == 1 || templates[i].trainerType == 3) && (templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN || templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP || templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT))
         {
-            r6 = sub_810CF54();
-            TryGetObjectEventIdByLocalIdAndMap(templates[i].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &sp0);
-            objectEvent = &gObjectEvents[sp0];
-            if (sub_810CF04(sp0) == TRUE)
+            movementType = GetRandomFaceDirectionMovementType();
+            TryGetObjectEventIdByLocalIdAndMap(templates[i].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &objEventId);
+            objectEvent = &gObjectEvents[objEventId];
+            if (sub_810CF04(objEventId) == TRUE)
             {
-                SetTrainerMovementType(objectEvent, r6);
+                SetTrainerMovementType(objectEvent, movementType);
             }
-            templates[i].movementType = r6;
+            templates[i].movementType = movementType;
         }
     }
 }
 
-bool8 sub_810C4EC(void)
+bool8 UpdateVsSeekerStepCounter(void)
 {
     if (CheckBagHasItem(ITEM_VS_SEEKER, 1) == TRUE)
     {
@@ -672,7 +673,7 @@ bool8 sub_810C4EC(void)
         if (x == 100)
         {
             FlagClear(FLAG_SYS_VS_SEEKER_CHARGING);
-            sub_810C640();
+            VsSeekerResetChargingStepCounter();
             sub_810D0D0();
             return TRUE;
         }
@@ -684,7 +685,7 @@ bool8 sub_810C4EC(void)
 void TryUpdateRandomTrainerRematches(u16 mapGroup, u16 mapNum)
 {
     FlagClear(FLAG_SYS_VS_SEEKER_CHARGING);
-    sub_810C640();
+    VsSeekerResetChargingStepCounter();
     sub_810D0D0();
     sub_810C594();
 }
@@ -698,34 +699,34 @@ static void sub_810C594(void)
         struct ObjectEvent * objectEvent = &gObjectEvents[i];
         if (objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN || objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP || objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT)
         {
-            u8 r3 = sub_810CF54();
+            u8 movementType = GetRandomFaceDirectionMovementType();
             if (objectEvent->active && gSprites[objectEvent->spriteId].data[0] == i)
             {
                 gSprites[objectEvent->spriteId].pos2.x = 0;
                 gSprites[objectEvent->spriteId].pos2.y = 0;
-                SetTrainerMovementType(objectEvent, r3);
+                SetTrainerMovementType(objectEvent, movementType);
             }
         }
     }
 }
 
-void sub_810C604(void)
+static void VsSeekerResetInBagStepCounter(void)
 {
     gSaveBlock1Ptr->trainerRematchStepCounter &= 0xFF00;
 }
 
-void sub_810C620(void)
+static void VsSeekerSetStepCounterInBagFull(void)
 {
     gSaveBlock1Ptr->trainerRematchStepCounter &= 0xFF00;
     gSaveBlock1Ptr->trainerRematchStepCounter |= 100;
 }
 
-void sub_810C640(void)
+static void VsSeekerResetChargingStepCounter(void)
 {
     gSaveBlock1Ptr->trainerRematchStepCounter &= 0x00FF;
 }
 
-void sub_810C654(void)
+static void VsSeekerSetStepCounterFullyCharged(void)
 {
     gSaveBlock1Ptr->trainerRematchStepCounter &= 0x00FF;
     gSaveBlock1Ptr->trainerRematchStepCounter |= (100 << 8);
@@ -785,7 +786,7 @@ static void Task_VsSeeker_2(u8 taskId)
     {
         data[1] = 0;
         data[2] = 0;
-        sub_810C604();
+        VsSeekerResetInBagStepCounter();
         sVsSeeker->responseCode = GetVsSeekerResponseInArea(sVsSeekerData);
         ScriptMovement_StartObjectMovementScript(0xFF, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gUnknown_8453F5C);
         gTasks[taskId].func = Task_VsSeeker_3;
@@ -934,7 +935,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
     {
         PlaySE(SE_PIN);
         FlagSet(FLAG_SYS_VS_SEEKER_CHARGING);
-        sub_810C640();
+        VsSeekerResetChargingStepCounter();
         return VSSEEKER_RESPONSE_FOUND_REMATCHES;
     }
     if (sVsSeeker->trainerHasNotYetBeenFought)
@@ -944,7 +945,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
 
 void sub_810CB90(void)
 {
-    u8 sp0 = 0;
+    u8 objEventId = 0;
     struct ObjectEventTemplate *r4 = gSaveBlock1Ptr->objectEventTemplates;
     s32 r9 = sub_810CE10(sVsSeekerData, gTrainerBattleOpponent_A);
 
@@ -958,12 +959,12 @@ void sub_810CB90(void)
             {
                 struct ObjectEvent *r4_2;
 
-                TryGetObjectEventIdByLocalIdAndMap(r4[r8].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &sp0);
-                r4_2 = &gObjectEvents[sp0];
-                sub_810CF54(&r4[r8]); // You are using this function incorrectly.  Please consult the manual.
+                TryGetObjectEventIdByLocalIdAndMap(r4[r8].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &objEventId);
+                r4_2 = &gObjectEvents[objEventId];
+                GetRandomFaceDirectionMovementType(&r4[r8]); // You are using this function incorrectly.  Please consult the manual.
                 OverrideMovementTypeForObjectEvent(r4_2, gUnknown_8453F67[r4_2->facingDirection]);
                 gSaveBlock1Ptr->trainerRematches[r4[r8].localId] = 0;
-                if (gSelectedObjectEvent == sp0)
+                if (gSelectedObjectEvent == objEventId)
                     r4_2->movementType = gUnknown_8453F67[r4_2->facingDirection];
                 else
                     r4_2->movementType = MOVEMENT_TYPE_FACE_DOWN;
@@ -1113,22 +1114,22 @@ bool8 sub_810CF04(u8 a0)
     return FALSE;
 }
 
-u8 sub_810CF54()
+static u8 GetRandomFaceDirectionMovementType()
 {
     u16 r1 = Random() % 4;
 
     switch (r1)
     {
         case 0:
-            return 7;
+            return MOVEMENT_TYPE_FACE_UP;
         case 1:
-            return 8;
+            return MOVEMENT_TYPE_FACE_DOWN;
         case 2:
-            return 9;
+            return MOVEMENT_TYPE_FACE_LEFT;
         case 3:
-            return 10;
+            return MOVEMENT_TYPE_FACE_RIGHT;
         default:
-            return 8;
+            return MOVEMENT_TYPE_FACE_DOWN;
     }
 }