Merge branch 'master' into weather-15

3 files changed, 2732 insertions, 349 deletions

diff --git a/src/battle_interface.c b/src/battle_interface.c
index 0eb494db4..4a6ac67f1 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -35,125 +35,126 @@ struct TestingBar
 };
 
 enum
-{
-    HEALTHBOX_GFX_0,
-    HEALTHBOX_GFX_1,
-    HEALTHBOX_GFX_2,
-    HEALTHBOX_GFX_HP_BAR_GREEN,
-    HEALTHBOX_GFX_4,
-    HEALTHBOX_GFX_5,
-    HEALTHBOX_GFX_6,
-    HEALTHBOX_GFX_7,
-    HEALTHBOX_GFX_8,
-    HEALTHBOX_GFX_9,
-    HEALTHBOX_GFX_10,
-    HEALTHBOX_GFX_11,
-    HEALTHBOX_GFX_12,
-    HEALTHBOX_GFX_13,
-    HEALTHBOX_GFX_14,
-    HEALTHBOX_GFX_15,
-    HEALTHBOX_GFX_16,
-    HEALTHBOX_GFX_17,
-    HEALTHBOX_GFX_18,
-    HEALTHBOX_GFX_19,
-    HEALTHBOX_GFX_20,
-    HEALTHBOX_GFX_STATUS_PSN_BATTLER0,
-    HEALTHBOX_GFX_22,
-    HEALTHBOX_GFX_23,
-    HEALTHBOX_GFX_STATUS_PRZ_BATTLER0,
+{   // Corresponds to gHealthboxElementsGfxTable (and the tables after it) in graphics.c
+    // These are indexes into the tables, which are filled with 8x8 square pixel data.
+    HEALTHBOX_GFX_0, //hp bar [black section]
+    HEALTHBOX_GFX_1, //hp bar "H"
+    HEALTHBOX_GFX_2, //hp bar "P"
+    HEALTHBOX_GFX_HP_BAR_GREEN, //hp bar [0 pixels]
+    HEALTHBOX_GFX_4,  //hp bar [1 pixels]
+    HEALTHBOX_GFX_5,  //hp bar [2 pixels]
+    HEALTHBOX_GFX_6,  //hp bar [3 pixels]
+    HEALTHBOX_GFX_7,  //hp bar [4 pixels]
+    HEALTHBOX_GFX_8,  //hp bar [5 pixels]
+    HEALTHBOX_GFX_9,  //hp bar [6 pixels]
+    HEALTHBOX_GFX_10, //hp bar [7 pixels]
+    HEALTHBOX_GFX_11, //hp bar [8 pixels]
+    HEALTHBOX_GFX_12, //exp bar [0 pixels]
+    HEALTHBOX_GFX_13, //exp bar [1 pixels]
+    HEALTHBOX_GFX_14, //exp bar [2 pixels]
+    HEALTHBOX_GFX_15, //exp bar [3 pixels]
+    HEALTHBOX_GFX_16, //exp bar [4 pixels]
+    HEALTHBOX_GFX_17, //exp bar [5 pixels]
+    HEALTHBOX_GFX_18, //exp bar [6 pixels]
+    HEALTHBOX_GFX_19, //exp bar [7 pixels]
+    HEALTHBOX_GFX_20, //exp bar [8 pixels]
+    HEALTHBOX_GFX_STATUS_PSN_BATTLER0,  //status psn "(P"
+    HEALTHBOX_GFX_22,                   //status psn "SN"
+    HEALTHBOX_GFX_23,                   //status psn "|)""
+    HEALTHBOX_GFX_STATUS_PRZ_BATTLER0,  //status prz
     HEALTHBOX_GFX_25,
     HEALTHBOX_GFX_26,
-    HEALTHBOX_GFX_STATUS_SLP_BATTLER0,
+    HEALTHBOX_GFX_STATUS_SLP_BATTLER0,  //status slp
     HEALTHBOX_GFX_28,
     HEALTHBOX_GFX_29,
-    HEALTHBOX_GFX_STATUS_FRZ_BATTLER0,
+    HEALTHBOX_GFX_STATUS_FRZ_BATTLER0,  //status frz
     HEALTHBOX_GFX_31,
     HEALTHBOX_GFX_32,
-    HEALTHBOX_GFX_STATUS_BRN_BATTLER0,
+    HEALTHBOX_GFX_STATUS_BRN_BATTLER0,  //status brn
     HEALTHBOX_GFX_34,
     HEALTHBOX_GFX_35,
-    HEALTHBOX_GFX_36,
-    HEALTHBOX_GFX_37,
-    HEALTHBOX_GFX_38,
-    HEALTHBOX_GFX_39,
-    HEALTHBOX_GFX_40,
-    HEALTHBOX_GFX_41,
-    HEALTHBOX_GFX_42,
-    HEALTHBOX_GFX_43,
-    HEALTHBOX_GFX_44,
-    HEALTHBOX_GFX_45,
-    HEALTHBOX_GFX_46,
-    HEALTHBOX_GFX_HP_BAR_YELLOW,
-    HEALTHBOX_GFX_48,
-    HEALTHBOX_GFX_49,
-    HEALTHBOX_GFX_50,
-    HEALTHBOX_GFX_51,
-    HEALTHBOX_GFX_52,
-    HEALTHBOX_GFX_53,
-    HEALTHBOX_GFX_54,
-    HEALTHBOX_GFX_55,
-    HEALTHBOX_GFX_HP_BAR_RED,
-    HEALTHBOX_GFX_57,
-    HEALTHBOX_GFX_58,
-    HEALTHBOX_GFX_59,
-    HEALTHBOX_GFX_60,
-    HEALTHBOX_GFX_61,
-    HEALTHBOX_GFX_62,
-    HEALTHBOX_GFX_63,
-    HEALTHBOX_GFX_64,
-    HEALTHBOX_GFX_65,
-    HEALTHBOX_GFX_66,
-    HEALTHBOX_GFX_67,
-    HEALTHBOX_GFX_68,
-    HEALTHBOX_GFX_69,
-    HEALTHBOX_GFX_70,
-    HEALTHBOX_GFX_STATUS_PSN_BATTLER1,
+    HEALTHBOX_GFX_36, //misc [Black section]
+    HEALTHBOX_GFX_37, //misc [Black section]
+    HEALTHBOX_GFX_38, //misc [Black section]
+    HEALTHBOX_GFX_39, //misc [Blank Health Window?]
+    HEALTHBOX_GFX_40, //misc [Blank Health Window?]
+    HEALTHBOX_GFX_41, //misc [Blank Health Window?]
+    HEALTHBOX_GFX_42, //misc [Blank Health Window?]
+    HEALTHBOX_GFX_43, //misc [Top of Health Window?]
+    HEALTHBOX_GFX_44, //misc [Top of Health Window?]
+    HEALTHBOX_GFX_45, //misc [Top of Health Window?]
+    HEALTHBOX_GFX_46, //misc [Blank Health Window?]
+    HEALTHBOX_GFX_HP_BAR_YELLOW, //hp bar yellow [0 pixels]
+    HEALTHBOX_GFX_48, //hp bar yellow [1 pixels]
+    HEALTHBOX_GFX_49, //hp bar yellow [2 pixels]
+    HEALTHBOX_GFX_50, //hp bar yellow [3 pixels]
+    HEALTHBOX_GFX_51, //hp bar yellow [4 pixels]
+    HEALTHBOX_GFX_52, //hp bar yellow [5 pixels]
+    HEALTHBOX_GFX_53, //hp bar yellow [6 pixels]
+    HEALTHBOX_GFX_54, //hp bar yellow [7 pixels]
+    HEALTHBOX_GFX_55, //hp bar yellow [8 pixels]
+    HEALTHBOX_GFX_HP_BAR_RED,  //hp bar red [0 pixels]
+    HEALTHBOX_GFX_57, //hp bar red [1 pixels]
+    HEALTHBOX_GFX_58, //hp bar red [2 pixels]
+    HEALTHBOX_GFX_59, //hp bar red [3 pixels]
+    HEALTHBOX_GFX_60, //hp bar red [4 pixels]
+    HEALTHBOX_GFX_61, //hp bar red [5 pixels]
+    HEALTHBOX_GFX_62, //hp bar red [6 pixels]
+    HEALTHBOX_GFX_63, //hp bar red [7 pixels]
+    HEALTHBOX_GFX_64, //hp bar red [8 pixels]
+    HEALTHBOX_GFX_65, //hp bar frame end
+    HEALTHBOX_GFX_66, //status ball [full]
+    HEALTHBOX_GFX_67, //status ball [empty]
+    HEALTHBOX_GFX_68, //status ball [fainted]
+    HEALTHBOX_GFX_69, //status ball [statused]
+    HEALTHBOX_GFX_70, //status ball [unused extra]
+    HEALTHBOX_GFX_STATUS_PSN_BATTLER1, //status2 "PSN"
     HEALTHBOX_GFX_72,
     HEALTHBOX_GFX_73,
-    HEALTHBOX_GFX_STATUS_PRZ_BATTLER1,
+    HEALTHBOX_GFX_STATUS_PRZ_BATTLER1, //status2 "PRZ"
     HEALTHBOX_GFX_75,
     HEALTHBOX_GFX_76,
-    HEALTHBOX_GFX_STATUS_SLP_BATTLER1,
+    HEALTHBOX_GFX_STATUS_SLP_BATTLER1, //status2 "SLP"
     HEALTHBOX_GFX_78,
     HEALTHBOX_GFX_79,
-    HEALTHBOX_GFX_STATUS_FRZ_BATTLER1,
+    HEALTHBOX_GFX_STATUS_FRZ_BATTLER1, //status2 "FRZ"
     HEALTHBOX_GFX_81,
     HEALTHBOX_GFX_82,
-    HEALTHBOX_GFX_STATUS_BRN_BATTLER1,
+    HEALTHBOX_GFX_STATUS_BRN_BATTLER1, //status2 "BRN"
     HEALTHBOX_GFX_84,
     HEALTHBOX_GFX_85,
-    HEALTHBOX_GFX_STATUS_PSN_BATTLER2,
+    HEALTHBOX_GFX_STATUS_PSN_BATTLER2, //status3 "PSN"
     HEALTHBOX_GFX_87,
     HEALTHBOX_GFX_88,
-    HEALTHBOX_GFX_STATUS_PRZ_BATTLER2,
+    HEALTHBOX_GFX_STATUS_PRZ_BATTLER2, //status3 "PRZ"
     HEALTHBOX_GFX_90,
     HEALTHBOX_GFX_91,
-    HEALTHBOX_GFX_STATUS_SLP_BATTLER2,
+    HEALTHBOX_GFX_STATUS_SLP_BATTLER2, //status3 "SLP"
     HEALTHBOX_GFX_93,
     HEALTHBOX_GFX_94,
-    HEALTHBOX_GFX_STATUS_FRZ_BATTLER2,
+    HEALTHBOX_GFX_STATUS_FRZ_BATTLER2, //status3 "FRZ"
     HEALTHBOX_GFX_96,
     HEALTHBOX_GFX_97,
-    HEALTHBOX_GFX_STATUS_BRN_BATTLER2,
+    HEALTHBOX_GFX_STATUS_BRN_BATTLER2, //status3 "BRN"
     HEALTHBOX_GFX_99,
     HEALTHBOX_GFX_100,
-    HEALTHBOX_GFX_STATUS_PSN_BATTLER3,
+    HEALTHBOX_GFX_STATUS_PSN_BATTLER3, //status4 "PSN"
     HEALTHBOX_GFX_102,
     HEALTHBOX_GFX_103,
-    HEALTHBOX_GFX_STATUS_PRZ_BATTLER3,
+    HEALTHBOX_GFX_STATUS_PRZ_BATTLER3, //status4 "PRZ"
     HEALTHBOX_GFX_105,
     HEALTHBOX_GFX_106,
-    HEALTHBOX_GFX_STATUS_SLP_BATTLER3,
+    HEALTHBOX_GFX_STATUS_SLP_BATTLER3, //status4 "SLP"
     HEALTHBOX_GFX_108,
     HEALTHBOX_GFX_109,
-    HEALTHBOX_GFX_STATUS_FRZ_BATTLER3,
+    HEALTHBOX_GFX_STATUS_FRZ_BATTLER3, //status4 "FRZ"
     HEALTHBOX_GFX_111,
     HEALTHBOX_GFX_112,
-    HEALTHBOX_GFX_STATUS_BRN_BATTLER3,
+    HEALTHBOX_GFX_STATUS_BRN_BATTLER3, //status4 "BRN"
     HEALTHBOX_GFX_114,
     HEALTHBOX_GFX_115,
-    HEALTHBOX_GFX_116,
-    HEALTHBOX_GFX_117,
+    HEALTHBOX_GFX_116, //unknown_D12FEC
+    HEALTHBOX_GFX_117, //unknown_D1300C
 };
 
 extern const u8 *const gNatureNamePointers[];
diff --git a/src/easy_chat.c b/src/easy_chat.c
index 5f5d20e16..1b1bd105b 100644
--- a/src/easy_chat.c
+++ b/src/easy_chat.c
@@ -2,11 +2,16 @@
 // Includes
 #include "global.h"
 #include "alloc.h"
+#include "bg.h"
+#include "decompress.h"
 #include "dewford_trend.h"
 #include "dynamic_placeholder_text_util.h"
 #include "easy_chat.h"
 #include "event_data.h"
+#include "event_object_movement.h"
 #include "field_weather.h"
+#include "gpu_regs.h"
+#include "graphics.h"
 #include "international_string_util.h"
 #include "link.h"
 #include "main.h"
@@ -17,7 +22,9 @@
 #include "string_util.h"
 #include "strings.h"
 #include "task.h"
+#include "text_window.h"
 #include "window.h"
+#include "constants/event_objects.h"
 #include "constants/flags.h"
 #include "constants/songs.h"
 
@@ -70,8 +77,46 @@ struct EasyChatScreen
     /*0x3C*/ u16 ecWordBuffer[9];
 };
 
+struct Unk203A11C
+{
+    u16 unk0;
+    u16 windowId;
+    u16 unk4;
+    u8 unk6;
+    u8 unk7;
+    s8 unk8;
+    u8 unk9;
+    u8 unkA;
+    u8 unkB[0xC1];
+    u8 unkCC[0x202];
+    u16 unk2CE;
+    int unk2D0;
+    int unk2D4;
+    struct Sprite *unk2D8;
+    struct Sprite *unk2DC;
+    struct Sprite *unk2E0;
+    struct Sprite *unk2E4;
+    struct Sprite *unk2E8;
+    struct Sprite *unk2EC;
+    struct Sprite *unk2F0;
+    struct Sprite *unk2F4;
+    struct Sprite *unk2F8;
+    struct Sprite *unk2FC;
+    u16 unk300[BG_SCREEN_SIZE / 2];
+    u16 unkB00[BG_SCREEN_SIZE / 2];
+};
+
+struct Unk08597C30
+{
+    u8 unk0_0:5;
+    u8 unk0_5:3;
+    u8 unk1;
+    u8 unk2;
+    u8 unk3;
+};
+
 EWRAM_DATA struct EasyChatScreen *gEasyChatScreen = NULL;
-EWRAM_DATA void *gUnknown_0203A11C = 0;
+EWRAM_DATA struct Unk203A11C *gUnknown_0203A11C = 0;
 EWRAM_DATA void *gUnknown_0203A120 = 0;
 
 static void sub_811A2C0(u8);
@@ -103,10 +148,10 @@ static u8 sub_811BCC8(u8);
 static void sub_811BDF0(u8 *);
 void sub_811BF78(void);
 static bool8 sub_811BF8C(void);
-bool8 sub_811BFA4(void);
-void sub_811C13C(void);
-/*static*/ void sub_811C158(u16);
-/*static*/ bool8 sub_811C170(void);
+static bool8 sub_811BFA4(void);
+static void sub_811C13C(void);
+static void sub_811C158(u16);
+static bool8 sub_811C170(void);
 bool8 sub_811F28C(void);
 void sub_811F2B8(void);
 u8 sub_811F3AC(void);
@@ -152,7 +197,102 @@ static void sub_811B9A0(void);
 static u8 sub_811BA1C(void);
 static int sub_811BF20(void);
 static u16 sub_811BF40(void);
-u8 sub_811CE94(void);
+static bool8 sub_811CE94(void);
+static void sub_811CF64(void);
+static void sub_811CF04(void);
+static void sub_811D60C(void);
+static void sub_811D424(u16 *);
+static void sub_811D230(void);
+void sub_811E948(void);
+static void sub_811CFCC(void);
+static void sub_811D0BC(void);
+static void sub_811D2C8(void);
+static void sub_811D684(void);
+static void sub_811DE90(void);
+static void sub_811DEC4(void);
+static void sub_811DE5C(u8, u8, u8, u8);
+static void sub_811E5D4(void);
+static void sub_811E720(void);
+static void sub_811E828(void);
+static bool8 sub_811C2D4(void);
+static bool8 sub_811C30C(void);
+static bool8 sub_811C3E4(void);
+static bool8 sub_811C48C(void);
+static bool8 sub_811C404(void);
+static bool8 sub_811C448(void);
+static bool8 sub_811C4D0(void);
+static bool8 sub_811C518(void);
+static bool8 sub_811C554(void);
+static bool8 sub_811C620(void);
+static bool8 sub_811C830(void);
+static bool8 sub_811C8F0(void);
+static bool8 sub_811C99C(void);
+static bool8 sub_811CA5C(void);
+static bool8 sub_811C780(void);
+static bool8 sub_811C78C(void);
+static bool8 sub_811C7D4(void);
+static bool8 sub_811CB18(void);
+static bool8 sub_811CB98(void);
+static bool8 sub_811CB24(void);
+static bool8 sub_811CC90(void);
+static bool8 sub_811CC08(void);
+static bool8 sub_811C6C0(void);
+static bool8 sub_811CD14(void);
+static bool8 sub_811CD54(void);
+static bool8 sub_811CD94(void);
+static bool8 sub_811CDD4(void);
+static bool8 sub_811CE14(void);
+static bool8 sub_811CE54(void);
+static void sub_811DF60(u8, u8);
+static int sub_811E920(int);
+static void sub_811DF90(void);
+static void sub_811D104(u8);
+static void sub_811D214(u8);
+static void sub_811DFB0(void);
+static void sub_811D6D4(void);
+static void sub_811D9CC(int);
+static void sub_811E3AC(void);
+static bool8 sub_811E418(void);
+static void sub_811DFC8(void);
+static void sub_811E6E0(int);
+static bool8 sub_811DAA4(void);
+static void sub_811E64C(void);
+static void sub_811E050(void);
+static void sub_811E4AC(void);
+static void sub_811E6B0(void);
+static void sub_811E55C(void);
+static bool8 sub_811E4D0(void);
+static bool8 sub_811E5B8(void);
+static void sub_811E578(void);
+static void sub_811E088(void);
+static void sub_811DDAC(s16, u8);
+static bool8 sub_811DE10(void);
+static void sub_811D9B4(void);
+static void sub_811D698(u32);
+static void sub_811E288(void);
+static void sub_811E794(void);
+static void sub_811E380(void);
+static void sub_811E7F8(void);
+static void sub_811E30C(void);
+static void sub_811D7A4(void);
+static void sub_811D7C8(void);
+static int sub_811DE48(void);
+static void sub_811D7EC(void);
+static void sub_811D830(void);
+void sub_811D058(u8, u8, const u8 *, u8, u8, u8, u8, u8, u8);
+static void sub_811DD84(void);
+static void sub_811D6F4(void);
+static void sub_811D758(void);
+static void sub_811D794(void);
+const u8 *sub_811F424(u8);
+static void sub_811D864(u8, u8);
+static void sub_811D950(u8, u8);
+static void sub_811DADC(u8);
+static void sub_811DC28(int, int, int, int);
+static void sub_811E0EC(s8, s8);
+static void sub_811E1A4(s8, s8);
+static void sub_811E2DC(struct Sprite *);
+static void sub_811E34C(u8, u8);
 u8 *CopyEasyChatWordPadded(u8 *, u16, u16);
 
 extern const struct {
@@ -164,6 +304,28 @@ extern const struct EasyChatScreenTemplate gEasyChatScreenTemplates[21];
 extern const u8 gUnknown_08597748[][7];
 extern const u16 gUnknown_08597764[];
 extern const u16 gUnknown_0859776C[][2];
+extern const struct BgTemplate gUnknown_08597C54[4];
+extern const struct WindowTemplate gUnknown_08597C64[];
+extern const u32 gUnknown_08597B54[];
+extern const struct Unk08597C30 gUnknown_08597C30[];
+extern const u16 gUnknown_08597B14[];
+extern const u16 gUnknown_08597B34[];
+extern const u16 gUnknown_08597C1C[];
+extern const u16 gUnknown_08597C24[];
+extern const struct WindowTemplate gUnknown_08597C84;
+extern const u8 gUnknown_08597C8C[4];
+extern const u8 *const gUnknown_08597C90[4];
+extern const struct SpriteSheet gUnknown_08597CA0[];
+extern const struct SpritePalette gUnknown_08597CC0[];
+extern const struct CompressedSpriteSheet gUnknown_08597CE8[];
+extern const struct SpriteTemplate gUnknown_08597D18;
+extern const struct SpriteTemplate gUnknown_08597D68;
+extern const struct SpriteTemplate gUnknown_08597DF0;
+extern const struct SpriteTemplate gUnknown_08597DD0;
+extern const struct SpriteTemplate gUnknown_08597E48;
+extern const struct SpriteTemplate gUnknown_08597E30;
+extern const u8 gUnknown_08597D08[];
+extern const u8 gUnknown_08597E60[][4];
 
 void sub_811A20C(u8 kind, u16 *words, MainCallback callback, u8 sizeParam)
 {
@@ -1916,19 +2078,19 @@ u8 sub_811BAC4(void)
     return gEasyChatScreen->mainCursorRow;
 }
 
-void sub_811BAD0(const u8 **str1, const u8 **str2)
+static void GetEasyChatInstructionsText(const u8 **str1, const u8 **str2)
 {
     *str1 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].instructionsText1;
     *str2 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].instructionsText2;
 }
 
-void sub_811BB08(const u8 **str1, const u8 **str2)
+static void GetEasyChatConfirmText(const u8 **str1, const u8 **str2)
 {
     *str1 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].confirmText1;
     *str2 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].confirmText2;
 }
 
-void sub_811BB40(const u8 **str1, const u8 **str2)
+static void sub_811BB40(const u8 **str1, const u8 **str2)
 {
     switch (gEasyChatScreen->kind)
     {
@@ -1949,7 +2111,7 @@ void sub_811BB40(const u8 **str1, const u8 **str2)
 
 }
 
-void sub_811BB88(const u8 **str1, const u8 **str2)
+static void GetEasyChatConfirmDeletionText(const u8 **str1, const u8 **str2)
 {
     *str1 = gText_AllTextBeingEditedWill;
     *str2 = gText_BeDeletedThatOkay;
@@ -2026,7 +2188,7 @@ int sub_811BC2C(void)
     return 0;
 }
 
-int sub_811BC70(void)
+static int sub_811BC70(void)
 {
     return sub_811BA3C();
 }
@@ -2213,3 +2375,2001 @@ static bool8 sub_811BF8C(void)
     else
         return 1;
 }
+
+static bool8 sub_811BFA4(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, gUnknown_08597C54, ARRAY_COUNT(gUnknown_08597C54));
+        SetBgTilemapBuffer(3, gUnknown_0203A11C->unkB00);
+        SetBgTilemapBuffer(1, gUnknown_0203A11C->unk300);
+        InitWindows(gUnknown_08597C64);
+        DeactivateAllTextPrinters();
+        sub_811CF64();
+        sub_811CF04();
+        CpuFastFill(0, (void *)VRAM + 0x1000000, 0x400);
+        break;
+    case 1:
+        DecompressAndLoadBgGfxUsingHeap(3, gEasyChatWindow_Gfx, 0, 0, 0);
+        CopyToBgTilemapBuffer(3, gEasyChatWindow_Tilemap, 0, 0);
+        sub_811D60C();
+        sub_811D424(gUnknown_0203A11C->unk300);
+        sub_811D230();
+        sub_811E948();
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 2:
+        DecompressAndLoadBgGfxUsingHeap(1, gUnknown_08597B54, 0, 0, 0);
+        CopyBgTilemapBufferToVram(1);
+        break;
+    case 3:
+        sub_811CFCC();
+        sub_811D0BC();
+        sub_811D2C8();
+        sub_811D684();
+        break;
+    case 4:
+        sub_811DE90();
+        if (sub_811BA5C() != 16)
+            sub_811DEC4();
+        break;
+    case 5:
+        if (IsDma3ManagerBusyWithBgCopy())
+        {
+            return TRUE;
+        }
+        else
+        {
+            sub_811DE5C(0, 0, 0, 0);
+            SetGpuReg(REG_OFFSET_WININ, WIN_RANGE(0, 63));
+            SetGpuReg(REG_OFFSET_WINOUT, WIN_RANGE(0, 59));
+            ShowBg(3);
+            ShowBg(1);
+            ShowBg(2);
+            ShowBg(0);
+            sub_811E5D4();
+            sub_811E720();
+            sub_811E828();
+        }
+        break;
+    default:
+        return FALSE;
+    }
+
+    gUnknown_0203A11C->unk0++;
+    return TRUE;
+}
+
+static void sub_811C13C(void)
+{
+    if (gUnknown_0203A11C)
+        FREE_AND_SET_NULL(gUnknown_0203A11C);
+}
+
+static void sub_811C158(u16 arg0)
+{
+    gUnknown_0203A11C->unk4 = arg0;
+    gUnknown_0203A11C->unk0 = 0;
+    sub_811C170();
+}
+
+static bool8 sub_811C170(void)
+{
+    switch (gUnknown_0203A11C->unk4)
+    {
+    case 0:  return FALSE;
+    case 1:  return sub_811C2D4();
+    case 2:  return sub_811C30C();
+    case 3:  return sub_811C3E4();
+    case 4:  return sub_811C48C();
+    case 5:  return sub_811C404();
+    case 6:  return sub_811C448();
+    case 7:  return sub_811C4D0();
+    case 8:  return sub_811C518();
+    case 9:  return sub_811C554();
+    case 10: return sub_811C620();
+    case 11: return sub_811C830();
+    case 12: return sub_811C8F0();
+    case 13: return sub_811C99C();
+    case 14: return sub_811CA5C();
+    case 15: return sub_811C780();
+    case 16: return sub_811C78C();
+    case 17: return sub_811C7D4();
+    case 18: return sub_811CB18();
+    case 19: return sub_811CB98();
+    case 20: return sub_811CB24();
+    case 21: return sub_811CC90();
+    case 22: return sub_811CC08();
+    case 23: return sub_811C6C0();
+    case 24: return FALSE;
+    case 25: return FALSE;
+    case 26: return FALSE;
+    case 27: return FALSE;
+    case 28: return FALSE;
+    case 29: return sub_811CD14();
+    case 30: return sub_811CD54();
+    case 31: return sub_811CD94();
+    case 32: return sub_811CDD4();
+    case 33: return sub_811CE14();
+    case 34: return sub_811CE54();
+    default: return FALSE;
+    }
+}
+
+static bool8 sub_811C2D4(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D2C8();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C30C(void)
+{
+    u8 i;
+    u16 *ecWordBuffer;
+    u16 *ecWord;
+    u8 var0;
+    u8 cursorColumn, cursorRow, numColumns;
+    s16 var1;
+    int stringWidth;
+    int trueStringWidth;
+    u8 var2;
+    u8 sp0[64];
+    
+    ecWordBuffer = sub_811BA94();
+    var0 = sub_811BA68();
+    cursorColumn = sub_811BAB8();
+    cursorRow = sub_811BAC4();
+    numColumns = sub_811BAAC();
+    ecWord = &ecWordBuffer[cursorRow * numColumns];
+    var1 = 8 * gUnknown_08597C30[var0].unk0_0 + 13;
+    for (i = 0; i < cursorColumn; i++)
+    {
+        if (*ecWord == 0xFFFF)
+        {
+            stringWidth = 72;
+        }
+        else
+        {
+            CopyEasyChatWord(sp0, *ecWord);
+            stringWidth = GetStringWidth(1, sp0, 0);
+        }
+
+        trueStringWidth = stringWidth + 17;
+        var1 += trueStringWidth;
+        ecWord++;
+    }
+
+    var2 = 8 * (gUnknown_08597C30[var0].unk0_5 + cursorRow * 2);
+    sub_811DF60(var1, var2 + 8);
+    return FALSE;
+}
+
+static bool8 sub_811C3E4(void)
+{
+    u8 var0 = sub_811E920(sub_811BAB8());
+    sub_811DF60(var0, 96);
+    return FALSE;
+}
+
+static bool8 sub_811C404(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(2);
+        sub_811D214(1);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C448(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(3);
+        sub_811D214(0);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C48C(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(1);
+        sub_811D214(1);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C4D0(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DFB0();
+        sub_811D104(0);
+        sub_811D2C8();
+        ShowBg(0);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C518(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DFB0();
+        sub_811D104(0);
+        sub_811D2C8();
+        gUnknown_0203A11C->unk0++;
+        // Fall through
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C554(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        HideBg(0);
+        sub_811DE5C(0, 0, 0, 0);
+        sub_811D6D4();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(0);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy() && !sub_811DAA4())
+            gUnknown_0203A11C->unk0++;
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811E3AC();
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        if (!sub_811E418())
+        {
+            sub_811DFC8();
+            sub_811E6E0(0);
+            sub_811E64C();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    default:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C620(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811E050();
+        sub_811E4AC();
+        sub_811E6B0();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (sub_811E4D0() == TRUE)
+            break;
+
+        sub_811D9CC(1);
+        gUnknown_0203A11C->unk0++;
+        // Fall through
+    case 2:
+        if (!sub_811DAA4())
+            gUnknown_0203A11C->unk0++;
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811DFB0();
+            ShowBg(0);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C6C0(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811E050();
+        sub_811E6B0();
+        sub_811E55C();
+        sub_811D9CC(5);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!sub_811DAA4() && !sub_811E5B8())
+        {
+            sub_811D6D4();
+            gUnknown_0203A11C->unk0++;   
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(6);
+            sub_811E578();
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 3:
+        if (!sub_811DAA4() && !sub_811E5B8())
+        {
+            sub_811E64C();
+            sub_811DFC8();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 4:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C780(void)
+{
+    sub_811E088();
+    return FALSE;
+}
+
+static bool8 sub_811C78C(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DDAC(1, 4);
+        gUnknown_0203A11C->unk0++;
+        // Fall through
+    case 1:
+        if (!sub_811DE10())
+        {
+            sub_811E088();
+            sub_811E64C();
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C7D4(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DDAC(-1, 4);
+        gUnknown_0203A11C->unk0++;
+        // Fall through
+    case 1:
+        if (!sub_811DE10())
+        {
+            sub_811E64C();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 2:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C830(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811E050();
+        sub_811E4AC();
+        sub_811E6B0();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!sub_811E4D0())
+        {
+            sub_811D9B4();
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(2);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 3:
+        if (!sub_811DAA4())
+        {
+            sub_811D698(2);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811E288();
+            sub_811E6E0(1);
+            sub_811E64C();
+            sub_811E794();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 5:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C8F0(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D2C8();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        sub_811E380();
+        sub_811E6B0();
+        sub_811E7F8();
+        sub_811D9B4();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(3);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 3:
+        if (!sub_811DAA4())
+        {
+            ShowBg(0);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811DFB0();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 5:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811C99C(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D2C8();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        sub_811E380();
+        sub_811E6B0();
+        sub_811E7F8();
+        sub_811D9B4();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(3);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 3:
+        if (!sub_811DAA4())
+        {
+            sub_811D104(3);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ShowBg(0);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 5:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811DFB0();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 6:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CA5C(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811E380();
+        sub_811E6B0();
+        sub_811E7F8();
+        sub_811D9B4();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811D9CC(4);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!sub_811DAA4())
+        {
+            sub_811D6D4();
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811E3AC();
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 4:
+        if (!sub_811E418())
+        {
+            sub_811DFC8();
+            sub_811E6E0(0);
+            sub_811E64C();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CB18(void)
+{
+    sub_811E30C();
+    return FALSE;
+}
+
+static bool8 sub_811CB24(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D7A4();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811DDAC(1, 4);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!sub_811DE10())
+        {
+            sub_811E30C();
+            sub_811E64C();
+            sub_811E794();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CB98(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D7C8();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_811DDAC(-1, 4);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!sub_811DE10())
+        {
+            sub_811E64C();
+            sub_811E794();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CC08(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D7EC();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            s16 var0 = sub_811BBDC() - sub_811DE48();
+            sub_811DDAC(var0, 8);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!sub_811DE10())
+        {
+            sub_811E30C();
+            sub_811E64C();
+            sub_811E794();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CC90(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811D830();
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            s16 var0 = sub_811BBDC() - sub_811DE48();
+            sub_811DDAC(var0, 8);
+            gUnknown_0203A11C->unk0++;
+        }
+        break;
+    case 2:
+        if (!sub_811DE10())
+        {
+            sub_811E64C();
+            sub_811E794();
+            gUnknown_0203A11C->unk0++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CD14(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(4);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CD54(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(5);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CD94(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(6);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CDD4(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(7);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CE14(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(8);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CE54(void)
+{
+    switch (gUnknown_0203A11C->unk0)
+    {
+    case 0:
+        sub_811DF90();
+        sub_811D104(9);
+        gUnknown_0203A11C->unk0++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 sub_811CE94(void)
+{
+    gUnknown_0203A11C = Alloc(sizeof(*gUnknown_0203A11C));
+    if (!gUnknown_0203A11C)
+        return FALSE;
+
+    gUnknown_0203A11C->unk0 = 0;
+    gUnknown_0203A11C->unk2D8 = NULL;
+    gUnknown_0203A11C->unk2DC = NULL;
+    gUnknown_0203A11C->unk2E0 = NULL;
+    gUnknown_0203A11C->unk2E4 = NULL;
+    gUnknown_0203A11C->unk2E8 = NULL;
+    gUnknown_0203A11C->unk2EC = NULL;
+    gUnknown_0203A11C->unk2F0 = NULL;
+    gUnknown_0203A11C->unk2F4 = NULL;
+    gUnknown_0203A11C->unk2F8 = NULL;
+    gUnknown_0203A11C->unk2FC = NULL;
+    gUnknown_0203A11C->unkA = sub_811BC70();
+    return TRUE;
+}
+
+static void sub_811CF04(void)
+{
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON);
+}
+
+static void sub_811CF64(void)
+{
+    ResetPaletteFade();
+    LoadPalette(gEasyChatMode_Pal, 0, 32);
+    LoadPalette(gUnknown_08597B14, 1 * 16, 32);
+    LoadPalette(gUnknown_08597B34, 4 * 16, 32);
+    LoadPalette(gUnknown_08597C1C, 10 * 16, 8);
+    LoadPalette(gUnknown_08597C24, 11 * 16, 12);
+    LoadPalette(gUnknown_08597C24, 15 * 16, 12);
+    LoadPalette(gUnknown_08597C24, 3 * 16, 12);
+}
+
+static void sub_811CFCC(void)
+{
+    int xOffset;
+    const u8 *titleText = sub_811BA88();
+    if (!titleText)
+        return;
+
+    xOffset = GetStringCenterAlignXOffset(1, titleText, 144);
+    FillWindowPixelBuffer(0, 0);
+    sub_811D058(0, 1, titleText, xOffset, 1, 0xFF, 0, 2, 3);
+    PutWindowTilemap(0);
+    CopyWindowToVram(0, 3);
+}
+
+void sub_811D028(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16))
+{
+    AddTextPrinterParameterized(windowId, fontId, str, x, y, speed, callback);
+}
+
+void sub_811D058(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 speed, u8 red, u8 green, u8 blue)
+{
+    u8 color[3];
+    color[0] = red;
+    color[1] = green;
+    color[2] = blue;
+    AddTextPrinterParameterized3(windowId, fontId, left, top, color, speed, str);
+}
+
+static void sub_811D0BC(void)
+{
+    FillBgTilemapBufferRect(0, 0, 0, 0, 32, 20, 17);
+    LoadUserWindowBorderGfx(1, 1, 0xE0);
+    sub_8098858(1, 1, 14);
+    sub_811D104(0);
+    PutWindowTilemap(1);
+    CopyBgTilemapBufferToVram(0);
+}
+
+static void sub_811D104(u8 arg0)
+{
+    const u8 *text2 = NULL;
+    const u8 *text1 = NULL;
+    switch (arg0)
+    {
+    case 0:
+        GetEasyChatInstructionsText(&text1, &text2);
+        break;
+    case 2:
+        sub_811BB40(&text1, &text2);
+        break;
+    case 3:
+        GetEasyChatConfirmText(&text1, &text2);
+        break;
+    case 1:
+        GetEasyChatConfirmDeletionText(&text1, &text2);
+        break;
+    case 4:
+        text1 = gText_CreateAQuiz;
+        break;
+    case 5:
+        text1 = gText_SelectTheAnswer;
+        break;
+    case 6:
+        text1 = gText_OnlyOnePhrase;
+        text2 = gText_OriginalSongWillBeUsed;
+        break;
+    case 7:
+        text1 = gText_LyricsCantBeDeleted;
+        break;
+    case 8:
+        text1 = gText_CombineTwoWordsOrPhrases3;
+        break;
+    case 9:
+        text1 = gText_YouCannotQuitHere;
+        text2 = gText_SectionMustBeCompleted;
+        break;
+    }
+
+    FillWindowPixelBuffer(1, 0x11);
+    if (text1)
+        sub_811D028(1, 1, text1, 0, 1, 0xFF, 0);
+
+    if (text2)
+        sub_811D028(1, 1, text2, 0, 17, 0xFF, 0);
+
+    CopyWindowToVram(1, 3);
+}
+
+static void sub_811D214(u8 initialCursorPos)
+{
+    CreateYesNoMenu(&gUnknown_08597C84, 1, 14, initialCursorPos);
+}
+
+static void sub_811D230(void)
+{
+    u8 var0;
+    struct WindowTemplate template;
+
+    var0 = sub_811BA68();
+    template.bg = 3;
+    template.tilemapLeft = gUnknown_08597C30[var0].unk0_0;
+    template.tilemapTop = gUnknown_08597C30[var0].unk0_5;
+    template.width = gUnknown_08597C30[var0].unk1;
+    template.height = gUnknown_08597C30[var0].unk2;
+    template.paletteNum = 11;
+    template.baseBlock = 0x6C;
+    gUnknown_0203A11C->windowId = AddWindow(&template);
+    PutWindowTilemap(gUnknown_0203A11C->windowId);
+}
+
+static void sub_811D2C8(void)
+{
+    u8 spC[4];
+    u16 *ecWord;
+    u8 numColumns, numRows;
+    u8 *str;
+    int var0;
+    int var1;
+    int i, j, k;
+
+    ecWord = sub_811BA94();
+    numColumns = sub_811BAAC();
+    numRows = sub_811BAA0();
+    var0 = sub_811BA68();
+    var1 = 0;
+    if (var0 == 7)
+        var1 = 1;
+
+    FillWindowPixelBuffer(gUnknown_0203A11C->windowId, 0x11);
+    for (i = 0; i < numRows; i++)
+    {
+        memcpy(spC, gUnknown_08597C8C, sizeof(gUnknown_08597C8C));
+        if (var1)
+            spC[2] = 6;
+
+        str = gUnknown_0203A11C->unkB;
+        gUnknown_0203A11C->unkB[0] = EOS;
+        str = StringAppend(str, spC);
+        for (j = 0; j < numColumns; j++)
+        {
+            if (*ecWord != 0xFFFF)
+            {
+                str = CopyEasyChatWord(str, *ecWord);
+                ecWord++;
+            }
+            else
+            {
+                ecWord++;
+                if (!var1)
+                {
+                    str = WriteColorChangeControlCode(str, 0, 4);
+                    for (k = 0; k < 12; k++)
+                    {
+                        *str = CHAR_HYPHEN;
+                        str++;
+                    }
+
+                    str = WriteColorChangeControlCode(str, 0, 2);
+                }
+            }
+
+            if (var1)
+                spC[2] = 3;
+
+            str = StringAppend(str, spC);
+            if (var0 == 2 || var0 == 7 || var0 == 8)
+            {
+                if (j == 0 && i == 4)
+                    break;
+            }
+        }
+
+        *str = EOS;
+        sub_811D028(gUnknown_0203A11C->windowId, 1, gUnknown_0203A11C->unkB, 0, i * 16 + 1, 0xFF, 0);
+    }
+
+    CopyWindowToVram(gUnknown_0203A11C->windowId, 3);
+}
+
+static void sub_811D424(u16 *tilemap)
+{
+    u8 var0;
+    int right, bottom;
+    int x, y;
+
+    var0 = sub_811BA68();
+    CpuFastFill(0, tilemap, BG_SCREEN_SIZE);
+    if (var0 == 2 || var0 == 8)
+    {
+        right = gUnknown_08597C30[var0].unk0_0 + gUnknown_08597C30[var0].unk1;
+        bottom = gUnknown_08597C30[var0].unk0_5 + gUnknown_08597C30[var0].unk2;
+        for (y = gUnknown_08597C30[var0].unk0_5; y < bottom; y++)
+        {
+            x = gUnknown_08597C30[var0].unk0_0 - 1;
+            tilemap[y * 32 + x] = 0x1005;
+            x++;
+            for (; x < right; x++)
+                tilemap[y * 32 + x] = 0x1000;
+            
+            tilemap[y* 32 + x] = 0x1007;
+        }
+    }
+    else
+    {
+        y = gUnknown_08597C30[var0].unk0_5 - 1;
+        x = gUnknown_08597C30[var0].unk0_0 - 1;
+        right = gUnknown_08597C30[var0].unk0_0 + gUnknown_08597C30[var0].unk1;
+        bottom = gUnknown_08597C30[var0].unk0_5 + gUnknown_08597C30[var0].unk2;
+        tilemap[y * 32 + x] = 0x1001;
+        x++;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x1002;
+
+        tilemap[y * 32 + x] = 0x1003;
+        y++;
+        for (; y < bottom; y++)
+        {
+            x = gUnknown_08597C30[var0].unk0_0 - 1;
+            tilemap[y * 32 + x] = 0x1005;
+            x++;
+            for (; x < right; x++)
+                tilemap[y * 32 + x] = 0x1000;
+
+            tilemap[y* 32 + x] = 0x1007;
+        }
+
+        x = gUnknown_08597C30[var0].unk0_0 - 1;
+        tilemap[y * 32 + x] = 0x1009;
+        x++;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x100A;
+
+        tilemap[y * 32 + x] = 0x100B;
+    }
+}
+
+static void sub_811D60C(void)
+{
+    u8 var0;
+    u16 *tilemap;
+
+    tilemap = GetBgTilemapBuffer(3);
+    var0 = sub_811BA68();
+    switch (gUnknown_08597C30[var0].unk3)
+    {
+    case 2:
+        tilemap += 0x2A0;
+        CopyToBgTilemapBufferRect(3, tilemap, 0, 11, 32, 2);
+        break;
+    case 1:
+        tilemap += 0x300;
+        CopyToBgTilemapBufferRect(3, tilemap, 0, 11, 32, 2);
+        break;
+    case 3:
+        CopyToBgTilemapBufferRect(3, tilemap, 0, 10, 32, 4);
+        break;
+    }
+}
+
+static void sub_811D684(void)
+{
+    PutWindowTilemap(2);
+    CopyBgTilemapBufferToVram(2);
+}
+
+static void sub_811D698(u32 arg0)
+{
+    sub_811DD84();
+    FillWindowPixelBuffer(2, 0x11);
+    switch (arg0)
+    {
+    case 0:
+        sub_811D6F4();
+        break;
+    case 1:
+        sub_811D758();
+        break;
+    case 2:
+        sub_811D794();
+        break;
+    }
+
+    CopyWindowToVram(2, 2);
+}
+
+static void sub_811D6D4(void)
+{
+    if (!sub_811BBB0())
+        sub_811D698(0);
+    else
+        sub_811D698(1);
+}
+
+static void sub_811D6F4(void)
+{
+    int i;
+    int x, y;
+
+    i = 0;
+    y = 97;
+    while (1)
+    {
+        for (x = 0; x < 2; x++)
+        {
+            u8 index = sub_811F3B8(i++);
+            if (index == 22)
+            {
+                sub_811DDAC(sub_811BBBC(), 0);
+                return;
+            }
+
+            sub_811D028(2, 1, sub_811F424(index), x * 84 + 10, y, 0xFF, NULL);
+        }
+
+        y += 16;
+    }
+}
+
+static void sub_811D758(void)
+{
+    u32 i;
+
+    for (i = 0; i < 4; i++)
+        sub_811D028(2, 1, gUnknown_08597C90[i], 10, 97 + i * 16, 0xFF, NULL);
+}
+
+static void sub_811D794(void)
+{
+    sub_811D864(0, 4);
+}
+
+static void sub_811D7A4(void)
+{
+    u8 var0 = sub_811BBDC() + 3;
+    sub_811D950(var0, 1);
+    sub_811D864(var0, 1);
+}
+
+static void sub_811D7C8(void)
+{
+    u8 var0 = sub_811BBDC();
+    sub_811D950(var0, 1);
+    sub_811D864(var0, 1);
+}
+
+static void sub_811D7EC(void)
+{
+    u8 var0 = sub_811BBDC();
+    u8 var1 = var0 + 4;
+    u8 var2 = sub_811BBE8() + 1;
+    if (var1 > var2)
+        var1 = var2;
+
+    if (var0 < var1)
+    {
+        u8 var3 = var1 - var0;
+        sub_811D950(var0, var3);
+        sub_811D864(var0, var3);
+    }
+}
+
+static void sub_811D830(void)
+{
+    u8 var0 = sub_811BBDC();
+    u8 var1 = sub_811DE48();
+    if (var0 < var1)
+    {
+        u8 var2 = var1 - var0;
+        sub_811D950(var0, var2);
+        sub_811D864(var0, var2);
+    }
+}
+
+static void sub_811D864(u8 arg0, u8 arg1)
+{
+    int i, j;
+    u16 easyChatWord;
+    u8 *str;
+    int y;
+    int var0;
+
+    var0 = arg0 * 2;
+    y = (arg0 * 16 + 96) & 0xFF;
+    y++;
+    for (i = 0; i < arg1; i++)
+    {
+        for (j = 0; j < 2; j++)
+        {
+            easyChatWord = sub_811F578(var0++);
+            if (easyChatWord != 0xFFFF)
+            {
+                CopyEasyChatWordPadded(gUnknown_0203A11C->unkCC, easyChatWord, 0);
+                if (!sub_811BF88(easyChatWord))
+                    sub_811D028(2, 1, gUnknown_0203A11C->unkCC, (j * 13 + 3) * 8, y, 0xFF, NULL);
+                else
+                    sub_811D058(2, 1, gUnknown_0203A11C->unkCC, (j * 13 + 3) * 8, y, 0xFF, 1, 5, 3);
+            }
+        }
+
+        y += 16;
+    }
+
+    CopyWindowToVram(2, 2);
+}
+
+static void sub_811D950(u8 arg0, u8 arg1)
+{
+    int y;
+    int var0;
+    int var1;
+    int var2;
+
+    y = (arg0 * 16 + 96) & 0xFF;
+    var2 = arg1 * 16;
+    var0 = y + var2;
+    if (var0 > 255)
+    {
+        var1 = var0 - 256;
+        var2 = 256 - y;
+    }
+    else
+    {
+        var1 = 0;
+    }
+
+    FillWindowPixelRect(2, 0x11, 0, y, 224, var2);
+    if (var1)
+        FillWindowPixelRect(2, 0x11, 0, 0, 224, var1);
+}
+
+static void sub_811D9B4(void)
+{
+    FillWindowPixelBuffer(2, 0x11);
+    CopyWindowToVram(2, 2);
+}
+
+static void sub_811D9CC(int arg0)
+{
+    switch (arg0)
+    {
+    case 0:
+        gUnknown_0203A11C->unk6 = 0;
+        gUnknown_0203A11C->unk7 = 10;
+        break;
+    case 1:
+        gUnknown_0203A11C->unk6 = 9;
+        gUnknown_0203A11C->unk7 = 0;
+        break;
+    case 2:
+        gUnknown_0203A11C->unk6 = 11;
+        gUnknown_0203A11C->unk7 = 17;
+        break;
+    case 3:
+        gUnknown_0203A11C->unk6 = 17;
+        gUnknown_0203A11C->unk7 = 0;
+        break;
+    case 4:
+        gUnknown_0203A11C->unk6 = 17;
+        gUnknown_0203A11C->unk7 = 10;
+        break;
+    case 5:
+        gUnknown_0203A11C->unk6 = 18;
+        gUnknown_0203A11C->unk7 = 22;
+        break;
+    case 6:
+        gUnknown_0203A11C->unk6 = 22;
+        gUnknown_0203A11C->unk7 = 18;
+        break;
+    }
+
+    gUnknown_0203A11C->unk8 = gUnknown_0203A11C->unk6 < gUnknown_0203A11C->unk7 ? 1 : -1;
+}
+
+static bool8 sub_811DAA4(void)
+{
+    u8 var0, var1;
+    if (gUnknown_0203A11C->unk6 == gUnknown_0203A11C->unk7)
+        return FALSE;
+
+    gUnknown_0203A11C->unk6 += gUnknown_0203A11C->unk8;
+    sub_811DADC(gUnknown_0203A11C->unk6);
+    var0 = gUnknown_0203A11C->unk6;
+    var1 = gUnknown_0203A11C->unk7;
+    return (var0 ^ var1) > 0;
+}
+
+static void sub_811DADC(u8 arg0)
+{
+    FillBgTilemapBufferRect_Palette0(1, 0, 0, 10, 30, 10);
+    switch (arg0)
+    {
+    case 0:
+        break;
+    case 1:
+        sub_811DC28(11, 14, 3, 2);
+        break;
+    case 2:
+        sub_811DC28(9, 14, 7, 2);
+        break;
+    case 3:
+        sub_811DC28(7, 14, 11, 2);
+        break;
+    case 4:
+        sub_811DC28(5, 14, 15, 2);
+        break;
+    case 5:
+        sub_811DC28(3, 14, 19, 2);
+        break;
+    case 6:
+        sub_811DC28(1, 14, 23, 2);
+        break;
+    case 11:
+        sub_811DC28(1, 10, 24, 10);
+        break;
+    case 12:
+        sub_811DC28(1, 10, 25, 10);
+        break;
+    case 13:
+        sub_811DC28(1, 10, 26, 10);
+        break;
+    case 14:
+        sub_811DC28(1, 10, 27, 10);
+        break;
+    case 15:
+        sub_811DC28(1, 10, 28, 10);
+        break;
+    case 16:
+        sub_811DC28(1, 10, 29, 10);
+        break;
+    case 17:
+        sub_811DC28(0, 10, 30, 10);
+        break;
+    case 10:
+    case 18:
+        sub_811DC28(1, 10, 23, 10);
+        break;
+    case 9:
+    case 19:
+        sub_811DC28(1, 11, 23, 8);
+        break;
+    case 8:
+    case 20:
+        sub_811DC28(1, 12, 23, 6);
+        break;
+    case 7:
+    case 21:
+        sub_811DC28(1, 13, 23, 4);
+        break;
+    case 22:
+        sub_811DC28(1, 14, 23, 2);
+        break;
+    }
+
+    CopyBgTilemapBufferToVram(1);
+}
+
+static void sub_811DC28(int left, int top, int width, int height)
+{
+    u16 *tilemap;
+    int right;
+    int bottom;
+    int x, y;
+
+    tilemap = gUnknown_0203A11C->unk300;
+    right = left + width - 1;
+    bottom = top + height - 1;
+    x = left;
+    y = top;
+    tilemap[y * 32 + x] = 0x4001;
+    x++;
+    for (; x < right; x++)
+        tilemap[y * 32 + x] = 0x4002;
+
+    tilemap[y * 32 + x] = 0x4003;
+    y++;
+    for (; y < bottom; y++)
+    {
+        tilemap[y * 32 + left] = 0x4005;
+        x = left + 1;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x4000;
+
+        tilemap[y * 32 + x] = 0x4007;
+    }
+
+    tilemap[y * 32 + left] = 0x4009;
+    x = left + 1;
+    for (; x < right; x++)
+        tilemap[y * 32 + x] = 0x400A;
+
+    tilemap[y * 32 + x] = 0x400B;
+    sub_811DE5C((left + 1) * 8, (top + 1) * 8, (width - 2) * 8, (height - 2) * 8);
+}
+
+static void sub_811DD84(void)
+{
+    ChangeBgY(2, 0x800, 0);
+    gUnknown_0203A11C->unk2CE = 0;
+}
+
+static void sub_811DDAC(s16 arg0, u8 arg1)
+{
+    int bgY;
+    s16 var0;
+
+    bgY = GetBgY(2);
+    gUnknown_0203A11C->unk2CE += arg0;
+    var0 = arg0 * 16;
+    bgY += var0 << 8;
+    if (arg1)
+    {
+        gUnknown_0203A11C->unk2D0 = bgY;
+        gUnknown_0203A11C->unk2D4 = arg1 * 256;
+        if (var0 < 0)
+            gUnknown_0203A11C->unk2D4 = -gUnknown_0203A11C->unk2D4;
+    }
+    else
+    {
+        ChangeBgY(2, bgY, 0);
+    }
+}
+
+static bool8 sub_811DE10(void)
+{
+    int bgY;
+
+    bgY = GetBgY(2);
+    if (bgY == gUnknown_0203A11C->unk2D0)
+    {
+        return FALSE;
+    }
+    else
+    {
+        ChangeBgY(2, gUnknown_0203A11C->unk2D4, 1);
+        return TRUE;
+    }
+}
+
+static int sub_811DE48(void)
+{
+    return gUnknown_0203A11C->unk2CE;
+}
+
+static void sub_811DE5C(u8 left, u8 top, u8 width, u8 height)
+{
+    u16 horizontalDimensions = WIN_RANGE(left, left + width);
+    u16 verticalDimensions = WIN_RANGE(top, top + height);
+    SetGpuReg(REG_OFFSET_WIN0H, horizontalDimensions);
+    SetGpuReg(REG_OFFSET_WIN0V, verticalDimensions);
+}
+
+static void sub_811DE90(void)
+{
+    u32 i;
+
+    LoadSpriteSheets(gUnknown_08597CA0);
+    LoadSpritePalettes(gUnknown_08597CC0);
+    for (i = 0; i < 4; i++)
+        LoadCompressedSpriteSheet(&gUnknown_08597CE8[i]);
+}
+
+static void sub_811DEC4(void)
+{
+    u8 var0 = sub_811BA68();
+    int x = gUnknown_08597C30[var0].unk0_0 * 8 + 13;
+    int y = gUnknown_08597C30[var0].unk0_5 * 8 + 8;
+    u8 spriteId = CreateSprite(&gUnknown_08597D18, x, y, 2);
+    gUnknown_0203A11C->unk2D8 = &gSprites[spriteId];
+    gSprites[spriteId].data[1] = 1;
+}
+
+void sub_811DF28(struct Sprite *sprite)
+{
+    if (sprite->data[1])
+    {
+        if (++sprite->data[0] > 2)
+        {
+            sprite->data[0] = 0;
+            if (++sprite->pos2.x > 0)
+                sprite->pos2.x = -6;
+        }
+    }
+}
+
+static void sub_811DF60(u8 x, u8 y)
+{
+    gUnknown_0203A11C->unk2D8->pos1.x = x;
+    gUnknown_0203A11C->unk2D8->pos1.y = y;
+    gUnknown_0203A11C->unk2D8->pos2.x = 0;
+    gUnknown_0203A11C->unk2D8->data[0] = 0;
+}
+
+static void sub_811DF90(void)
+{
+    gUnknown_0203A11C->unk2D8->data[0] = 0;
+    gUnknown_0203A11C->unk2D8->data[1] = 0;
+    gUnknown_0203A11C->unk2D8->pos2.x = 0;
+}
+
+static void sub_811DFB0(void)
+{
+    gUnknown_0203A11C->unk2D8->data[1] = 1;
+}
+
+static void sub_811DFC8(void)
+{
+    u8 spriteId = CreateSprite(&gUnknown_08597D68, 0, 0, 3);
+    gUnknown_0203A11C->unk2DC = &gSprites[spriteId];
+    gUnknown_0203A11C->unk2DC->pos2.x = 32;
+
+    spriteId = CreateSprite(&gUnknown_08597D68, 0, 0, 3);
+    gUnknown_0203A11C->unk2E0 = &gSprites[spriteId];
+    gUnknown_0203A11C->unk2E0->pos2.x = -32;
+
+    gUnknown_0203A11C->unk2DC->hFlip = 1;
+    sub_811E088();
+}
+
+static void sub_811E050(void)
+{
+    DestroySprite(gUnknown_0203A11C->unk2DC);
+    gUnknown_0203A11C->unk2DC = NULL;
+    DestroySprite(gUnknown_0203A11C->unk2E0);
+    gUnknown_0203A11C->unk2E0 = NULL;
+}
+
+static void sub_811E088(void)
+{
+    u8 var0;
+    u8 var1;
+
+    if (gUnknown_0203A11C->unk2DC && gUnknown_0203A11C->unk2E0)
+    {
+        sub_811BB9C(&var0, &var1);
+        if (!sub_811BBB0())
+            sub_811E0EC(var0, var1);
+        else
+            sub_811E1A4(var0, var1);
+    }
+}
+
+static void sub_811E0EC(s8 arg0, s8 arg1)
+{
+    if (arg0 != -1)
+    {
+        StartSpriteAnim(gUnknown_0203A11C->unk2DC, 0);
+        gUnknown_0203A11C->unk2DC->pos1.x = arg0 * 84 + 58;
+        gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 96;
+
+        StartSpriteAnim(gUnknown_0203A11C->unk2E0, 0);
+        gUnknown_0203A11C->unk2E0->pos1.x = arg0 * 84 + 58;
+        gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 96;
+    }
+    else
+    {
+        StartSpriteAnim(gUnknown_0203A11C->unk2DC, 1);
+        gUnknown_0203A11C->unk2DC->pos1.x = 216;
+        gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 112;
+
+        StartSpriteAnim(gUnknown_0203A11C->unk2E0, 1);
+        gUnknown_0203A11C->unk2E0->pos1.x = 216;
+        gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 112;
+    }
+}
+
+static void sub_811E1A4(s8 arg0, s8 arg1)
+{
+    int anim;
+    int x, y;
+
+    if (arg0 != -1)
+    {
+        y = arg1 * 16 + 96;
+        x = 32;
+        if (arg0 == 6 && arg1 == 0)
+        {
+            x = 158;
+            anim = 2;
+        }
+        else
+        {
+            x += gUnknown_08597D08[(u8)arg0 < 7 ? arg0 : 0];
+            anim = 3;
+        }
+
+        StartSpriteAnim(gUnknown_0203A11C->unk2DC, anim);
+        gUnknown_0203A11C->unk2DC->pos1.x = x;
+        gUnknown_0203A11C->unk2DC->pos1.y = y;
+
+        StartSpriteAnim(gUnknown_0203A11C->unk2E0, anim);
+        gUnknown_0203A11C->unk2E0->pos1.x = x;
+        gUnknown_0203A11C->unk2E0->pos1.y = y;
+    }
+    else
+    {
+        StartSpriteAnim(gUnknown_0203A11C->unk2DC, 1);
+        gUnknown_0203A11C->unk2DC->pos1.x = 216;
+        gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 112;
+
+        StartSpriteAnim(gUnknown_0203A11C->unk2E0, 1);
+        gUnknown_0203A11C->unk2E0->pos1.x = 216;
+        gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 112;
+    }
+}
+
+static void sub_811E288(void)
+{
+    u8 spriteId = CreateSprite(&gUnknown_08597D18, 0, 0, 4);
+    gUnknown_0203A11C->unk2E4 = &gSprites[spriteId];
+    gUnknown_0203A11C->unk2E4->callback = sub_811E2DC;
+    gUnknown_0203A11C->unk2E4->oam.priority = 2;
+    sub_811E30C();
+}
+
+static void sub_811E2DC(struct Sprite *sprite)
+{
+    if (++sprite->data[0] > 2)
+    {
+        sprite->data[0] = 0;
+        if (++sprite->pos2.x > 0)
+            sprite->pos2.x = -6;
+    }
+}
+
+static void sub_811E30C(void)
+{
+    s8 var0, var1, x, y;
+
+    sub_811BBC8(&var0, &var1);
+    x = var0 * 13;
+    x = x * 8 + 28;
+    y = var1 * 16 + 96;
+    sub_811E34C(x, y);
+}
+
+static void sub_811E34C(u8 x, u8 y)
+{
+    if (gUnknown_0203A11C->unk2E4)
+    {
+        gUnknown_0203A11C->unk2E4->pos1.x = x;
+        gUnknown_0203A11C->unk2E4->pos1.y = y;
+        gUnknown_0203A11C->unk2E4->pos2.x = 0;
+        gUnknown_0203A11C->unk2E4->data[0] = 0;
+    }
+}
+
+static void sub_811E380(void)
+{
+    if (gUnknown_0203A11C->unk2E4)
+    {
+        DestroySprite(gUnknown_0203A11C->unk2E4);
+        gUnknown_0203A11C->unk2E4 = NULL;
+    }
+}
+
+static void sub_811E3AC(void)
+{
+    u8 spriteId = CreateSprite(&gUnknown_08597DF0, 208, 128, 6);
+    gUnknown_0203A11C->unk2E8 = &gSprites[spriteId];
+    gUnknown_0203A11C->unk2E8->pos2.x = -64;
+
+    spriteId = CreateSprite(&gUnknown_08597DD0, 208, 80, 5);
+    gUnknown_0203A11C->unk2EC = &gSprites[spriteId];
+    gUnknown_0203A11C->unk9 = 0;
+}
+
+static bool8 sub_811E418(void)
+{
+    switch (gUnknown_0203A11C->unk9)
+    {
+    default:
+        return FALSE;
+    case 0:
+        gUnknown_0203A11C->unk2E8->pos2.x += 8;
+        if (gUnknown_0203A11C->unk2E8->pos2.x >= 0)
+        {
+            gUnknown_0203A11C->unk2E8->pos2.x = 0;
+            if (!sub_811BBB0())
+                StartSpriteAnim(gUnknown_0203A11C->unk2EC, 1);
+            else
+                StartSpriteAnim(gUnknown_0203A11C->unk2EC, 2);
+
+            gUnknown_0203A11C->unk9++;
+        }
+        break;
+    case 1:
+        if (gUnknown_0203A11C->unk2EC->animEnded)
+        {
+            gUnknown_0203A11C->unk9 = 2;
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static void sub_811E4AC(void)
+{
+    gUnknown_0203A11C->unk9 = 0;
+    StartSpriteAnim(gUnknown_0203A11C->unk2EC, 3);
+}
+
+static bool8 sub_811E4D0(void)
+{
+    switch (gUnknown_0203A11C->unk9)
+    {
+    default:
+        return FALSE;
+    case 0:
+        if (gUnknown_0203A11C->unk2EC->animEnded)
+            gUnknown_0203A11C->unk9 = 1;
+        break;
+    case 1:
+        gUnknown_0203A11C->unk2E8->pos2.x -= 8;
+        if (gUnknown_0203A11C->unk2E8->pos2.x <= -64)
+        {
+            DestroySprite(gUnknown_0203A11C->unk2EC);
+            DestroySprite(gUnknown_0203A11C->unk2E8);
+            gUnknown_0203A11C->unk2EC = NULL;
+            gUnknown_0203A11C->unk2E8 = NULL;
+            gUnknown_0203A11C->unk9++;
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static void sub_811E55C(void)
+{
+    StartSpriteAnim(gUnknown_0203A11C->unk2EC, 4);
+}
+
+static void sub_811E578(void)
+{
+    if (!sub_811BBB0())
+        StartSpriteAnim(gUnknown_0203A11C->unk2EC, 1);
+    else
+        StartSpriteAnim(gUnknown_0203A11C->unk2EC, 2);
+}
+
+static bool8 sub_811E5B8(void)
+{
+    return !gUnknown_0203A11C->unk2EC->animEnded;
+}
+
+static void sub_811E5D4(void)
+{
+    u8 spriteId = CreateSprite(&gUnknown_08597E48, 96, 80, 0);
+    if (spriteId != MAX_SPRITES)
+        gUnknown_0203A11C->unk2F0 = &gSprites[spriteId];
+
+    spriteId = CreateSprite(&gUnknown_08597E48, 96, 156, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        gUnknown_0203A11C->unk2F4 = &gSprites[spriteId];
+        gUnknown_0203A11C->unk2F4->vFlip = 1;
+    }
+
+    sub_811E6B0();
+}
+
+static void sub_811E64C(void)
+{
+    gUnknown_0203A11C->unk2F0->invisible = !sub_811BBF8();
+    gUnknown_0203A11C->unk2F4->invisible = !sub_811BC2C();
+}
+
+static void sub_811E6B0(void)
+{
+    gUnknown_0203A11C->unk2F0->invisible = 1;
+    gUnknown_0203A11C->unk2F4->invisible = 1;
+}
+
+static void sub_811E6E0(int arg0)
+{
+    if (!arg0)
+    {
+        gUnknown_0203A11C->unk2F0->pos1.x = 96;
+        gUnknown_0203A11C->unk2F4->pos1.x = 96;
+    }
+    else
+    {
+        gUnknown_0203A11C->unk2F0->pos1.x = 120;
+        gUnknown_0203A11C->unk2F4->pos1.x = 120;
+    }
+}
+
+static void sub_811E720(void)
+{
+    u8 spriteId = CreateSprite(&gUnknown_08597E30, 220, 84, 1);
+    if (spriteId != MAX_SPRITES)
+        gUnknown_0203A11C->unk2F8 = &gSprites[spriteId];
+
+    spriteId = CreateSprite(&gUnknown_08597E30, 220, 156, 1);
+    if (spriteId != MAX_SPRITES)
+    {
+        gUnknown_0203A11C->unk2FC = &gSprites[spriteId];
+        StartSpriteAnim(gUnknown_0203A11C->unk2FC, 1);
+    }
+
+    sub_811E7F8();
+}
+
+static void sub_811E794(void)
+{
+    gUnknown_0203A11C->unk2F8->invisible = !sub_811BBF8();
+    gUnknown_0203A11C->unk2FC->invisible = !sub_811BC2C();
+}
+
+static void sub_811E7F8(void)
+{
+    gUnknown_0203A11C->unk2F8->invisible = 1;
+    gUnknown_0203A11C->unk2FC->invisible = 1;
+}
+
+static void sub_811E828(void)
+{
+    int graphicsId;
+    u8 spriteId;
+
+    switch (sub_811BCBC())
+    {
+    case 0:
+        graphicsId = EVENT_OBJ_GFX_REPORTER_M;
+        break;
+    case 1:
+        graphicsId = EVENT_OBJ_GFX_REPORTER_F;
+        break;
+    case 2:
+        graphicsId = EVENT_OBJ_GFX_BOY_1;
+        break;
+    default:
+        return;
+    }
+
+    if (sub_811BA68() != 4)
+        return;
+
+    spriteId = AddPseudoEventObject(graphicsId, SpriteCallbackDummy, 76, 40, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].oam.priority = 0;
+        StartSpriteAnim(&gSprites[spriteId], 2);
+    }
+
+    spriteId = AddPseudoEventObject(
+        gSaveBlock2Ptr->playerGender == MALE ? EVENT_OBJ_GFX_RIVAL_BRENDAN_NORMAL : EVENT_OBJ_GFX_RIVAL_MAY_NORMAL,
+        SpriteCallbackDummy,
+        52,
+        40,
+        0);
+
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].oam.priority = 0;
+        StartSpriteAnim(&gSprites[spriteId], 3);
+    }
+}
+
+int sub_811E8E4(void)
+{
+    u8 var0 = sub_811BA68();
+    switch (gUnknown_08597C30[var0].unk3)
+    {
+    case 1:
+        return 1;
+    case 2:
+        return 2;
+    case 0:
+        return 0;
+    default:
+        return 3;
+    }
+}
+
+static int sub_811E920(int arg0)
+{
+    int var0 = sub_811E8E4();
+    if (var0 < 3)
+        return gUnknown_08597E60[var0][arg0] + 4;
+    else
+        return 0;
+}
diff --git a/src/pokenav.c b/src/pokenav.c
index ff687e8dc..d09c3da94 100644
--- a/src/pokenav.c
+++ b/src/pokenav.c
@@ -13,26 +13,45 @@
 #include "bg.h"
 #include "menu.h"
 #include "graphics.h"
+#include "dma3.h"
 #include "gba/macro.h"
 #include "decompress.h"
 #include "strings.h"
 #include "constants/rgb.h"
 
+enum
+{
+    MODE_NORMAL, // Chosen from Start menu.
+    MODE_FORCE_CALL_1, // Used for the script's special. Has to choose Match Call and make a call.
+    MODE_FORCE_CALL_2, // Set after making a call, has to exit Pokenav.
+};
+
 #define UNKNOWN_OFFSET 100000
 
+struct UnknownSubStruct_0203CF40
+{
+    void (*unk0)(u32);
+    u32 (*unk4)(void);
+    u32 unk8;
+    u32 unkC;
+    u32 unk10;
+    u32 unk14;
+    struct Sprite *unk18;
+    struct Sprite *unk1C[2];
+    struct Sprite *unk24[2];
+    u8 tilemapBuffer[0x1000];
+};
+
+#define SUBSTRUCT_COUNT 19
+
 struct UnknownStruct_0203CF40
 {
     u32 (*field0)(void);
     u32 field4;
-    u16 field8;
+    u16 mode;
     u16 fieldA;
-    u32 fieldC;
-    void *field10[19];
-};
-
-struct UnknownStruct_sub_81C76C4
-{
-    u32 data[523];
+    bool32 hasAnyRibbons;
+    struct UnknownSubStruct_0203CF40 *field10[SUBSTRUCT_COUNT];
 };
 
 extern u32 sub_81C9430(void);
@@ -101,34 +120,42 @@ extern u32 sub_81CFE08(void);
 u32 sub_81C791C(s32 a0);
 bool32 sub_81C756C(u32 a0);
 bool32 sub_81C76C4(void);
-u32 AnyMonHasRibbon(void);
+static bool32 AnyMonHasRibbon(void);
 u32 sub_81C75E0(void);
 u32 sub_81C75D4(void);
 u32 sub_81C76FC(void);
 u32 sub_81C786C(void);
 u32 sub_81C7764(s32 a0);
-u32 atk47_cmd47(s32 a0);
+u32 sub_81C78D4(s32 a0);
 bool32 sub_81C7738(void);
 void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 a1, u32 a2);
-void sub_81C7834(u32 (*a0)(void), u32(*a1)(void));
-void sub_81C7360(struct UnknownStruct_0203CF40 *a0);
-void sub_81C7650(u32 index);
+void sub_81C7834(void *func1, void *func2);
+static void InitMainStruct(struct UnknownStruct_0203CF40 *a0);
+void FreeSubstruct(u32 index);
 void sub_81C7850(u32 a0);
 void sub_81C7BF8(u32 a0);
 void sub_81C71E4(u8 a0);
-void sub_81C7170(u8 a0);
+void sub_81C7170(u8 taskId);
 void sub_81C742C(u8 taskId);
 void sub_81C7710(void);
-void sub_81C75F4(void);
-void sub_81C7334(void);
-void sub_81C7418(void);
-void sub_81C7400(void);
+static void InitKeys_(void);
+static void FreeVars(void);
+static void VblankCb_Pokenav(void);
+static void Cb2_Pokenav(void);
 void sub_81C7C28(void);
 void sub_81C72BC(void);
 void sub_81C7B74(void);
 void sub_81C7C94(void);
-
-
+void sub_81C7F24(u32 arg0);
+void sub_81C7E58(u32 arg0);
+void sub_81C8110(bool32 arg0);
+void sub_81C80D4(bool32 arg0);
+void sub_81C803C(u32 arg0, bool32 arg1);
+void sub_81C8088(u32 arg0, bool32 arg1);
+void sub_81C814C(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3);
+void sub_81C817C(struct Sprite *sprite);
+
+// Const rom data.
 u32 (*const gUnknown_0861F3EC[15][7])(void) =
 {
     {
@@ -272,15 +299,17 @@ const u16 gUnknown_0861F590[] = INCBIN_U16("graphics/pokenav/icon2.gbapal");
 const u32 gUnknown_0861F5B0[] = INCBIN_U32("graphics/pokenav/icon2.4bpp.lz");
 const u32 gUnknown_0861F994[] = INCBIN_U32("graphics/pokenav/icon2_unused.4bpp.lz");
 
-const struct BgTemplate gUnknown_0861FA04 =
+const struct BgTemplate gUnknown_0861FA04[] =
 {
-    .bg = 0,
-    .charBaseIndex = 0,
-    .mapBaseIndex = 5,
-    .screenSize = 0,
-    .paletteMode = 0,
-    .priority = 0,
-    .baseTile = 0,
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 5,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0,
+    }
 };
 
 const struct WindowTemplate gUnknown_0861FA08[2] =
@@ -305,7 +334,7 @@ const struct WindowTemplate gUnknown_0861FA08[2] =
     },
 };
 
-const u8 *const (MenuButtonReminders[12]) =
+const u8 *const (sMenuButtonReminders[12]) =
 {
     gText_Navgear_ClearButtonList,
     gText_NavgearMap_ZoomedOutButtons,
@@ -341,10 +370,6 @@ const struct SpritePalette gUnknown_0861FA54[2] =
         .data = gUnknown_0861F590,
         .tag = 0,
     },
-    {
-        .data = NULL,
-        .tag = 0,
-    }
 };
 
 const struct CompressedSpriteSheet gUnknown_0861FA64 =
@@ -358,16 +383,17 @@ extern struct UnknownStruct_0203CF40 *gUnknown_0203CF40;
 extern u8 gUnknown_0203CF3C;
 extern const struct SpriteTemplate gUnknown_0861FB04;
 
-u32 sub_81C7078(u32 (*a0)(s32), u32 a1)
+// code
+u32 sub_81C7078(u32 (*func)(s32), u32 priority)
 {
     u16 taskId;
 
     if (!is_c1_link_related_active())
-        taskId = CreateTask(sub_81C7170, a1);
+        taskId = CreateTask(sub_81C7170, priority);
     else
-        taskId = CreateTask(sub_81C71E4, a1);
+        taskId = CreateTask(sub_81C71E4, priority);
 
-    SetWordTaskArg(taskId, 1, (u32)a0);
+    SetWordTaskArg(taskId, 1, (u32)func);
 
     gTasks[taskId].data[3] = gUnknown_0203CF3C;
     return ((gUnknown_0203CF3C++) << 16) | taskId;
@@ -375,62 +401,52 @@ u32 sub_81C7078(u32 (*a0)(s32), u32 a1)
 
 bool32 sub_81C70D8(u32 a0)
 {
-    u32 v1 = a0 & 0xFFFF;
+    u32 taskId = a0 & 0xFFFF;
     u32 v2 = a0 >> 16;
-    if (gTasks[v1].isActive
-        && (gTasks[v1].func == sub_81C7170 || gTasks[v1].func == sub_81C71E4)
-        && gTasks[v1].data[3] == v2)
-    {
-    
+
+    if (gTasks[taskId].isActive
+        && (gTasks[taskId].func == sub_81C7170 || gTasks[taskId].func == sub_81C71E4)
+        && gTasks[taskId].data[3] == v2)
         return TRUE;
-    }
     else
-    {
         return FALSE;
-    }
 }
 
 bool32 sub_81C7124(u32 a0)
 {
     s32 i;
-    for (i = 0; i < 16; i++)
+    for (i = 0; i < NUM_TASKS; i++)
     {
         if (gTasks[i].isActive
-            && (gTasks[i].func == sub_81C7170 || gTasks[i].func == sub_81C71E4))
-        {
-            u32 arg = GetWordTaskArg((u8)i, 1);
-            if (arg == a0)
-                return TRUE;
-        }
+            && (gTasks[i].func == sub_81C7170 || gTasks[i].func == sub_81C71E4)
+            && GetWordTaskArg(i, 1) == a0)
+            return TRUE;
     }
     return FALSE;
 }
 
 void sub_81C7170(u8 taskId)
 {
-    s16 *dataPtr;
-    u32 (*func)(u32);
-    bool32 exitLoop;
+    u32 (*func)(s32) = (void *)GetWordTaskArg(taskId, 1);
+    s16 *data = gTasks[taskId].data;
+    bool32 exitLoop = FALSE;
 
-    func = (u32 (*)(u32))GetWordTaskArg(taskId, 1);
-    dataPtr = gTasks[taskId].data;
-    exitLoop = FALSE;
     while (!exitLoop)
     {
-        u32 v1 =((u32 (*)(u32))func)(dataPtr[0]); 
-        switch (v1)
+        u32 var = func(data[0]);
+        switch (var)
         {
         case 1:
-            dataPtr[0] = dataPtr[0] + 1;
+            data[0] = data[0] + 1;
             break;
         case 0:
-            dataPtr[0]++;
+            data[0]++;
             return;
         case 4:
             DestroyTask(taskId);
             return;
         default:
-            dataPtr[0] = v1 - 5;
+            data[0] = var - 5;
             break;
         case 3:
             break;
@@ -471,91 +487,81 @@ void sub_81C71E4(u8 taskId)
 
 void CB2_PokeNav(void)
 {
-    gUnknown_0203CF40 = Alloc(sizeof(struct UnknownStruct_0203CF40));
+    gUnknown_0203CF40 = Alloc(sizeof(*gUnknown_0203CF40));
     if (gUnknown_0203CF40 == NULL)
     {
         SetMainCallback2(CB2_ReturnToFieldWithOpenMenu);
     }
     else
     {
-        sub_81C7360(gUnknown_0203CF40);
+        InitMainStruct(gUnknown_0203CF40);
         ResetTasks();
         SetVBlankCallback(NULL);
         CreateTask(sub_81C742C, 0);
-        SetMainCallback2(sub_81C7400);
-        SetVBlankCallback(sub_81C7418);
+        SetMainCallback2(Cb2_Pokenav);
+        SetVBlankCallback(VblankCb_Pokenav);
     }
 }
 
-void sub_81C72A4()
+void sub_81C72A4(void)
 {
     SetMainCallback2(sub_81C72BC);
     FadeScreen(1, 0);
 }
 
-void sub_81C72BC()
+void sub_81C72BC(void)
 {
     UpdatePaletteFade();
-    if (!gPaletteFade.active)
+    if (gPaletteFade.active)
+        return;
+
+    gUnknown_0203CF40 = Alloc(sizeof(*gUnknown_0203CF40));
+    if (gUnknown_0203CF40 == NULL)
     {
-        gUnknown_0203CF40 = Alloc(sizeof(struct UnknownStruct_0203CF40));
-        if (gUnknown_0203CF40 == NULL)
-        {
-            SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
-        }
-        else
-        {
-            sub_81C7360(gUnknown_0203CF40);
-            gUnknown_0203CF40->field8 = 1;
-            ResetTasks();
-            ResetSpriteData();
-            FreeAllSpritePalettes();
-            SetVBlankCallback(NULL);
-            CreateTask(sub_81C742C, 0);
-            SetMainCallback2(sub_81C7400);
-            SetVBlankCallback(sub_81C7418);
-        }
+        SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
+    }
+    else
+    {
+        InitMainStruct(gUnknown_0203CF40);
+        gUnknown_0203CF40->mode = MODE_FORCE_CALL_1;
+        ResetTasks();
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        SetVBlankCallback(NULL);
+        CreateTask(sub_81C742C, 0);
+        SetMainCallback2(Cb2_Pokenav);
+        SetVBlankCallback(VblankCb_Pokenav);
     }
 }
 
-void sub_81C7334()
+static void FreeVars(void)
 {
     s32 i;
-    for (i = 0; i < 19; i++)
-    {
-        sub_81C7650(i);
-    }
 
-    Free(gUnknown_0203CF40);
-    gUnknown_0203CF40 = NULL;
+    for (i = 0; i < SUBSTRUCT_COUNT; i++)
+        FreeSubstruct(i);
+
+    FREE_AND_SET_NULL(gUnknown_0203CF40);
     InitKeys();
 }
 
 // Clears UnknownStruct_0203CF40
-void sub_81C7360(struct UnknownStruct_0203CF40 *a0)
+static void InitMainStruct(struct UnknownStruct_0203CF40 *a0)
 {
     s32 i;
-    void **arrayPtr;
-    void *fill;
 
-    fill = NULL;
-    i = 18;
-    arrayPtr = &(a0->field10[18]);
-    for (i; i >= 0; i--)
-    {
-        *arrayPtr = fill;
-        arrayPtr -= 1;
-    }
-    a0->field8 = 0;
+    for (i = 0; i < SUBSTRUCT_COUNT; i++)
+        a0->field10[i] = NULL;
+
+    a0->mode = MODE_NORMAL;
     a0->field4 = 0;
-    a0->fieldC = AnyMonHasRibbon();
+    a0->hasAnyRibbons = AnyMonHasRibbon();
     a0->field0 = NULL;
 }
 
-bool32 AnyMonHasRibbon()
+static bool32 AnyMonHasRibbon(void)
 {
-    s32 i;
-    s32 j;
+    s32 i, j;
 
     for (i = 0; i < PARTY_SIZE; i++)
     {
@@ -569,7 +575,7 @@ bool32 AnyMonHasRibbon()
 
     for (j = 0; j < TOTAL_BOXES_COUNT; j++)
     {
-        for (i = 0; i < IN_BOX_COUNT; i++) 
+        for (i = 0; i < IN_BOX_COUNT; i++)
         {
             if (CheckBoxMonSanityAt(j, i)
                 && GetBoxMonDataAt(j, i, MON_DATA_RIBBON_COUNT) != 0)
@@ -582,7 +588,7 @@ bool32 AnyMonHasRibbon()
     return FALSE;
 }
 
-void sub_81C7400()
+static void Cb2_Pokenav(void)
 {
     RunTasks();
     AnimateSprites();
@@ -590,7 +596,7 @@ void sub_81C7400()
     UpdatePaletteFade();
 }
 
-void sub_81C7418()
+static void VblankCb_Pokenav(void)
 {
     TransferPlttBuffer();
     LoadOam();
@@ -599,34 +605,31 @@ void sub_81C7418()
 
 void sub_81C742C(u8 taskId)
 {
-    s16 *dataPtr;
     u32 v1;
-    bool32 v2;
-
-    dataPtr = gTasks[taskId].data;
+    s16 *data = gTasks[taskId].data;
 
-    switch (dataPtr[0])
+    switch (data[0])
     {
     case 0:
         sub_81C76C4();
-        dataPtr[0] = 1;
+        data[0] = 1;
         break;
     case 1:
         if (sub_81C76FC())
             break;
         sub_81C756C(UNKNOWN_OFFSET);
-        dataPtr[0] = 4;
+        data[0] = 4;
         break;
     case 2:
         if (sub_81C786C())
             break;
-        dataPtr[0] = 3;
+        data[0] = 3;
     case 3:
         v1 = sub_81C75E0();
         if (v1 == -1)
         {
             sub_81C7710();
-            dataPtr[0] = 5;
+            data[0] = 5;
         }
         else if (v1 >= UNKNOWN_OFFSET)
         {
@@ -634,32 +637,33 @@ void sub_81C742C(u8 taskId)
             gUnknown_0861F3EC[gUnknown_0203CF40->field4][5]();
             if (sub_81C756C(v1))
             {
-                dataPtr[0] = 4;
+                data[0] = 4;
             }
             else
             {
                 sub_81C7710();
-                dataPtr[0] = 5;
+                data[0] = 5;
             }
         }
         else if (v1 != 0)
         {
             sub_81C7850(v1);
             if (sub_81C786C())
-                dataPtr[0] = 2;
+                data[0] = 2;
         }
         break;
     case 4:
         if (!sub_81C75D4())
-            dataPtr[0] = 3;
+            data[0] = 3;
         break;
     case 5:
         if (!sub_81C7738())
         {
-            v2 = gUnknown_0203CF40->field8 != 0;
+            bool32 calledFromScript = (gUnknown_0203CF40->mode != MODE_NORMAL);
+
             sub_81C9430();
-            sub_81C7334();
-            if (v2)
+            FreeVars();
+            if (calledFromScript)
                 SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
             else
                 SetMainCallback2(CB2_ReturnToFieldWithOpenMenu);
@@ -670,14 +674,14 @@ void sub_81C742C(u8 taskId)
 
 bool32 sub_81C756C(u32 a0)
 {
-    u32 index;
+    u32 index = a0 - UNKNOWN_OFFSET;
 
-    index = a0 - UNKNOWN_OFFSET;
-    sub_81C75F4();
+    InitKeys_();
     if (!gUnknown_0861F3EC[index][0]())
         return FALSE;
     if (!gUnknown_0861F3EC[index][2]())
         return FALSE;
+
     sub_81C7834(gUnknown_0861F3EC[index][3], gUnknown_0861F3EC[index][4]);
     gUnknown_0203CF40->field0 = gUnknown_0861F3EC[index][1];
     gUnknown_0203CF40->field4 = index;
@@ -694,52 +698,52 @@ u32 sub_81C75E0(void)
     return gUnknown_0203CF40->field0();
 }
 
-void sub_81C75F4(void)
+static void InitKeys_(void)
 {
     InitKeys();
 }
 
-void IndirectSetVBlankCallback(IntrCallback callback)
+void SetVBlankCallback_(IntrCallback callback)
 {
     SetVBlankCallback(callback);
 }
 
-void sub_81C760C(void)
+void SetPokenavVBlankCallback(void)
 {
-    SetVBlankCallback(sub_81C7418);
+    SetVBlankCallback(VblankCb_Pokenav);
 }
 
-void *sub_81C761C(u32 index, u32 size)
+void *AllocSubstruct(u32 index, u32 size)
 {
-    return gUnknown_0203CF40->field10[index] = (void*)Alloc(size);
+    return gUnknown_0203CF40->field10[index] = Alloc(size);
 }
 
-void *sub_81C763C(u32 index)
+struct UnknownSubStruct_0203CF40 *GetSubstructPtr(u32 index)
 {
     return gUnknown_0203CF40->field10[index];
 }
 
-void sub_81C7650(u32 index)
+void FreeSubstruct(u32 index)
 {
     if (gUnknown_0203CF40->field10[index] != NULL)
         FREE_AND_SET_NULL(gUnknown_0203CF40->field10[index]);
 }
 
-u16 sub_81C767C(void)
+u16 GetPokenavMode(void)
 {
-    return gUnknown_0203CF40->field8;
+    return gUnknown_0203CF40->mode;
 }
 
-void sub_81C7688(u16 a0)
+void SetPokenavMode(u16 mode)
 {
-    gUnknown_0203CF40->field8 = a0;
+    gUnknown_0203CF40->mode = mode;
 }
 
 void sub_81C7694(u32 a0)
 {
-    u32 value;
-    value = a0;
-    if (a0 > 4)
+    u32 value = a0;
+
+    if (value > 4)
         value = 0;
     gUnknown_0203CF40->fieldA = value;
 }
@@ -749,34 +753,27 @@ u16 sub_81C76AC(void)
     return gUnknown_0203CF40->fieldA;
 }
 
-u32 sub_81C76B8(void)
+bool32 CanViewRibbonsMenu(void)
 {
-    return gUnknown_0203CF40->fieldC;
+    return gUnknown_0203CF40->hasAnyRibbons;
 }
 
 bool32 sub_81C76C4(void)
 {
-    struct UnknownStruct_sub_81C76C4 *v1;
-
-    v1 = (struct UnknownStruct_sub_81C76C4*)sub_81C761C(0, sizeof(struct UnknownStruct_sub_81C76C4));
-    if (v1 == NULL)
-    {
+    struct UnknownSubStruct_0203CF40 *structPtr = AllocSubstruct(0, 0x82C);
+    if (structPtr == NULL)
         return FALSE;
-    }
-    else
-    {
-        ResetSpriteData();
-        FreeAllSpritePalettes();
-        v1->data[3] = sub_81C7078(sub_81C7764, 1);
-        return TRUE;
-    }
+
+    ResetSpriteData();
+    FreeAllSpritePalettes();
+    structPtr->unkC = sub_81C7078(sub_81C7764, 1);
+    return TRUE;
 }
 
 u32 sub_81C76FC(void)
 {
-    u32 *v1;
-    v1 = sub_81C763C(0);
-    return sub_81C70D8(v1[3]);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    return sub_81C70D8(structPtr->unkC);
 }
 
 void sub_81C7710(void)
@@ -794,15 +791,14 @@ bool32 sub_81C7738(void)
         sub_81C7C94();
         FreeAllWindowBuffers();
         return FALSE;
-    } else
-    {
-        return TRUE;
     }
+
+    return TRUE;
 }
 
 u32 sub_81C7764(s32 a0)
 {
-    u32 *v1;
+    struct UnknownSubStruct_0203CF40 *structPtr;
 
     switch (a0)
     {
@@ -810,14 +806,14 @@ u32 sub_81C7764(s32 a0)
         SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
         FreeAllWindowBuffers();
         ResetBgsAndClearDma3BusyFlags(0);
-        InitBgsFromTemplates(0, &gUnknown_0861FA04, 1);
+        InitBgsFromTemplates(0, gUnknown_0861FA04, ARRAY_COUNT(gUnknown_0861FA04));
         sub_8199D98();
         reset_temp_tile_data_buffers();
         return 1;
     case 1:
-        v1 = sub_81C763C(0);
+        structPtr = GetSubstructPtr(0);
         decompress_and_copy_tile_data_to_vram(0, &gPokenavHeader_Gfx, 0, 0, 0);
-        SetBgTilemapBuffer(0, &v1[11]);
+        SetBgTilemapBuffer(0, structPtr->tilemapBuffer);
         CopyToBgTilemapBuffer(0, &gPokenavHeader_Tilemap, 0, 0);
         CopyPaletteIntoBufferUnfaded(gPokenavHeader_Pal, 0, 0x20);
         CopyBgTilemapBufferToVram(0);
@@ -825,7 +821,7 @@ u32 sub_81C7764(s32 a0)
     case 2:
         if (free_temp_tile_data_buffers_if_possible())
             return 2;
-        
+
         sub_81C7B74();
         return 0;
     case 3:
@@ -841,58 +837,46 @@ u32 sub_81C7764(s32 a0)
     }
 }
 
-void sub_81C7834(u32 (*a0)(void), u32(*a1)(void))
+void sub_81C7834(void *func1, void *func2) // Fix types later.
 {
-    u32 (**v1)(void);
-
-    v1 = sub_81C763C(0);
-    v1[0] = a0;
-    v1[1] = a1;
-    v1[2] = NULL;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    structPtr->unk0 = func1;
+    structPtr->unk4 = func2;
+    structPtr->unk8 = 0;
 }
 
 void sub_81C7850(u32 a0)
 {
-    void (**v1)(u32);
-
-    v1 = sub_81C763C(0);
-    v1[2] = NULL;
-    v1[0](a0);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    structPtr->unk8 = 0;
+    structPtr->unk0(a0);
 }
 
 u32 sub_81C786C(void)
 {
-    u32 (**v1)(void);
-
-    v1 = sub_81C763C(0);
-    return v1[1]();
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    return structPtr->unk4();
 }
 
 void sub_81C7880(void)
 {
-    u32 *v1;
-    
-    v1 = sub_81C763C(0);
-    v1[3] = sub_81C7078(atk47_cmd47, 4);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    structPtr->unkC = sub_81C7078(sub_81C78D4, 4);
 }
 
 void sub_81C78A0(void)
 {
-    u32 *v1;
-
-    v1 = sub_81C763C(0);
-    v1[3] = sub_81C7078(sub_81C791C, 4);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    structPtr->unkC = sub_81C7078(sub_81C791C, 4);
 }
 
 bool32 sub_81C78C0(void)
 {
-    u32 *v1;
-
-    v1 = sub_81C763C(0);
-    return sub_81C70D8(v1[3]);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+    return sub_81C70D8(structPtr->unkC);
 }
 
-u32 atk47_cmd47(s32 a0)
+u32 sub_81C78D4(s32 a0)
 {
     switch (a0)
     {
@@ -903,12 +887,12 @@ u32 atk47_cmd47(s32 a0)
     case 0:
         return 0;
     case 2:
-        if ((u32)ChangeBgY(0, 384, 1) >= 0x2000)
+        if (ChangeBgY(0, 384, 1) >= 0x2000u)
         {
             ChangeBgY(0, 0x2000, 0);
             return 4;
         }
-        
+
         return 2;
     }
 }
@@ -923,7 +907,8 @@ u32 sub_81C791C(s32 a0)
     return 2;
 }
 
-void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 bufferOffset, u32 size) {
+void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 bufferOffset, u32 size)
+{
     CpuCopy16(palette, gPlttBufferUnfaded + bufferOffset, size);
 }
 
@@ -932,7 +917,7 @@ void sub_81C795C(const struct SpritePalette *palettes)
     const struct SpritePalette *current;
     u32 index;
 
-    for (current = palettes; current->data != NULL; current++) 
+    for (current = palettes; current->data != NULL; current++)
     {
         index = AllocSpritePalette(current->tag);
         if (index == 0xFF)
@@ -953,7 +938,7 @@ void sub_81C7990(u32 a0, u16 a1)
 }
 
 __attribute__((naked))
-void sub_81C79BC(u16 *a0, u16 *a1, u32 a2, u32 a3, u32 unused, u32 a5, u32 a6)
+void sub_81C79BC(u16 *a0, u16 *a1, u32 a2, u32 a3, u32 a4, u32 a5)
 {
     asm(".syntax unified\n\
     push {r4-r7,lr}\n\
@@ -1090,15 +1075,15 @@ _081C7AAE:\n\
 
 void sub_81C7AC0(s32 a0)
 {
-    u32 *v1;
-    v1 = sub_81C763C(0);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
     switch (a0)
     {
     case 0:
-        BeginNormalPaletteFade(v1[5], -2, 0, 16, RGB_BLACK);
+        BeginNormalPaletteFade(structPtr->unk14, -2, 0, 16, RGB_BLACK);
         break;
     case 1:
-        BeginNormalPaletteFade(v1[5], -2, 16, 0, RGB_BLACK);
+        BeginNormalPaletteFade(structPtr->unk14, -2, 16, 0, RGB_BLACK);
         break;
     case 2:
         BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK);
@@ -1119,93 +1104,330 @@ void sub_81C7B40(void)
     BlendPalettes(0xFFFEFFFE, 16, RGB_BLACK);
 }
 
-void sub_81C7B54(const struct BgTemplate *a0, s32 a1)
+void InitBgTemplates(const struct BgTemplate *templates, s32 count)
 {
     s32 i;
-    if (a1 <= 0)
-        return;
-    for (i = a1; i != 0; i--)
-    {
-        InitBgFromTemplate(a0++);
-    }
+
+    for (i = 0; i < count; i++)
+        InitBgFromTemplate(templates++);
 }
 
 void sub_81C7B74(void)
 {
-    u32 *v1;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
 
-    v1 = sub_81C763C(0);
     InitWindows(&gUnknown_0861FA08[0]);
-    v1[4] = 0;
-    sub_81C7BF8(0);
-    PutWindowTilemap(v1[4]);
-    CopyWindowToVram(v1[4], 3); // TODO: Use a defined constant here.
+    structPtr->unk10 = 0;
+    sub_81C7BF8(structPtr->unk10);
+    PutWindowTilemap(structPtr->unk10);
+    CopyWindowToVram(structPtr->unk10, 3); // TODO: Use a defined constant here.
 }
 
 void sub_81C7BA4(u32 a0)
 {
-    u32 *v1;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
 
-    v1 = sub_81C763C(0);
-    sub_81C7BF8(v1[4]);
-    AddTextPrinterParameterized3(v1[4], 1, 0, 1, gMenuButtonReminderColor, 0, MenuButtonReminders[a0]);
+    sub_81C7BF8(structPtr->unk10);
+    AddTextPrinterParameterized3(structPtr->unk10, 1, 0, 1, gMenuButtonReminderColor, 0, sMenuButtonReminders[a0]);
 }
 
-bool8 sub_81C7BE8(void)
+bool32 IsDma3ManagerBusyWithBgCopy_(void)
 {
     return IsDma3ManagerBusyWithBgCopy();
 }
 
-void sub_81C7BF8(u32 a0)
+void sub_81C7BF8(u32 windowId)
 {
-    FillWindowPixelBuffer(a0, 0x44);
-    FillWindowPixelRect(a0, 0x55, 0, 0, 0x80, 1);
+    FillWindowPixelBuffer(windowId, 0x44);
+    FillWindowPixelRect(windowId, 0x55, 0, 0, 0x80, 1);
 }
 
 void sub_81C7C28(void)
 {
-    u32 *v1;
-    u32 i;
-    u8 v2;
-    u32 v3;
-    u32 v4;
+    s32 i;
     u8 spriteId;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
 
-    v1 = sub_81C763C(0);
     for (i = 0; i < ARRAY_COUNT(gUnknown_0861FA4C); i++)
-    {
         LoadCompressedSpriteSheet(&gUnknown_0861FA4C[i]);
-    }
 
     sub_81C795C(gUnknown_0861FA54);
-    v2 = IndexOfSpritePaletteTag(0);
-    v1[5] = ~1 & ~(0x10000 << v2);
+    structPtr->unk14 = ~1 & ~(0x10000 << IndexOfSpritePaletteTag(0));
     spriteId = CreateSprite(&gUnknown_0861FB04, 220, 12, 0);
-    v1[6] = (u32)(&gSprites[spriteId]);
+    structPtr->unk18 = &gSprites[spriteId];
 }
 
 void sub_81C7C94(void)
 {
-    void **v1;
-    v1 = sub_81C763C(0);
-    DestroySprite(v1[6]);
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    DestroySprite(structPtr->unk18);
     FreeSpriteTilesByTag(0);
     FreeSpritePaletteByTag(0);
 }
 
-void sub_81C7CB4(u16 *a0)
+void sub_81C7CB4(struct Sprite *sprite)
 {
-    u32 v1;
-    v1 = GetBgY(0);
-    a0[19] = (v1 >> 8) * -1;
+    sprite->pos2.y = (GetBgY(0) / 256u) * -1;
 }
 
 struct Sprite *sub_81C7CCC(void)
 {
-    struct Sprite **v1;
-    struct Sprite *v2;
-    v1 = sub_81C763C(0);
-    v2 = v1[6];
-    v2->callback = SpriteCallbackDummy;
-    return v2;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    structPtr->unk18->callback = SpriteCallbackDummy;
+    return structPtr->unk18;
+}
+
+void sub_81C7CE4(void)
+{
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    structPtr->unk18->pos1.x = 220;
+    structPtr->unk18->pos1.y = 12;
+    structPtr->unk18->callback = sub_81C7CB4;
+    structPtr->unk18->invisible = FALSE;
+    structPtr->unk18->oam.priority = 0;
+    structPtr->unk18->subpriority = 0;
+}
+
+extern const struct SpriteTemplate gUnknown_0861FB2C;
+extern const struct SpriteTemplate gUnknown_0861FB44;
+extern const struct CompressedSpriteSheet gUnknown_0861FA6C[];
+
+void sub_81C7D28(void)
+{
+    s32 i, spriteId;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    LoadCompressedSpriteSheet(&gUnknown_0861FA64);
+    AllocSpritePalette(1);
+    AllocSpritePalette(2);
+    for (i = 0; i < 2; i++)
+    {
+        spriteId = CreateSprite(&gUnknown_0861FB2C, 0, 0, 1);
+        structPtr->unk1C[i] = &gSprites[spriteId];
+        structPtr->unk1C[i]->invisible = TRUE;
+        structPtr->unk1C[i]->pos2.x = i * 64;
+
+        spriteId = CreateSprite(&gUnknown_0861FB44, 0, 0, 2);
+        structPtr->unk24[i] = &gSprites[spriteId];
+        structPtr->unk24[i]->invisible = TRUE;
+        structPtr->unk24[i]->pos2.x = i * 32;
+        structPtr->unk24[i]->pos2.y = 18;
+        structPtr->unk24[i]->oam.tileNum += (i * 8) + 64;
+    }
+}
+
+void sub_81C7DFC(u32 arg0)
+{
+    if (arg0 < 6)
+        sub_81C7E58(arg0);
+    else
+        sub_81C7F24(arg0 - 6);
+}
+
+void sub_81C7E14(u32 arg0)
+{
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (arg0 == 4)
+        structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + 32;
+    else
+        structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + 64;
+}
+
+void sub_81C7E58(u32 arg0)
+{
+    struct UnknownSubStruct_0203CF40 *structPtr;
+    u32 size, tag;
+
+    if (arg0 >= 6)
+        return;
+
+    structPtr = GetSubstructPtr(0);
+    tag = gUnknown_0861FA6C[arg0].tag;
+    size = GetDecompressedDataSize(gUnknown_0861FA6C[arg0].data);
+    LoadPalette(&gPokenavLeftHeader_Pal[tag * 16], (IndexOfSpritePaletteTag(1) * 16) + 0x100, 0x20);
+    LZ77UnCompWram(gUnknown_0861FA6C[arg0].data, gDecompressionBuffer);
+    RequestDma3Copy(gDecompressionBuffer, (void *)VRAM + 0x10000 + (GetSpriteTileStartByTag(2) * 32), size, 1);
+    structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + gUnknown_0861FA6C[arg0].size;
+
+    if (arg0 == 4 || arg0 == 5)
+        structPtr->unk1C[1]->pos2.x = 56;
+    else
+        structPtr->unk1C[1]->pos2.x = 64;
+}
+
+// Needed to match u32/u16 tag field difference.
+struct CompressedSpritePalette_
+{
+    const u32 *data;  // LZ77 compressed palette data
+    u32 tag;
+};
+
+extern const struct CompressedSpritePalette_ gUnknown_0861FA9C[];
+
+void sub_81C7F24(u32 arg0)
+{
+    u32 size, tag;
+
+    if (arg0 >= 7)
+        return;
+
+    tag = gUnknown_0861FA9C[arg0].tag;
+    size = GetDecompressedDataSize(gUnknown_0861FA9C[arg0].data);
+    LoadPalette(&gPokenavLeftHeader_Pal[tag * 16], (IndexOfSpritePaletteTag(2) * 16) + 0x100, 0x20);
+    LZ77UnCompWram(gUnknown_0861FA9C[arg0].data, &gDecompressionBuffer[0x1000]);
+    RequestDma3Copy(&gDecompressionBuffer[0x1000], (void *)VRAM + 0x10800 + (GetSpriteTileStartByTag(2) * 32), size, 1);
+}
+
+void sub_81C7FA0(u32 arg0, bool32 arg1, bool32 arg2)
+{
+    u32 var;
+
+    if (!arg1)
+        var = 0x30;
+    else
+        var = 0x10;
+
+    if (arg0 < 6)
+        sub_81C803C(var, arg2);
+    else
+        sub_81C8088(var, arg2);
+}
+
+void sub_81C7FC4(u32 arg0, bool32 arg1)
+{
+    if (arg0 < 6)
+        sub_81C80D4(arg1);
+    else
+        sub_81C8110(arg1);
+}
+
+void sub_81C7FDC(void)
+{
+    s32 i;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    for (i = 0; i < 2; i++)
+    {
+        structPtr->unk1C[i]->invisible = TRUE;
+        structPtr->unk24[i]->invisible = TRUE;
+    }
+}
+
+bool32 sub_81C8010(void)
+{
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (structPtr->unk1C[0]->callback == SpriteCallbackDummy && structPtr->unk24[0]->callback == SpriteCallbackDummy)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+void sub_81C803C(u32 arg0, bool32 arg1)
+{
+    s32 var1, var2, i;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (!arg1)
+        var1 = -96, var2 = 32;
+    else
+        var1 = 256, var2 = 160;
+
+    for (i = 0; i < 2; i++)
+    {
+        structPtr->unk1C[i]->pos1.y = arg0;
+        sub_81C814C(structPtr->unk1C[i], var1, var2, 12);
+    }
+}
+
+void sub_81C8088(u32 arg0, bool32 arg1)
+{
+    s32 var1, var2, i;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (!arg1)
+        var1 = -96, var2 = 16;
+    else
+        var1 = 256, var2 = 192;
+
+    for (i = 0; i < 2; i++)
+    {
+        structPtr->unk24[i]->pos1.y = arg0;
+        sub_81C814C(structPtr->unk24[i], var1, var2, 12);
+    }
+}
+
+void sub_81C80D4(bool32 arg0)
+{
+    s32 var1, var2, i;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (!arg0)
+        var1 = 32, var2 = -96;
+    else
+        var1 = 192, var2 = 256;
+
+    for (i = 0; i < 2; i++)
+    {
+        sub_81C814C(structPtr->unk1C[i], var1, var2, 12);
+    }
+}
+
+void sub_81C8110(bool32 arg0)
+{
+    s32 var1, var2, i;
+    struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0);
+
+    if (!arg0)
+        var1 = 16, var2 = -96;
+    else
+        var1 = 192, var2 = 256;
+
+    for (i = 0; i < 2; i++)
+    {
+        sub_81C814C(structPtr->unk24[i], var1, var2, 12);
+    }
+}
+
+void sub_81C814C(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3)
+{
+    sprite->pos1.x = arg1;
+    sprite->data[0] = arg1 * 16;
+    sprite->data[1] = (arg2 - arg1) * 16 / arg3;
+    sprite->data[2] = arg3;
+    sprite->data[7] = arg2;
+    sprite->callback = sub_81C817C;
+}
+
+void sub_81C817C(struct Sprite *sprite)
+{
+    if (sprite->data[2] != 0)
+    {
+        sprite->data[2]--;
+        sprite->data[0] += sprite->data[1];
+        sprite->pos1.x = sprite->data[0] >> 4;
+        if (sprite->pos1.x < -16 || sprite->pos1.x > 256)
+            sprite->invisible = TRUE;
+        else
+            sprite->invisible = FALSE;
+    }
+    else
+    {
+        sprite->pos1.x = sprite->data[7];
+        sprite->callback = SpriteCallbackDummy;
+    }
+}
+
+/*
+bool32 sub_81C81D4(const void *arg0, void *arg1, s32 arg3)
+{
+    struct UnknownSubStruct_0203CF40 *structPtr = AllocSubstruct(0x11, 0x8A4);
+
+    if (structPtr == NULL)
+        return FALSE;
 }
+*/