undo revert

6 files changed, 6655 insertions, 6 deletions

diff --git a/src/decoration.c b/src/decoration.c
new file mode 100644
index 000000000..0179d36a1
--- /dev/null
+++ b/src/decoration.c
@@ -0,0 +1,2781 @@
+
+// Includes
+#include "global.h"
+#include "decompress.h"
+#include "malloc.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "script.h"
+#include "task.h"
+#include "main.h"
+#include "palette.h"
+#include "songs.h"
+#include "overworld.h"
+#include "fieldmap.h"
+#include "metatile_behavior.h"
+#include "field_weather.h"
+#include "field_player_avatar.h"
+#include "field_camera.h"
+#include "field_screen.h"
+#include "field_map_obj.h"
+#include "list_menu.h"
+#include "menu_helpers.h"
+#include "new_menu_helpers.h"
+#include "menu_indicators.h"
+#include "sound.h"
+#include "event_scripts.h"
+#include "event_data.h"
+#include "region_map.h"
+#include "player_pc.h"
+#include "strings.h"
+#include "tv.h"
+#include "secret_base.h"
+#include "tilesets.h"
+#include "item_icon.h"
+#include "trader.h"
+#include "map_object_constants.h"
+#include "decoration_inventory.h"
+#include "decoration.h"
+#include "graphics.h"
+
+// Static type declarations
+
+#define OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG 0xbe5
+#define OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG 0x008
+
+struct DecorPCBuffer {
+    struct ListMenuItem items[41];
+    u8 names[41][24];
+    u8 unk_520;
+    u8 unk_521;
+    u8 unk_522;
+};
+
+struct PlaceDecorationGraphicsDataBuffer {
+    /*0x000; 0x0203a190*/ const struct Decoration *decoration;
+    /*0x004; 0x0203a194*/ u16 tiles[0x40];
+    /*0x084; 0x0203a214*/ u8 image[0x800];
+    /*0x884; 0x0203aa14*/ u16 palette[16];
+};
+
+struct DecorRearrangementDataBuffer {
+    u8 idx;
+    u8 width;
+    u8 height;
+    u16 flagId;
+};
+
+// Static RAM declarations
+
+EWRAM_DATA u8 *gCurDecorInventoryItems = NULL;
+EWRAM_DATA u8 sSecretBasePCMenuCursorPos = 0;
+EWRAM_DATA u8 sCurDecorCatCount = 0;
+EWRAM_DATA u8 sSecretBaseItemsIndicesBuffer[16] = {};
+EWRAM_DATA u8 sPlayerRoomItemsIndicesBuffer[12] = {};
+EWRAM_DATA u16 sSecretBasePCSelectDecorLineNo = 0;
+EWRAM_DATA u16 sSecretBasePCSelectDecorPageNo = 0;
+EWRAM_DATA u8 gCurDecorationIndex = 0;
+EWRAM_DATA u8 sCurDecorationCategory = DECORCAT_DESK;
+EWRAM_DATA u32 filler_0203a174[2] = {};
+EWRAM_DATA struct DecorPCPointers gUnknown_0203A17C = {};
+EWRAM_DATA u8 sDecorMenuWindowIndices[4] = {};
+EWRAM_DATA struct DecorPCBuffer *sDecorPCBuffer = NULL;
+EWRAM_DATA struct PlaceDecorationGraphicsDataBuffer sPlaceDecorationGraphicsDataBuffer = {};
+EWRAM_DATA u16 sCurDecorMapX = 0;
+EWRAM_DATA u16 sCurDecorMapY = 0;
+EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx1 = 0;
+EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx2 = 0;
+EWRAM_DATA u8 sDecorationLastDirectionMoved = 0;
+EWRAM_DATA struct OamData sDecorSelectorOam = {};
+EWRAM_DATA struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {};
+EWRAM_DATA u8 sCurDecorSelectedInRearrangement = 0;
+
+// Static ROM declarations
+
+void sub_8126B80(u8 taskId);
+void sub_8126C08(void);
+void SecretBasePC_Decorate(u8 taskId);
+void SecretBasePC_PutAway(u8 taskId);
+void SecretBasePC_Toss(u8 taskId);
+void sub_8126DA4(u8 taskId);
+void SecretBasePC_Cancel(u8 taskId);
+void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId);
+void sub_8126DFC(u8 taskId);
+void sub_8126E8C(u8 taskId);
+void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed);
+void sub_8127058(u8 *str, bool8 flag);
+void sub_8127088(u8 taskId);
+void sub_81270E8(u8 taskId);
+void sub_8127180(u8 taskId);
+void sub_812719C(u8 taskId);
+void sub_81271CC(u8 taskId);
+void sub_8127268(u8 taskId);
+void sub_8127454(u8 *dest, u16 decorId);
+void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu);
+void sub_81274A0(u8 a0, s32 a1, u8 a2);
+void sub_8127620(u8 taskId);
+void sub_812764C(u8 taskId);
+void sub_8127744(u32 a0);
+void sub_81277A8(void);
+bool8 sub_81277BC(u8 idx);
+bool8 sub_81277E8(u8 idx);
+void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId);
+void sub_812759C(u8 taskId);
+void sub_8127718(u8 decorCat);
+void sub_8127A30(u8 taskId);
+void sub_8127A8C(u8 taskId);
+void sub_8127F68(u8 taskId);
+void sub_8128060(u8 taskId);
+void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor);
+void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data);
+void sub_812826C(u8 taskId);
+void sub_81283BC(u8 taskId);
+void sub_8128414(u8 taskId);
+void sub_8128950(u8 taskId);
+void sub_81289D0(u8 taskId);
+void sub_81289F0(u8 taskId);
+void sub_8128AAC(u8 taskId);
+void sub_8128B80(u8 taskId);
+void sub_8128BA0(u8 taskId);
+void sub_8128BBC(u8 taskId);
+void c1_overworld_prev_quest(u8 taskId);
+void sub_8128CD4(void);
+void sub_8128DE0(void);
+void sub_8128FD8(u8 taskId);
+void sub_8129020(u8 taskId);
+void sub_81292D0(struct Sprite *sprite);
+void sub_81292E8(struct Sprite *sprite);
+u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor);
+const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode);
+bool8 sub_81299AC(u8 taskId);
+void sub_8129ABC(u8 taskId);
+void sub_8129B34(u8 taskId);
+void sub_8129BCC(u8 taskId);
+void sub_8129BF8(u8 taskId);
+void sub_8129C74(u8 taskId);
+void sub_8129D64(u8 taskId);
+void sub_812A0E8(u8 taskId);
+void sub_812A1A0(u8 taskId);
+void sub_812A1C0(u8 taskId);
+void sub_812A1F0(u8 taskId);
+void sub_812A210(u8 taskId);
+void sub_812A22C(u8 taskId);
+void sub_812A25C(u8 taskId);
+void sub_812A334(void);
+void sub_812A36C(struct Sprite *sprite);
+void sub_812A39C(void);
+void sub_812A3C8(void);
+void sub_812A3D4(u8 taskId);
+void sub_812A458(u8 taskId);
+void sub_812A478(u8 taskId);
+
+// .rodata
+
+#include "data/decoration/tiles.h"
+#include "data/decoration/description.h"
+#include "data/decoration/header.h"
+
+const u8 *const sDecorCatNames[] = {
+    gText_Desk,
+    gText_Chair,
+    gText_Plant,
+    gText_Ornament,
+    gText_Mat,
+    gText_Poster,
+    gText_Doll,
+    gText_Cushion
+};
+
+const struct MenuAction sSecretBasePCMenuActions[] = {
+    {
+        gText_Decorate, {.void_u8=SecretBasePC_Decorate}
+    }, {
+        gText_PutAway, {.void_u8=SecretBasePC_PutAway}
+    }, {
+        gText_Toss2, {.void_u8=SecretBasePC_Toss}
+    }, {
+        gText_Cancel, {.void_u8=SecretBasePC_Cancel}
+    }
+};
+
+const u8 *const sSecretBasePCMenuItemDescriptions[] = {
+    gText_PutOutSelectedDecorItem,
+    gText_StoreChosenDecorInPC,
+    gText_ThrowAwayUnwantedDecors,
+    gText_GoBackPrevMenu
+};
+
+void (*const SecretBasePC_SelectedDecorActions[][2])(u8 taskId) = {
+   {
+        sub_8127F68, sub_8127A8C
+   }, {
+        sub_812A3D4, sub_8127A8C
+   }, {
+        sub_8133DA0, sub_8127A8C
+   }
+};
+
+const struct WindowTemplate gUnknown_085A6B90[4] = {
+    { 0,  1,  1, 18,  8, 15, 0x0001 },
+    { 0,  1,  1, 13, 18, 13, 0x0091 },
+    { 0, 17,  1, 12,  2, 15, 0x017b },
+    { 0, 16, 13, 13,  6, 15, 0x0193 }
+};
+
+const u16 gUnknown_085A6BB0[] = INCBIN_U16("graphics/decorations/unk_85a6bb0.gbapal");
+
+const struct ListMenuTemplate gUnknown_085A6BD0 = {
+    NULL,
+    sub_8127480,
+    sub_81274A0,
+    0, 0,
+    0, 0, 8, 0,
+    9, 2, 1, 3, FALSE, 0, FALSE, 7
+};
+
+#include "data/decoration/icon.h"
+#include "data/decoration/tilemaps.h"
+
+const struct {
+    u8 shape;
+    u8 size;
+    u8 x;
+    u8 y;
+} gUnknown_085A7250[] = {
+    {0, 1, 0x78, 0x4e},
+    {1, 2, 0x80, 0x4e},
+    {1, 3, 0x90, 0x56},
+    {1, 3, 0x90, 0x46},
+    {0, 2, 0x80, 0x46},
+    {2, 2, 0x78, 0x46},
+    {2, 3, 0x80, 0x56},
+    {2, 3, 0x80, 0x36},
+    {0, 3, 0x90, 0x46},
+    {1, 3, 0x90, 0x46}
+};
+
+const union AnimCmd gUnknown_085A7278[] = {
+    ANIMCMD_FRAME(0, 0, FALSE, FALSE),
+    ANIMCMD_END
+};
+
+const union AnimCmd *const sDecorSelectorAnims[] = {
+    gUnknown_085A7278
+};
+
+const struct SpriteFrameImage sDecorSelectorSpriteFrameImages = {
+    (const u8 *)&sPlaceDecorationGraphicsDataBuffer.image, 0x800
+};
+
+const struct SpriteTemplate sDecorSelectorSpriteTemplate = {
+    0xffff,
+    OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG,
+    &sDecorSelectorOam,
+    sDecorSelectorAnims,
+    &sDecorSelectorSpriteFrameImages,
+    gDummySpriteAffineAnimTable,
+    SpriteCallbackDummy
+};
+
+const struct SpriteTemplate sDecorWhilePlacingSpriteTemplate = {
+    0x0000,
+    0x0000,
+    &sDecorSelectorOam,
+    sDecorSelectorAnims,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCallbackDummy
+};
+
+const struct SpritePalette gUnknown_085A72BC = {
+    (const u16 *)&sPlaceDecorationGraphicsDataBuffer.palette, OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG
+};
+
+const struct YesNoFuncTable gUnknown_085A72C4 = {
+    sub_81289F0,
+    sub_8128FD8
+};
+
+const struct YesNoFuncTable gUnknown_085A72CC = {
+    sub_8128BA0,
+    sub_8128FD8
+};
+
+const struct YesNoFuncTable gUnknown_085A72D4[] = {
+    {
+        sub_81283BC,
+        sub_8128414
+    }, {
+        sub_8129BCC,
+        sub_8129BF8
+    }
+};
+
+const u8 gUnknown_085A72E4[] = {
+    0x04, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x00
+};
+
+const u8 gUnknown_085A72EC[] = {
+    0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x03, 0x00
+};
+
+const u16 gUnknown_085A72F4[] = {
+    0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x20
+};
+
+const u16 Unknown_085A7308[] = INCBIN_U16("graphics/decorations/unk_85a7308.gbapal");
+
+const u16 Unknown_085A7328[] = INCBIN_U16("graphics/decorations/unk_85a7328.gbapal");
+
+const struct YesNoFuncTable gUnknown_085A7348 = {
+    sub_812A1C0,
+    sub_8129B34
+};
+
+const struct YesNoFuncTable gUnknown_085A7350 = {
+    sub_812A210,
+    sub_8129B34
+};
+
+const u8 Unknown_085A7358[] = INCBIN_U8("graphics/misc/decoration_unk_85a7358.4bpp");
+
+const struct SpritePalette gUnknown_085A73D8 = {
+    Unknown_085A7308, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG
+};
+
+const struct SpritePalette gUnknown_085A73E0 = {
+    Unknown_085A7328, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG
+};
+
+const struct OamData Unknown_085A73E8 = {
+    .size = 1, .priority = 1
+};
+
+const union AnimCmd Unknown_085A73F0[] = {
+    ANIMCMD_FRAME(0, 0, 0),
+    ANIMCMD_END
+};
+
+const union AnimCmd *const Unknown_085A73F8[] = {
+    Unknown_085A73F0
+};
+
+const struct SpriteFrameImage Unknown_085A73FC = {
+    Unknown_085A7358, 0x80
+};
+
+const struct SpriteTemplate gUnknown_085A7404 = {
+    0xFFFF,
+    OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG,
+    &Unknown_085A73E8,
+    Unknown_085A73F8,
+    &Unknown_085A73FC,
+    gDummySpriteAffineAnimTable,
+    sub_812A36C
+};
+
+const struct YesNoFuncTable gUnknown_085A741C = {
+    sub_812A478,
+    sub_8127A30
+};
+
+// .text
+
+void sub_8126968(void)
+{
+    if (sCurDecorationCategory < 8)
+    {
+        gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items;
+    }
+    if (gUnknown_0203A17C.isPlayerRoom == FALSE)
+    {
+        gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations;
+        gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos;
+    }
+    if (gUnknown_0203A17C.isPlayerRoom == TRUE)
+    {
+        gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor;
+        gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos;
+    }
+}
+
+u8 sub_81269D4(u8 idx)
+{
+    u8 *winidx;
+    struct WindowTemplate template;
+
+    winidx = &sDecorMenuWindowIndices[idx];
+    if (idx == 0)
+    {
+        template = gUnknown_085A6B90[0];
+        template.width = GetMaxWidthInMenuTable(sSecretBasePCMenuActions, 4);
+        if (template.width > 18)
+        {
+            template.width = 18;
+        }
+        *winidx = AddWindow(&template);
+    }
+    else
+    {
+        *winidx = AddWindow(&gUnknown_085A6B90[idx]);
+    }
+    SetWindowBorderStyle(*winidx, 0, 0x214, 0xe);
+    schedule_bg_copy_tilemap_to_vram(0);
+    return *winidx;
+}
+
+void sub_8126A58(u8 idx)
+{
+    sub_8198070(sDecorMenuWindowIndices[idx], FALSE);
+    ClearWindowTilemap(sDecorMenuWindowIndices[idx]);
+    RemoveWindow(sDecorMenuWindowIndices[idx]);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_8126A88(void)
+{
+    u8 idx;
+
+    idx = sub_81269D4(0);
+    PrintMenuTable(idx, 4, sSecretBasePCMenuActions);
+    InitMenuInUpperLeftCornerPlaySoundWhenAPressed(idx, 4, sSecretBasePCMenuCursorPos);
+}
+
+void sub_8126ABC(void)
+{
+    sSecretBasePCMenuCursorPos = 0;
+    ScriptContext2_Enable();
+    sub_8126A88();
+    sub_8126C08();
+}
+
+void sub_8126AD8(u8 taskId)
+{
+    sub_8126ABC();
+    gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations;
+    gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos;
+    gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->secretBases[0].decorations);
+    gUnknown_0203A17C.isPlayerRoom = FALSE;
+    gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8126B2C(u8 taskId)
+{
+    sub_8126ABC();
+    gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor;
+    gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos;
+    gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->playerRoomDecor);
+    gUnknown_0203A17C.isPlayerRoom = TRUE;
+    gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8126B80(u8 taskId)
+{
+    u8 menuPos;
+
+    if (!gPaletteFade.active)
+    {
+        menuPos = GetMenuCursorPos();
+        switch (ProcessMenuInput())
+        {
+            default:
+                PlaySE(SE_SELECT);
+                sSecretBasePCMenuActions[sSecretBasePCMenuCursorPos].func.void_u8(taskId);
+                break;
+            case -2:
+                sSecretBasePCMenuCursorPos = GetMenuCursorPos();
+                if ((s8)menuPos != sSecretBasePCMenuCursorPos)
+                {
+                    sub_8126C08();
+                }
+                break;
+            case -1:
+                PlaySE(SE_SELECT);
+                SecretBasePC_Cancel(taskId);
+                break;
+        }
+    }
+}
+
+void sub_8126C08(void)
+{
+    FillWindowPixelBuffer(0, 0x11);
+    AddTextPrinterParametrized(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3);
+}
+
+void SecretBasePC_Decorate(u8 taskId)
+{
+    if (CountDecorations() == 0)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+    }
+    else
+    {
+        gTasks[taskId].data[11] = 0;
+        sCurDecorationCategory = DECORCAT_DESK;
+        SecretBasePC_PrepMenuForSelectingStoredDecors(taskId);
+    }
+}
+
+void SecretBasePC_PutAway(u8 taskId)
+{
+    if (!sub_81299AC(taskId))
+    {
+        StringExpandPlaceholders(gStringVar4, gText_NoDecorationsInUse);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+    }
+    else
+    {
+        sub_8126A58(0);
+        sub_8197434(0, 0);
+        fade_screen(1, 0);
+        gTasks[taskId].data[2] = 0;
+        gTasks[taskId].func = sub_8129ABC;
+    }
+}
+
+void SecretBasePC_Toss(u8 taskId)
+{
+    if (CountDecorations() == 0)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+    }
+    else
+    {
+        gTasks[taskId].data[11] = 1;
+        sCurDecorationCategory = DECORCAT_DESK;
+        SecretBasePC_PrepMenuForSelectingStoredDecors(taskId);
+    }
+}
+
+void SecretBasePC_Cancel(u8 taskId)
+{
+    sub_8126A58(0);
+    if (!gUnknown_0203A17C.isPlayerRoom)
+    {
+        ScriptContext1_SetupScript(gUnknown_0823B4E8);
+        DestroyTask(taskId);
+    }
+    else
+    {
+        sub_816B060(taskId);
+    }
+}
+
+void sub_8126DA4(u8 taskId)
+{
+    sub_8126C08();
+    gTasks[taskId].func = sub_8126B80;
+}
+
+void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId)
+{
+    LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20);
+    sub_8197434(0, 0);
+    sub_8126A58(0);
+    sub_8126DFC(taskId);
+}
+
+void sub_8126DFC(u8 taskId)
+{
+    u8 winIdx;
+
+    winIdx = sub_81269D4(1);
+    sub_8126E8C(taskId);
+    InitMenuInUpperLeftCornerPlaySoundWhenAPressed(winIdx, 9, sCurDecorationCategory);
+    gTasks[taskId].func = sub_8127088;
+}
+
+void sub_8126E44(u8 taskId)
+{
+    FillWindowPixelBuffer(sDecorMenuWindowIndices[1], 0x11);
+    sub_8126E8C(taskId);
+    InitMenuInUpperLeftCornerPlaySoundWhenAPressed(sDecorMenuWindowIndices[1], 9, sCurDecorationCategory);
+    gTasks[taskId].func = sub_8127088;
+}
+
+void sub_8126E8C(u8 taskId)
+{
+    s16 *data;
+    u8 r5;
+    bool8 r8;
+    u8 i;
+    bool8 fl;
+
+    data = gTasks[taskId].data;
+    r5 = sDecorMenuWindowIndices[1];
+    fl = gUnknown_0203A17C.isPlayerRoom;
+    r8 = FALSE;
+    if (fl == TRUE && data[11] == 0)
+    {
+        r8 = TRUE;
+    }
+    for (i = 0; i < 8; i ++)
+    {
+        if (r8 == TRUE && i != DECORCAT_DOLL && i != DECORCAT_CUSHION)
+        {
+            sub_8126F68(r5, i, 8, i << 4, TRUE, 0xFF);
+        }
+        else
+        {
+            sub_8126F68(r5, i, 8, i << 4, FALSE, 0xFF);
+        }
+    }
+    PrintTextOnWindow(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed)
+{
+    u8 width;
+    u8 *strbuf;
+
+    width = x == 8 ? 0x68 : 0x60;
+    y ++;
+    sub_8127058(gStringVar4, flag);
+    strbuf = StringLength(gStringVar4) + gStringVar4;
+    StringCopy(strbuf, sDecorCatNames[decorCat]);
+    PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+    strbuf = ConvertIntToDecimalStringN(strbuf, CountDecorationCategoryN(decorCat), STR_CONV_MODE_RIGHT_ALIGN, 2);
+    *strbuf++ = CHAR_SLASH;
+    ConvertIntToDecimalStringN(strbuf, gDecorationInventories[decorCat].size, STR_CONV_MODE_RIGHT_ALIGN, 2);
+    x = GetStringRightAlignXOffset(1, gStringVar4, width);
+    PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+}
+
+void sub_8127058(u8 *str, bool8 flag)
+{
+    StringCopy(str, gText_Color161Shadow161);
+    if (flag == TRUE)
+    {
+        str[2] = 0x04; // RED
+        str[5] = 0x05; // LIGHT_RED
+    }
+    else
+    {
+        str[2] = 0x02; // DARK_GREY
+        str[5] = 0x03; // LIGHT_GREY
+    }
+}
+
+void sub_8127088(u8 taskId)
+{
+    s8 input;
+
+    if (!gPaletteFade.active)
+    {
+        input = ProcessMenuInput();
+        switch (input)
+        {
+            case -1:
+            case 8:
+                PlaySE(SE_SELECT);
+                sub_812719C(taskId);
+                break;
+            case -2:
+                break;
+            default:
+                PlaySE(SE_SELECT);
+                sCurDecorationCategory = input;
+                sub_81270E8(taskId);
+                break;
+        }
+    }
+}
+
+void sub_81270E8(u8 taskId)
+{
+    sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory);
+    if (sCurDecorCatCount != 0)
+    {
+        CondenseDecorationCategoryN(sCurDecorationCategory);
+        gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items;
+        IdentifyOwnedDecorationsCurrentlyInUse(taskId);
+        sSecretBasePCSelectDecorPageNo = 0;
+        sSecretBasePCSelectDecorLineNo = 0;
+        gTasks[taskId].func = sub_8127620;
+    }
+    else
+    {
+        sub_8126A58(1);
+        StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8127180);
+    }
+}
+
+void sub_8127180(u8 taskId)
+{
+    sub_8197434(0, 0);
+    sub_8126DFC(taskId);
+}
+
+void sub_812719C(u8 taskId)
+{
+    if (gTasks[taskId].data[11] != 2)
+    {
+        sub_81271CC(taskId);
+    }
+    else
+    {
+        sub_8127268(taskId);
+    }
+}
+
+void sub_81271CC(u8 taskId)
+{
+    sub_8126A58(1);
+    sub_8126A88();
+    sub_81973C4(0, 0);
+    sub_8126C08();
+    gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8127208(u8 taskId)
+{
+    LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20);
+    sub_8197434(0, 0);
+    gTasks[taskId].data[11] = 2;
+    sCurDecorationCategory = DECORCAT_DESK;
+    sub_8126DFC(taskId);
+}
+
+void sub_8127250(u8 *dest, u8 decorCat)
+{
+    StringCopy(dest, sDecorCatNames[decorCat]);
+}
+
+void sub_8127268(u8 taskId)
+{
+    sub_8126A58(1);
+    sub_8133E1C(taskId);
+}
+
+void sub_8127284(void)
+{
+    sDecorPCBuffer->unk_520 = sCurDecorCatCount + 1;
+    if (sDecorPCBuffer->unk_520 > 8)
+    {
+        sDecorPCBuffer->unk_521 = 8;
+    }
+    else
+    {
+        sDecorPCBuffer->unk_521 = sDecorPCBuffer->unk_520;
+    }
+}
+
+void sub_81272C8(void)
+{
+    sub_812225C(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520);
+}
+
+void sub_81272F8(void)
+{
+    sub_8122298(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520, 8);
+}
+
+void sub_8127330(u8 taskId)
+{
+    s16 *data;
+    u16 i;
+
+    data = gTasks[taskId].data;
+    if ((sCurDecorationCategory < DECORCAT_DOLL || sCurDecorationCategory > DECORCAT_CUSHION) && gUnknown_0203A17C.isPlayerRoom == TRUE && data[11] == 0)
+    {
+        sub_8127058(gStringVar1, TRUE);
+    }
+    else
+    {
+        sub_8127058(gStringVar1, FALSE);
+    }
+    for (i = 0; i < sDecorPCBuffer->unk_520 - 1; i ++)
+    {
+        sub_8127454(sDecorPCBuffer->names[i], gCurDecorInventoryItems[i]);
+        sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i];
+        sDecorPCBuffer->items[i].unk_04 = i;
+    }
+    StringCopy(sDecorPCBuffer->names[i], gText_Cancel);
+    sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i];
+    sDecorPCBuffer->items[i].unk_04 = -2;
+    gUnknown_03006310 = gUnknown_085A6BD0;
+    gUnknown_03006310.unk_10 = sDecorMenuWindowIndices[1];
+    gUnknown_03006310.unk_0c = sDecorPCBuffer->unk_520;
+    gUnknown_03006310.unk_00 = sDecorPCBuffer->items;
+    gUnknown_03006310.unk_0e = sDecorPCBuffer->unk_521;
+}
+
+void sub_8127454(u8 *dest, u16 decorId)
+{
+    StringCopy(dest, gStringVar1);
+    StringAppend(dest, gDecorations[decorId].name);
+}
+
+void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu)
+{
+    if (flag != TRUE)
+    {
+        PlaySE(SE_SELECT);
+    }
+    sub_8127744(a0);
+}
+
+void sub_81274A0(u8 a0, s32 a1, u8 a2)
+{
+    if (a1 != -2)
+    {
+        if (sub_81277BC(a1 + 1) == TRUE)
+        {
+            blit_move_info_icon(a0, 0x18, 0x5c, a2 + 2);
+        }
+        else if (sub_81277E8(a1 + 1) == TRUE)
+        {
+            blit_move_info_icon(a0, 0x19, 0x5c, a2 + 2);
+        }
+    }
+}
+
+void sub_8127500(void)
+{
+    if (sDecorPCBuffer->unk_522 == 0xFF)
+    {
+        sDecorPCBuffer->unk_522 = AddScrollIndicatorArrowPairParametrized(0x02, 0x3c, 0x0c, 0x94, sDecorPCBuffer->unk_520 - sDecorPCBuffer->unk_521, 0x6e, 0x6e, &sSecretBasePCSelectDecorPageNo);
+    }
+}
+
+void sub_8127554(void)
+{
+    if (sDecorPCBuffer->unk_522 != 0xFF)
+    {
+        RemoveScrollIndicatorArrowPair(sDecorPCBuffer->unk_522);
+        sDecorPCBuffer->unk_522 = 0xFF;
+    }
+}
+
+void sub_8127580(u8 taskId)
+{
+    sub_81269D4(1);
+    sub_812759C(taskId);
+}
+
+void sub_812759C(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    sub_81269D4(3);
+    sub_8127718(sCurDecorationCategory);
+    sDecorPCBuffer = calloc(1, sizeof(struct DecorPCBuffer));
+    sDecorPCBuffer->unk_522 = 0xFF;
+    sub_8127284();
+    sub_81272C8();
+    sub_81272F8();
+    sub_8127330(taskId);
+    data[13] = ListMenuInit(&gUnknown_03006310, sSecretBasePCSelectDecorPageNo, sSecretBasePCSelectDecorLineNo);
+    sub_8127500();
+}
+
+void sub_8127620(u8 taskId)
+{
+    sub_812759C(taskId);
+    gTasks[taskId].func = sub_812764C;
+}
+
+void sub_812764C(u8 taskId)
+{
+    s16 *data;
+    s32 input;
+
+    data = gTasks[taskId].data;
+    if (!gPaletteFade.active)
+    {
+        input = ListMenuHandleInput(data[13]);
+        get_coro_args_x18_x1A(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo);
+        switch (input)
+        {
+            case -1:
+                break;
+            case -2:
+                PlaySE(SE_SELECT);
+                SecretBasePC_SelectedDecorActions[data[11]][1](taskId);
+                break;
+            default:
+                PlaySE(SE_SELECT);
+                gCurDecorationIndex = input;
+                sub_8127554();
+                sub_81AE6C8(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo);
+                sub_8126A58(1);
+                sub_81277A8();
+                free(sDecorPCBuffer);
+                SecretBasePC_SelectedDecorActions[data[11]][0](taskId);
+                break;
+        }
+    }
+}
+
+void sub_8127718(u8 decorCat)
+{
+    sub_8126F68(sub_81269D4(2), decorCat, 0, 0, 0, 0);
+}
+
+void sub_8127744(u32 a0)
+{
+    u8 winidx;
+    const u8 *txt;
+
+    winidx = sDecorMenuWindowIndices[3];
+    FillWindowPixelBuffer(winidx, 0x11);
+    if (a0 >= sCurDecorCatCount)
+    {
+        txt = gText_GoBackPrevMenu;
+    }
+    else
+    {
+        txt = gDecorations[gCurDecorInventoryItems[a0]].description;
+    }
+    PrintTextOnWindow(winidx, 1, txt, 0, 1, 0, 0);
+}
+
+void sub_81277A8(void)
+{
+    sub_8126A58(3);
+    sub_8126A58(2);
+}
+
+bool8 sub_81277BC(u8 idx)
+{
+    u8 i;
+
+    for (i = 0; i < 16; i ++)
+    {
+        if (sSecretBaseItemsIndicesBuffer[i] == idx)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 sub_81277E8(u8 idx)
+{
+    u8 i;
+
+    for (i = 0; i < 12; i ++)
+    {
+        if (sPlayerRoomItemsIndicesBuffer[i] == idx)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void IdentifyOwnedDecorationsCurrentlyInUseInternal(u8 taskId)
+{
+    u16 i;
+    u16 j;
+    u16 k;
+    u16 cnt;
+
+    cnt = 0;
+    memset(sSecretBaseItemsIndicesBuffer, 0, 16);
+    memset(sPlayerRoomItemsIndicesBuffer, 0, 12);
+    for (i = 0; i < 16; i ++)
+    {
+        if (gSaveBlock1Ptr->secretBases[0].decorations[i] != DECOR_NONE)
+        {
+            for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++)
+            {
+                if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->secretBases[0].decorations[i])
+                {
+                    for (k = 0; k < cnt && sSecretBaseItemsIndicesBuffer[k] != j + 1; k ++);
+                    if (k == cnt)
+                    {
+                        sSecretBaseItemsIndicesBuffer[cnt] = j + 1;
+                        cnt ++;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    cnt = 0;
+    for (i = 0; i < 12; i ++)
+    {
+        if (gSaveBlock1Ptr->playerRoomDecor[i] != DECOR_NONE)
+        {
+            for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++)
+            {
+                if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->playerRoomDecor[i] && sub_81277BC(j + 1) != TRUE)
+                {
+                    for (k = 0; k < cnt && sPlayerRoomItemsIndicesBuffer[k] != j + 1; k ++);
+                    if (k == cnt)
+                    {
+                        sPlayerRoomItemsIndicesBuffer[cnt] = j + 1;
+                        cnt ++;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId)
+{
+    IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+}
+
+bool8 IsSelectedDecorInThePC(void)
+{
+    u16 i;
+    for (i = 0; i < 16; i ++)
+    {
+        if (sSecretBaseItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1)
+        {
+            return FALSE;
+        }
+        if (i < 12 && sPlayerRoomItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1)
+        {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+void sub_8127A14(u8 taskId)
+{
+    sub_81269D4(1);
+    sub_8127620(taskId);
+}
+
+void sub_8127A30(u8 taskId)
+{
+    sub_8197434(0, 0);
+    gTasks[taskId].func = sub_8127A14;
+}
+
+void sub_8127A5C(u8 taskId)
+{
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+    {
+        sub_8197434(0, 0);
+        sub_81269D4(1);
+        sub_8127620(taskId);
+    }
+}
+
+void sub_8127A8C(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    sub_8127554();
+    sub_81277A8();
+    sub_81AE6C8(data[13], NULL, NULL);
+    free(sDecorPCBuffer);
+    sub_8126E44(taskId);
+}
+
+void sub_8127ACC(u8 taskId)
+{
+    gTasks[taskId].data[3] = gSaveBlock1Ptr->pos.x;
+    gTasks[taskId].data[4] = gSaveBlock1Ptr->pos.y;
+    PlayerGetDestCoords(&gTasks[taskId].data[0], &gTasks[taskId].data[1]);
+}
+
+void sub_8127B04(u8 taskId)
+{
+    DrawWholeMapView();
+    Overworld_SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, gTasks[taskId].data[3], gTasks[taskId].data[4]);
+    warp_in();
+}
+
+u16 sub_8127B54(u8 decor, u8 a1)
+{
+    u16 resp;
+
+    resp = -1;
+    switch (decor)
+    {
+        case DECOR_STAND:
+            resp = gUnknown_085A72E4[a1] << 12;
+            return resp;
+        case DECOR_SLIDE:
+            resp = gUnknown_085A72EC[a1] << 12;
+            return resp;
+        default:
+            return resp;
+    }
+}
+
+void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor)
+{
+    u16 i;
+    u16 j;
+    u16 behavior;
+    u16 flags;
+    u16 v0;
+    u16 v1;
+    s16 decLeft;
+    s16 decBottom;
+
+    for (i = 0; i < decHeight; i ++)
+    {
+        decBottom = mapY - decHeight + 1 + i;
+        for (j = 0; j < decWidth; j ++)
+        {
+            decLeft = mapX + j;
+            behavior = GetBehaviorByMetatileId(0x200 + gDecorations[decor].tiles[i * decWidth + j]);
+            if (MetatileBehavior_IsMB_B9(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12)))
+            {
+                flags = 0xc00;
+            }
+            else
+            {
+                flags = 0x000;
+            }
+            if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE)
+            {
+                v0 = 1;
+            }
+            else
+            {
+                v0 = 0;
+            }
+            v1 = sub_8127B54(gDecorations[decor].id, i * decWidth + j);
+            if (v1 != 0xFFFF)
+            {
+                MapGridSetMetatileEntryAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags | v1);
+            }
+            else
+            {
+                MapGridSetMetatileIdAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags);
+            }
+        }
+    }
+}
+
+void sub_8127D38(u16 mapX, u16 mapY, u16 decor)
+{
+    switch (gDecorations[decor].shape)
+    {
+        case DECORSHAPE_1x1:
+            sub_8127B90(mapX, mapY, 1, 1, decor);
+            break;
+        case DECORSHAPE_2x1:
+            sub_8127B90(mapX, mapY, 2, 1, decor);
+            break;
+        case DECORSHAPE_3x1: // unused
+            sub_8127B90(mapX, mapY, 3, 1, decor);
+            break;
+        case DECORSHAPE_4x2:
+            sub_8127B90(mapX, mapY, 4, 2, decor);
+            break;
+        case DECORSHAPE_2x2:
+            sub_8127B90(mapX, mapY, 2, 2, decor);
+            break;
+        case DECORSHAPE_1x2:
+            sub_8127B90(mapX, mapY, 1, 2, decor);
+            break;
+        case DECORSHAPE_1x3: // unused
+            sub_8127B90(mapX, mapY, 1, 3, decor);
+            break;
+        case DECORSHAPE_2x4:
+            sub_8127B90(mapX, mapY, 2, 4, decor);
+            break;
+        case DECORSHAPE_3x3:
+            sub_8127B90(mapX, mapY, 3, 3, decor);
+            break;
+        case DECORSHAPE_3x2:
+            sub_8127B90(mapX, mapY, 3, 2, decor);
+            break;
+    }
+}
+
+void sub_8127E18(void)
+{
+    u8 i;
+    u8 j;
+
+    for (i = 0; i < 14; i ++)
+    {
+        if (FlagGet(0xAE + i) == TRUE)
+        {
+            FlagClear(0xAE + i);
+            for (j = 0; j < gMapHeader.events->mapObjectCount; j ++)
+            {
+                if (gMapHeader.events->mapObjects[j].flagId == 0xAE + i)
+                {
+                    break;
+                }
+            }
+            VarSet(0x3F20 + gMapHeader.events->mapObjects[j].graphicsId, sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0]);
+            gSpecialVar_0x8005 = gMapHeader.events->mapObjects[j].localId;
+            gSpecialVar_0x8006 = sCurDecorMapX;
+            gSpecialVar_0x8007 = sCurDecorMapY;
+            show_sprite(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+            sub_808EBA8(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gSpecialVar_0x8006, gSpecialVar_0x8007);
+            sub_808F254(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+            break;
+        }
+    }
+}
+
+bool8 sub_8127F38(void)
+{
+    u16 i;
+
+    for (i = 0; i < gUnknown_0203A17C.size; i ++)
+    {
+        if (gUnknown_0203A17C.items[i] == DECOR_NONE)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void sub_8127F68(u8 taskId)
+{
+    if (gUnknown_0203A17C.isPlayerRoom == TRUE && sCurDecorationCategory != DECORCAT_DOLL && sCurDecorationCategory != DECORCAT_CUSHION)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_CantPlaceInRoom);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+    }
+    else if (IsSelectedDecorInThePC() == TRUE)
+    {
+        if (sub_8127F38() == TRUE)
+        {
+            fade_screen(1, 0);
+            gTasks[taskId].data[2] = 0;
+            gTasks[taskId].func = sub_8128060;
+        }
+        else
+        {
+            ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203A17C.size, STR_CONV_MODE_RIGHT_ALIGN, 2);
+            if (gUnknown_0203A17C.isPlayerRoom == FALSE) {
+                StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations);
+            }
+            else
+            {
+                StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations2);
+            }
+            DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+        }
+    }
+    else
+    {
+        StringExpandPlaceholders(gStringVar4, gText_InUseAlready);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+    }
+}
+
+void sub_8128060(u8 taskId)
+{
+    switch (gTasks[taskId].data[2])
+    {
+        case 0:
+            if (!gPaletteFade.active)
+            {
+                sub_8127ACC(taskId);
+                gTasks[taskId].data[2] = 1;
+            }
+            break;
+        case 1:
+            gPaletteFade.bufferTransferDisabled = TRUE;
+            ConfigureCameraObjectForPlacingDecoration(&sPlaceDecorationGraphicsDataBuffer, gCurDecorInventoryItems[gCurDecorationIndex]);
+            sub_812826C(taskId);
+            SetUpPlacingDecorationPlayerAvatar(taskId, &sPlaceDecorationGraphicsDataBuffer);
+            pal_fill_black();
+            gPaletteFade.bufferTransferDisabled = FALSE;
+            gTasks[taskId].data[2] = 2;
+            break;
+        case 2:
+            if (sub_80ABDFC() == TRUE)
+            {
+                gTasks[taskId].data[12] = 0;
+                sub_8128FD8(taskId);
+            }
+            break;
+    }
+}
+
+void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor)
+{
+    sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0;
+    gUnknown_03005DD0.unk4 = gpu_pal_decompress_alloc_tag_and_upload(data, decor);
+    gSprites[gUnknown_03005DD0.unk4].oam.priority = 1;
+    gSprites[gUnknown_03005DD0.unk4].callback = sub_81292D0;
+    gSprites[gUnknown_03005DD0.unk4].pos1.x = gUnknown_085A7250[data->decoration->shape].x;
+    gSprites[gUnknown_03005DD0.unk4].pos1.y = gUnknown_085A7250[data->decoration->shape].y;
+}
+
+void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data)
+{
+    u8 v0;
+
+    v0 = 16 * (u8)gTasks[taskId].data[5] + gUnknown_085A7250[data->decoration->shape].x - 8 * ((u8)gTasks[taskId].data[5] - 1);
+    if (data->decoration->shape == DECORSHAPE_3x1 || data->decoration->shape == DECORSHAPE_3x3 || data->decoration->shape == DECORSHAPE_3x2)
+    {
+        v0 -= 8;
+    }
+    if (gSaveBlock2Ptr->playerGender == MALE)
+    {
+        sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, v0, 0x48, 0);
+    }
+    else
+    {
+        sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, v0, 0x48, 0);
+    }
+    gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1;
+    DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]);
+    sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4;
+}
+
+void sub_812826C(u8 taskId)
+{
+    switch (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].shape)
+    {
+        case DECORSHAPE_1x1:
+            gTasks[taskId].data[5] = 1;
+            gTasks[taskId].data[6] = 1;
+            break;
+        case DECORSHAPE_2x1:
+            gTasks[taskId].data[5] = 2;
+            gTasks[taskId].data[6] = 1;
+            break;
+        case DECORSHAPE_3x1:
+            gTasks[taskId].data[5] = 3;
+            gTasks[taskId].data[6] = 1;
+            break;
+        case DECORSHAPE_4x2:
+            gTasks[taskId].data[5] = 4;
+            gTasks[taskId].data[6] = 2;
+            break;
+        case DECORSHAPE_2x2:
+            gTasks[taskId].data[5] = 2;
+            gTasks[taskId].data[6] = 2;
+            break;
+        case DECORSHAPE_1x2:
+            gTasks[taskId].data[5] = 1;
+            gTasks[taskId].data[6] = 2;
+            break;
+        case DECORSHAPE_1x3:
+            gTasks[taskId].data[5] = 1;
+            gTasks[taskId].data[6] = 3;
+            gTasks[taskId].data[1]++;
+            break;
+        case DECORSHAPE_2x4:
+            gTasks[taskId].data[5] = 2;
+            gTasks[taskId].data[6] = 4;
+            break;
+        case DECORSHAPE_3x3:
+            gTasks[taskId].data[5] = 3;
+            gTasks[taskId].data[6] = 3;
+            break;
+        case DECORSHAPE_3x2:
+            gTasks[taskId].data[5] = 3;
+            gTasks[taskId].data[6] = 2;
+            break;
+    }
+}
+
+void sub_81283BC(u8 taskId)
+{
+    gTasks[taskId].data[10] = 0;
+    gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1;
+    gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1;
+    sub_8128DE0();
+    sub_8128950(taskId);
+}
+
+void sub_8128414(u8 taskId)
+{
+    gTasks[taskId].data[10] = 0;
+    gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1;
+    gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1;
+    sub_8128DE0();
+    StringExpandPlaceholders(gStringVar4, gText_CancelDecorating);
+    DisplayItemMessageOnField(taskId, gStringVar4, sub_8128B80);
+}
+
+bool8 sub_8128484(u8 behaviorAt, u16 behaviorBy)
+{
+    if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE || behaviorBy != 0)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+bool8 sub_81284AC(u8 taskId, s16 x, s16 y, u16 decor)
+{
+    if (x == gTasks[taskId].data[3] + 7 && y == gTasks[taskId].data[4] + 7 && decor != DECOR_NONE)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+bool8 sub_81284F4(u16 behaviorAt, const struct Decoration *decoration)
+{
+    if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE)
+    {
+        if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsMB_C2(behaviorAt) == TRUE)
+        {
+            return TRUE;
+        }
+        if (MetatileBehavior_IsNormal(behaviorAt))
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 sub_812853C(u8 taskId, const struct Decoration *decoration)
+{
+    u8 i;
+    u8 j;
+    u8 behaviorAt;
+    u16 behaviorBy;
+    u8 mapY;
+    u8 mapX;
+    s16 curY;
+    s16 curX;
+    mapY = gTasks[taskId].data[6];
+    mapX = gTasks[taskId].data[5];
+
+    switch (decoration->permission)
+    {
+        case DECORPERM_SOLID_FLOOR:
+        case DECORPERM_PASS_FLOOR:
+            for (i=0; i<mapY; i++)
+            {
+                curY = gTasks[taskId].data[1] - i;
+                for (j=0; j<mapX; j++)
+                {
+                    curX = gTasks[taskId].data[0] + j;
+                    behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+                    behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[(mapY - 1 - i) * mapX + j]) & 0xf000;
+                    if (!sub_81284F4(behaviorAt, decoration))
+                    {
+                        return FALSE;
+                    }
+                    if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+                    {
+                        return FALSE;
+                    }
+                    behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0);
+                    if (behaviorAt != 0 && behaviorAt != 16)
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            break;
+        case DECORPERM_BEHIND_FLOOR:
+            for (i=0; i<mapY-1; i++)
+            {
+                curY = gTasks[taskId].data[1] - i;
+                for (j=0; j<mapX; j++)
+                {
+                    curX = gTasks[taskId].data[0] + j;
+                    behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+                    behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[(mapY - 1 - i) * mapX + j]) & 0xf000;
+                    if (!MetatileBehavior_IsNormal(behaviorAt) && !sub_8128484(behaviorAt, behaviorBy))
+                    {
+                        return FALSE;
+                    }
+                    if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+                    {
+                        return FALSE;
+                    }
+                    if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16)
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            curY = gTasks[taskId].data[1] - mapY + 1;
+            for (j=0; j<mapX; j++)
+            {
+                curX = gTasks[taskId].data[0] + j;
+                behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+                behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[j]) & 0xf000;
+                if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsMB_B7(behaviorAt))
+                {
+                    return FALSE;
+                }
+                if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+                {
+                    return FALSE;
+                }
+                behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0);
+                if (behaviorAt != 0 && behaviorAt != 16)
+                {
+                    return FALSE;
+                }
+            }
+            break;
+        case DECORPERM_NA_WALL:
+            for (i=0; i<mapY; i++)
+            {
+                curY = gTasks[taskId].data[1] - i;
+                for (j=0; j<mapX; j++)
+                {
+                    curX = gTasks[taskId].data[0] + j;
+                    if (!MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(curX, curY)))
+                    {
+                        return FALSE;
+                    }
+                    if (MapGridGetMetatileIdAt(curX, curY + 1) == 0x28c)
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            break;
+        case DECORPERM_SOLID_MAT:
+            curY = gTasks[taskId].data[1];
+            for (j=0; j<mapX; j++)
+            {
+                curX = gTasks[taskId].data[0] + j;
+                behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+                if (decoration->shape == DECORSHAPE_1x2)
+                {
+                    if (!MetatileBehavior_IsMB_C3(behaviorAt))
+                    {
+                        return FALSE;
+                    }
+                }
+                else if (!MetatileBehavior_IsMB_B5(behaviorAt))
+                {
+                    if (!MetatileBehavior_IsMB_C3(behaviorAt))
+                    {
+                        return FALSE;
+                    }
+                }
+                if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16)
+                {
+                    return FALSE;
+                }
+            }
+            break;
+    }
+    return TRUE;
+}
+
+void sub_8128950(u8 taskId)
+{
+    if (sub_812853C(taskId, &gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]]) == TRUE)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_PlaceItHere);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_81289D0);
+    }
+    else
+    {
+        PlaySE(SE_HAZURE);
+        StringExpandPlaceholders(gStringVar4, gText_CantBePlacedHere);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8129020);
+    }
+}
+
+void sub_81289D0(u8 taskId)
+{
+    sub_8197930();
+    sub_8121F68(taskId, &gUnknown_085A72C4);
+}
+
+void sub_81289F0(u8 taskId)
+{
+    sub_8197434(0, 0);
+    sub_8128AAC(taskId);
+    if (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].permission != DECORPERM_SOLID_MAT)
+    {
+        sub_8127D38(gTasks[taskId].data[0], gTasks[taskId].data[1], gCurDecorInventoryItems[gCurDecorationIndex]);
+    }
+    else
+    {
+        sCurDecorMapX = gTasks[taskId].data[0] - 7;
+        sCurDecorMapY = gTasks[taskId].data[1] - 7;
+        ScriptContext1_SetupScript(gUnknown_08275D1F);
+    }
+    gSprites[sDecor_CameraSpriteObjectIdx1].pos1.y += 2;
+    if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+    {
+        TV_PutSecretBaseVisitOnTheAir();
+    }
+    sub_8128BBC(taskId);
+}
+
+void sub_8128AAC(u8 taskId)
+{
+    u16 i;
+
+    for (i = 0; i < gUnknown_0203A17C.size; i ++)
+    {
+        if (gUnknown_0203A17C.items[i] == DECOR_NONE)
+        {
+            gUnknown_0203A17C.items[i] = gCurDecorInventoryItems[gCurDecorationIndex];
+            gUnknown_0203A17C.pos[i] = ((gTasks[taskId].data[0] - 7) << 4) + (gTasks[taskId].data[1] - 7);
+            break;
+        }
+    }
+    if (!gUnknown_0203A17C.isPlayerRoom)
+    {
+        for (i = 0; i < 16; i ++)
+        {
+            if (sSecretBaseItemsIndicesBuffer[i] == 0)
+            {
+                sSecretBaseItemsIndicesBuffer[i] = gCurDecorationIndex + 1;
+                break;
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < 12; i ++)
+        {
+            if (sPlayerRoomItemsIndicesBuffer[i] == 0)
+            {
+                sPlayerRoomItemsIndicesBuffer[i] = gCurDecorationIndex + 1;
+                break;
+            }
+        }
+    }
+}
+
+void sub_8128B80(u8 taskId)
+{
+    sub_8197930();
+    sub_8121F68(taskId, &gUnknown_085A72CC);
+}
+
+void sub_8128BA0(u8 taskId)
+{
+    sub_8197434(0, 0);
+    sub_8128BBC(taskId);
+}
+
+void sub_8128BBC(u8 taskId)
+{
+    fade_screen(1, 0);
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].func = c1_overworld_prev_quest;
+}
+
+void c1_overworld_prev_quest(u8 taskId)
+{
+    switch (gTasks[taskId].data[2])
+    {
+        case 0:
+            ScriptContext2_Enable();
+            if (!gPaletteFade.active)
+            {
+                sub_8127B04(taskId);
+                gTasks[taskId].data[2] = 1;
+            }
+            break;
+        case 1:
+            sub_812A3C8();
+            FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG);
+            gFieldCallback = sub_8128CD4;
+            SetMainCallback2(c2_exit_to_overworld_2_switch);
+            DestroyTask(taskId);
+            break;
+    }
+}
+
+void sub_8128C64(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    switch (data[2])
+    {
+        case 0:
+            sub_80E9578();
+            data[2] ++;
+            break;
+        case 1:
+            ScriptContext1_SetupScript(gUnknown_08275D0C);
+            data[2] ++;
+            break;
+        case 2:
+            ScriptContext2_Enable();
+            data[2] ++;
+            break;
+        case 3:
+            if (sub_80ABDFC() == TRUE)
+            {
+                gTasks[taskId].func = sub_812764C;
+            }
+            break;
+    }
+}
+
+void sub_8128CD4(void)
+{
+    u8 taskId;
+
+    ScriptContext2_Enable();
+    pal_fill_black();
+    taskId = CreateTask(sub_8128C64, 8);
+    sub_8127580(taskId);
+    gTasks[taskId].data[2] = 0;
+}
+
+bool8 sub_8128D10(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    if (sDecorationLastDirectionMoved == DIR_SOUTH && data[1] - data[6] - 6 < 0)
+    {
+        data[1] ++;
+        return FALSE;
+    }
+    if (sDecorationLastDirectionMoved == DIR_NORTH && data[1] - 7 >= gMapHeader.mapData->height)
+    {
+        data[1] --;
+        return FALSE;
+    }
+    if (sDecorationLastDirectionMoved == DIR_WEST && data[0] - 7 < 0)
+    {
+        data[0] ++;
+        return FALSE;
+    }
+    if (sDecorationLastDirectionMoved == DIR_EAST && data[0] + data[5] - 8 >= gMapHeader.mapData->width)
+    {
+        data[0] --;
+        return FALSE;
+    }
+    return TRUE;
+}
+
+bool8 sub_8128DB4(void)
+{
+    u16 heldKeys;
+
+    heldKeys = gMain.heldKeys & 0x0F0;
+    if (heldKeys != DPAD_UP && heldKeys != DPAD_DOWN && heldKeys != DPAD_LEFT && heldKeys != DPAD_RIGHT)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+void sub_8128DE0(void)
+{
+    sDecorationLastDirectionMoved = 0;
+    gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0;
+    gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0;
+}
+
+void sub_8128E18(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    if (!gSprites[sDecor_CameraSpriteObjectIdx1].data4)
+    {
+        if (data[10] == 1)
+        {
+            gUnknown_085A72D4[data[12]].yesFunc(taskId);
+            return;
+        } else if (data[10] == 2)
+        {
+            gUnknown_085A72D4[data[12]].noFunc(taskId);
+            return;
+        }
+        if ((gMain.heldKeys & 0x0F0) == DPAD_UP)
+        {
+            sDecorationLastDirectionMoved = DIR_SOUTH;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data2 =  0;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data3 = -2;
+            data[1]--;
+        }
+        if ((gMain.heldKeys & 0x0F0) == DPAD_DOWN)
+        {
+            sDecorationLastDirectionMoved = DIR_NORTH;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data2 =  0;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data3 =  2;
+            data[1]++;
+        }
+        if ((gMain.heldKeys & 0x0F0) == DPAD_LEFT)
+        {
+            sDecorationLastDirectionMoved = DIR_WEST;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data2 = -2;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data3 =  0;
+            data[0]--;
+        }
+        if ((gMain.heldKeys & 0x0F0) == DPAD_RIGHT)
+        {
+            sDecorationLastDirectionMoved = DIR_EAST;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data2 =  2;
+            gSprites[sDecor_CameraSpriteObjectIdx1].data3 =  0;
+            data[0]++;
+        }
+        if (!sub_8128DB4() || !sub_8128D10(taskId))
+        {
+            sub_8128DE0();
+        }
+    }
+    if (sDecorationLastDirectionMoved)
+    {
+        gSprites[sDecor_CameraSpriteObjectIdx1].data4++;
+        gSprites[sDecor_CameraSpriteObjectIdx1].data4 &= 7;
+    }
+    if (!data[10])
+    {
+        if (gMain.newKeys & A_BUTTON)
+        {
+            data[10] = A_BUTTON;
+        }
+        if (gMain.newKeys & B_BUTTON)
+        {
+            data[10] = B_BUTTON;
+        }
+    }
+}
+
+void sub_8128FD8(u8 taskId)
+{
+    sub_8197434(0, 1);
+    gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0;
+    gTasks[taskId].data[10] = 0;
+    gTasks[taskId].func = sub_8128E18;
+}
+
+void sub_8129020(u8 taskId)
+{
+    if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON)
+    {
+        sub_8128FD8(taskId);
+    }
+}
+
+void sub_8129048(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+    CpuFill16(0, data, sizeof(*data));
+}
+
+void sub_8129068(u16 *dest, u16 pal)
+{
+    CpuFastCopy(&((u16 *)gTilesetPointer_SecretBase->palettes)[pal << 4], dest, 32);
+}
+
+void sub_8129088(u8 *dest, u16 tile)
+{
+    u8 buffer[32];
+    u16 mode;
+    u16 i;
+
+    mode = tile >> 10;
+    if (tile != 0)
+    {
+        tile &= 0x03FF;
+    }
+    CpuFastCopy(&((u8 *)gTilesetPointer_SecretBase->tiles)[tile << 5], buffer, 32);
+    switch (mode)
+    {
+        case 0:
+            CpuFastCopy(buffer, dest, 32);
+            break;
+        case 1:
+            for (i = 0; i < 8; i ++)
+            {
+                dest[4 * i] = (buffer[4 * (i + 1) - 1] >> 4) + ((buffer[4 * (i + 1) - 1] & 0x0F) << 4);
+                dest[4 * i + 1] = (buffer[4 * (i + 1) - 2] >> 4) + ((buffer[4 * (i + 1) - 2] & 0x0F) << 4);
+                dest[4 * i + 2] = (buffer[4 * (i + 1) - 3] >> 4) + ((buffer[4 * (i + 1) - 3] & 0x0F) << 4);
+                dest[4 * i + 3] = (buffer[4 * (i + 1) - 4] >> 4) + ((buffer[4 * (i + 1) - 4] & 0x0F) << 4);
+            }
+            break;
+        case 2:
+            for (i = 0; i < 8; i ++)
+            {
+                dest[4 * i] = buffer[4 * (7 - i)];
+                dest[4 * i + 1] = buffer[4 * (7 - i) + 1];
+                dest[4 * i + 2] = buffer[4 * (7 - i) + 2];
+                dest[4 * i + 3] = buffer[4 * (7 - i) + 3];
+            }
+            break;
+        case 3:
+            for (i = 0; i < 32; i ++)
+            {
+                dest[i] = (buffer[31 - i] >> 4) + ((buffer[31 - i] & 0x0F) << 4);
+            }
+            break;
+    }
+}
+
+void sub_81291A4(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+    u16 i;
+    for (i = 0; i < 64; i ++)
+    {
+        sub_8129088(&data->image[i * 32], data->tiles[i]);
+    }
+}
+
+u16 sub_81291CC(u16 tile)
+{
+    return ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[tile] & 0xFFF;
+}
+
+void sub_81291E8(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+    u8 i;
+    u8 shape;
+
+    shape = data->decoration->shape;
+    for (i = 0; i < gUnknown_085A71B0[shape].size; i ++)
+    {
+        data->tiles[gUnknown_085A71B0[shape].tiles[i]] = sub_81291CC(data->decoration->tiles[gUnknown_085A71B0[shape].y[i]] * 8 + gUnknown_085A71B0[shape].x[i]);
+    }
+}
+
+void SetDecorSelectionBoxOamAttributes(u8 decorShape)
+{
+    sDecorSelectorOam.y = 0;
+    sDecorSelectorOam.affineMode = ST_OAM_AFFINE_OFF;
+    sDecorSelectorOam.objMode = ST_OAM_OBJ_NORMAL;
+    sDecorSelectorOam.mosaic = 0;
+    sDecorSelectorOam.bpp = ST_OAM_4BPP;
+    sDecorSelectorOam.shape = gUnknown_085A7250[decorShape].shape;
+    sDecorSelectorOam.x = 0;
+    sDecorSelectorOam.matrixNum = 0;
+    sDecorSelectorOam.size = gUnknown_085A7250[decorShape].size;
+    sDecorSelectorOam.tileNum = 0;
+    sDecorSelectorOam.priority = 0;
+    sDecorSelectorOam.paletteNum = 0;
+}
+
+void sub_81292D0(struct Sprite *sprite)
+{
+    sprite->data2 = 0;
+    sprite->data3 = 0;
+    sprite->data4 = 0;
+    sprite->data5 = 0;
+    sprite->data6 = 0;
+    sprite->data7 = 0;
+    sprite->callback = sub_81292E8;
+}
+
+void sub_81292E8(struct Sprite *sprite)
+{
+    if (sprite->data7 == 0)
+    {
+        if (sprite->data6 < 15)
+        {
+            sprite->invisible = FALSE;
+        }
+        else
+        {
+            sprite->invisible = TRUE;
+        }
+        sprite->data6 ++;
+        sprite->data6 &= 0x1F;
+    }
+    else
+    {
+        sprite->invisible = FALSE;
+    }
+}
+
+u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor)
+{
+    sub_8129048(data);
+    data->decoration = &gDecorations[decor];
+    if (data->decoration->permission == DECORPERM_SOLID_MAT)
+    {
+        return AddPseudoFieldObject(data->decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1);
+    }
+    FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG);
+    sub_81291E8(data);
+    SetDecorSelectionBoxOamAttributes(data->decoration->shape);
+    sub_81291A4(data);
+    sub_8129068(data->palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(data->decoration->tiles[0] * 8) + 7] >> 12);
+    LoadSpritePalette(&gUnknown_085A72BC);
+    return CreateSprite(&sDecorSelectorSpriteTemplate, 0, 0, 0);
+}
+
+u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor)
+{
+    struct SpriteSheet sheet;
+    struct CompressedSpritePalette palette;
+    struct SpriteTemplate *template;
+    u8 spriteId;
+
+    if (!AllocItemIconTemporaryBuffers())
+    {
+        return MAX_SPRITES;
+    }
+    LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gUnknown_0203CEBC);
+    CopyItemIconPicTo4x4Buffer(gUnknown_0203CEBC, gUnknown_0203CEC0);
+    sheet.data = gUnknown_0203CEC0;
+    sheet.size = 0x200;
+    sheet.tag = tilesTag;
+    LoadSpriteSheet(&sheet);
+    palette.data = GetDecorationIconPicOrPalette(decor, 1);
+    palette.tag = paletteTag;
+    LoadCompressedObjectPalette(&palette);
+    template = malloc(sizeof(struct SpriteTemplate));
+    *template = gUnknown_08614FF4;
+    template->tileTag = tilesTag;
+    template->paletteTag = paletteTag;
+    spriteId = CreateSprite(template, 0, 0, 0);
+    FreeItemIconTemporaryBuffers();
+    free(template);
+    return spriteId;
+}
+
+const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode)
+{
+    if (decor > 120)
+    {
+        decor = DECOR_NONE;
+    }
+    return gUnknown_085A6BE8[decor][mode];
+}
+
+u8 AddDecorationIconObjectFromFieldObject(u16 tilesTag, u16 paletteTag, u8 decor)
+{
+    u8 spriteId;
+    struct SpriteSheet sheet;
+    struct SpritePalette palette;
+    struct SpriteTemplate *template;
+
+    sub_8129048(&sPlaceDecorationGraphicsDataBuffer);
+    sPlaceDecorationGraphicsDataBuffer.decoration = &gDecorations[decor];
+    if (sPlaceDecorationGraphicsDataBuffer.decoration->permission != DECORPERM_SOLID_MAT)
+    {
+        sub_81291E8(&sPlaceDecorationGraphicsDataBuffer);
+        SetDecorSelectionBoxOamAttributes(sPlaceDecorationGraphicsDataBuffer.decoration->shape);
+        sub_81291A4(&sPlaceDecorationGraphicsDataBuffer);
+        sub_8129068(sPlaceDecorationGraphicsDataBuffer.palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0] * 8) + 7] >> 12);
+        sheet.data = sPlaceDecorationGraphicsDataBuffer.image;
+        sheet.size = gUnknown_085A72F4[sPlaceDecorationGraphicsDataBuffer.decoration->shape] << 5;
+        sheet.tag = tilesTag;
+        LoadSpriteSheet(&sheet);
+        palette.data = sPlaceDecorationGraphicsDataBuffer.palette;
+        palette.tag = paletteTag;
+        LoadSpritePalette(&palette);
+        template = Alloc(sizeof(struct SpriteTemplate));
+        *template = sDecorWhilePlacingSpriteTemplate;
+        template->tileTag = tilesTag;
+        template->paletteTag = paletteTag;
+        spriteId = CreateSprite(template, 0, 0, 0);
+        free(template);
+    }
+    else
+    {
+        spriteId = AddPseudoFieldObject(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1);
+    }
+    return spriteId;
+}
+
+u8 AddDecorationIconObject(u8 decor, s16 x, s16 y, u8 priority, u16 tilesTag, u16 paletteTag)
+{
+    u8 spriteId;
+
+    if (decor > 120)
+    {
+        spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, DECOR_NONE);
+        if (spriteId == MAX_SPRITES)
+        {
+            return MAX_SPRITES;
+        }
+        gSprites[spriteId].pos2.x = x + 4;
+        gSprites[spriteId].pos2.y = y + 4;
+    }
+    else if (gUnknown_085A6BE8[decor][0] == NULL)
+    {
+        spriteId = AddDecorationIconObjectFromFieldObject(tilesTag, paletteTag, decor);
+        if (spriteId == MAX_SPRITES)
+        {
+            return MAX_SPRITES;
+        }
+        gSprites[spriteId].pos2.x = x;
+        if (decor == DECOR_SILVER_SHIELD || decor == DECOR_GOLD_SHIELD)
+        {
+            gSprites[spriteId].pos2.y = y - 4;
+        }
+        else
+        {
+            gSprites[spriteId].pos2.y = y;
+        }
+    }
+    else
+    {
+        spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, decor);
+        if (spriteId == MAX_SPRITES)
+        {
+            return MAX_SPRITES;
+        }
+        gSprites[spriteId].pos2.x = x + 4;
+        gSprites[spriteId].pos2.y = y + 4;
+    }
+    gSprites[spriteId].oam.priority = priority;
+    return spriteId;
+}
+
+void sub_81296EC(u8 idx)
+{
+    gUnknown_0203A17C.items[idx] = 0;
+    gUnknown_0203A17C.pos[idx] = 0;
+}
+
+void sub_8129708(void)
+{
+    u16 i;
+
+    gSpecialVar_0x8005 = 0;
+    gScriptResult = 0;
+    if (gSpecialVar_0x8004 == sCurDecorSelectedInRearrangement)
+    {
+        gScriptResult = 1;
+    }
+    else if (gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx]].permission == DECORPERM_SOLID_MAT)
+    {
+        gSpecialVar_0x8005 = sDecorRearrangementDataBuffer[gSpecialVar_0x8004].flagId;
+        sub_81296EC(sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx);
+        for (i = 0; i < gMapHeader.events->mapObjectCount; i ++)
+        {
+            if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8005)
+            {
+                gSpecialVar_0x8006 = gMapHeader.events->mapObjects[i].localId;
+                break;
+            }
+        }
+    }
+}
+
+void sub_81297AC(void)
+{
+    u8 i;
+
+    for (i = 0; i < gMapHeader.events->mapObjectCount; i ++)
+    {
+        if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8004)
+        {
+            gSpecialVar_0x8005 = gMapHeader.events->mapObjects[i].localId;
+            break;
+        }
+    }
+}
+
+void sub_81297F8(void)
+{
+    u8 i;
+    u8 y;
+    u8 x;
+    int posX;
+    int posY;
+    u8 perm;
+
+    for (i = 0; i < sCurDecorSelectedInRearrangement; i ++)
+    {
+        perm = gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[i].idx]].permission;
+        posX = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] >> 4;
+        posY = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] & 0x0F;
+        if (perm != DECORPERM_SOLID_MAT)
+        {
+            for (y = 0; y < sDecorRearrangementDataBuffer[i].height; y ++)
+            {
+                for (x = 0; x < sDecorRearrangementDataBuffer[i].width; x ++)
+                {
+                    MapGridSetMetatileEntryAt(posX + 7 + x, posY + 7 - y, gMapHeader.mapData->map[posX + x + gMapHeader.mapData->width * (posY - y)] | 0x3000);
+                }
+            }
+            sub_81296EC(sDecorRearrangementDataBuffer[i].idx);
+        }
+    }
+}
+
+void sub_81298EC(u8 taskId)
+{
+    switch (gTasks[taskId].data[2])
+    {
+        case 0:
+            sub_81297F8();
+            gTasks[taskId].data[2] = 1;
+            break;
+        case 1:
+            if (!gPaletteFade.active) {
+                DrawWholeMapView();
+                ScriptContext1_SetupScript(gUnknown_08275D2E);
+                sub_8197434(0, 1);
+                gTasks[taskId].data[2] = 2;
+            }
+            break;
+        case 2:
+            ScriptContext2_Enable();
+            IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+            pal_fill_black();
+            gTasks[taskId].data[2] = 3;
+            break;
+        case 3:
+            if (sub_80ABDFC() == TRUE)
+            {
+                StringExpandPlaceholders(gStringVar4, gText_DecorationReturnedToPC);
+                DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64);
+                if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+                {
+                    TV_PutSecretBaseVisitOnTheAir();
+                }
+            }
+            break;
+    }
+}
+
+
+bool8 sub_81299AC(u8 taskId)
+{
+    u16 i;
+
+    for (i = 0; i < gUnknown_0203A17C.size; i ++)
+    {
+        if (gUnknown_0203A17C.items[i] != DECOR_NONE)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void SetUpPuttingAwayDecorationPlayerAvatar(void)
+{
+    player_get_direction_lower_nybble();
+    sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0;
+    sub_812A39C();
+    gUnknown_03005DD0.unk4 = CreateSprite(&gUnknown_085A7404, 0x78, 0x50, 0);
+    if (gSaveBlock2Ptr->playerGender == MALE)
+    {
+        sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, 0x88, 0x48, 0);
+    }
+    else
+    {
+        sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, 0x88, 0x48, 0);
+    }
+    gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1;
+    DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]);
+    sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4;
+    gSprites[sDecor_CameraSpriteObjectIdx1].oam.priority = 1;
+}
+
+void sub_8129ABC(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    switch (data[2])
+    {
+        case 0:
+            if (!gPaletteFade.active)
+            {
+                sub_8127ACC(taskId);
+                data[2] = 1;
+                data[6] = 1;
+                data[5] = 1;
+            }
+            break;
+        case 1:
+            SetUpPuttingAwayDecorationPlayerAvatar();
+            pal_fill_black();
+            data[2] = 2;
+            break;
+        case 2:
+            if (sub_80ABDFC() == TRUE)
+            {
+                data[12] = 1;
+                sub_8129B34(taskId);
+            }
+            break;
+    }
+}
+
+void sub_8129B34(u8 taskId)
+{
+    sub_8197434(0, 1);
+    gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0;
+    gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+    gSprites[sDecor_CameraSpriteObjectIdx1].callback = sub_812A36C;
+    gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = 0x88;
+    gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = 0x48;
+    gTasks[taskId].data[10] = 0;
+    gTasks[taskId].func = sub_8128E18;
+}
+
+void sub_8129BCC(u8 taskId)
+{
+    gTasks[taskId].data[10] = 0;
+    sub_8128DE0();
+    sub_8129C74(taskId);
+}
+
+void sub_8129BF8(u8 taskId)
+{
+    gTasks[taskId].data[10] = 0;
+    sub_8128DE0();
+    gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+    gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+    StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations);
+    DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0);
+}
+
+void sub_8129C74(u8 taskId)
+{
+    s16 *data;
+    u8 behavior;
+
+    sub_812A0E8(taskId);
+    if (sCurDecorSelectedInRearrangement != 0)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_ReturnDecorationToPC);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1A0);
+    }
+    else
+    {
+        data = gTasks[taskId].data;
+        behavior = MapGridGetMetatileBehaviorAt(data[0], data[1]);
+        if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsMB_C5(behavior) == TRUE)
+        {
+            gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+            gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+            StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations);
+            DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0);
+        }
+        else
+        {
+            StringExpandPlaceholders(gStringVar4, gText_NoDecorationHere);
+            DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64);
+        }
+    }
+}
+
+void sub_8129D64(u8 taskId)
+{
+    if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON)
+    {
+        sub_8129B34(taskId);
+    }
+}
+
+void sub_8129D8C(u8 decor, struct DecorRearrangementDataBuffer *data)
+{
+    if (gDecorations[decor].shape == DECORSHAPE_1x1)
+    {
+        data->width = 1;
+        data->height = 1;
+    } else if (gDecorations[decor].shape == DECORSHAPE_2x1)
+    {
+        data->width = 2;
+        data->height = 1;
+    } else if (gDecorations[decor].shape == DECORSHAPE_3x1)
+    {
+        data->width = 3;
+        data->height = 1;
+    } else if (gDecorations[decor].shape == DECORSHAPE_4x2)
+    {
+        data->width = 4;
+        data->height = 2;
+    } else if (gDecorations[decor].shape == DECORSHAPE_2x2)
+    {
+        data->width = 2;
+        data->height = 2;
+    } else if (gDecorations[decor].shape == DECORSHAPE_1x2)
+    {
+        data->width = 1;
+        data->height = 2;
+    } else if (gDecorations[decor].shape == DECORSHAPE_1x3)
+    {
+        data->width = 1;
+        data->height = 3;
+    } else if (gDecorations[decor].shape == DECORSHAPE_2x4)
+    {
+        data->width = 2;
+        data->height = 4;
+    } else if (gDecorations[decor].shape == DECORSHAPE_3x3)
+    {
+        data->width = 3;
+        data->height = 3;
+    } else if (gDecorations[decor].shape == DECORSHAPE_3x2)
+    {
+        data->width = 3;
+        data->height = 2;
+    }
+}
+
+void sub_8129E0C(u8 x, u8 y)
+{
+    gSprites[sDecor_CameraSpriteObjectIdx1].invisible = TRUE;
+    gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+    gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = (x << 4) + 0x88;
+    gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = (y << 4) + 0x48;
+}
+
+bool8 sub_8129E74(u8 taskId, u8 idx, struct DecorRearrangementDataBuffer *data)
+{
+    u8 x;
+    u8 y;
+    u8 xOff;
+    u8 yOff;
+    u8 ht;
+
+    x = gTasks[taskId].data[0] - 7;
+    y = gTasks[taskId].data[1] - 7;
+    xOff = gUnknown_0203A17C.pos[idx] >> 4;
+    yOff = gUnknown_0203A17C.pos[idx] & 0x0F;
+    ht = data->height;
+    if (gUnknown_0203A17C.items[idx] == DECOR_SAND_ORNAMENT && MapGridGetMetatileIdAt(xOff + 7, yOff + 7) == 0x28C)
+    {
+        ht --;
+    }
+    if (x >= xOff && x < xOff + data->width && y > yOff - ht && y <= yOff)
+    {
+        sub_8129E0C(data->width - (x - xOff + 1), yOff - y);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_8129F20(void)
+{
+    u8 xOff;
+    u8 yOff;
+    u16 i;
+
+    xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] >> 4;
+    yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] & 0x0F;
+    for (i = 0; i < 0x40; i ++)
+    {
+        if (gSaveBlock1Ptr->mapObjectTemplates[i].x == xOff && gSaveBlock1Ptr->mapObjectTemplates[i].y == yOff && !FlagGet(gSaveBlock1Ptr->mapObjectTemplates[i].flagId))
+        {
+            sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].flagId = gSaveBlock1Ptr->mapObjectTemplates[i].flagId;
+            break;
+        }
+    }
+}
+
+bool8 sub_8129FC8(u8 taskId)
+{
+    u16 i;
+
+    for (i = 0; i < gUnknown_0203A17C.size; i ++)
+    {
+        if (gUnknown_0203A17C.items[i] != 0)
+        {
+            if (gDecorations[gUnknown_0203A17C.items[i]].permission == DECORPERM_SOLID_MAT)
+            {
+                sub_8129D8C(gUnknown_0203A17C.items[i], sDecorRearrangementDataBuffer);
+                if (sub_8129E74(taskId, i, sDecorRearrangementDataBuffer) == TRUE)
+                {
+                    sDecorRearrangementDataBuffer->idx = i;
+                    sub_8129F20();
+                    sCurDecorSelectedInRearrangement = 1;
+                    return TRUE;
+                }
+            }
+        }
+    }
+    return FALSE;
+}
+
+void sub_812A040(u8 left, u8 top, u8 right, u8 bottom)
+{
+    u8 i;
+    u8 xOff;
+    u8 yOff;
+    u8 decorIdx;
+
+    for (i = 0; i < gUnknown_0203A17C.size; i ++)
+    {
+        decorIdx = gUnknown_0203A17C.items[i];
+        xOff = gUnknown_0203A17C.pos[i] >> 4;
+        yOff = gUnknown_0203A17C.pos[i] & 0x0F;
+        if (decorIdx != 0 && gDecorations[decorIdx].permission == DECORPERM_SOLID_MAT && left <= xOff && top <= yOff && right >= xOff && bottom >= yOff)
+        {
+            sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx = i;
+            sub_8129F20();
+            sCurDecorSelectedInRearrangement++;
+        }
+    }
+}
+
+#ifdef NONMATCHING
+void sub_812A0E8(u8 taskId)
+{
+    u8 i;
+    u8 xOff;
+    u8 yOff;
+    u8 decor;
+    register u8 decor asm("r1");
+    struct DecorRearrangementDataBuffer *data;
+
+    sCurDecorSelectedInRearrangement = 0;
+    if (sub_8129FC8(taskId) != TRUE)
+    {
+        for (i = 0; i < gUnknown_0203A17C.size; i ++)
+        {
+            decor = gUnknown_0203A17C.items[i];
+            if (decor != DECOR_NONE)
+            {
+                data = &sDecorRearrangementDataBuffer[0];
+                sub_8129D8C(decor, data);
+                if (sub_8129E74(taskId, i, data) == TRUE)
+                {
+                    data->idx = i;
+                    sCurDecorSelectedInRearrangement ++;
+                    break;
+                }
+            }
+        }
+        if (sCurDecorSelectedInRearrangement != 0)
+        {
+            xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] >> 4;
+            yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] & 0x0F;
+            sub_812A040(xOff, yOff - sDecorRearrangementDataBuffer[0].height + 1, xOff + sDecorRearrangementDataBuffer[0].width - 1, yOff); // Arithmetic register swap at the r2 argument: `add r2, r0, r2` instead of `add r2, r2, r0`
+        }
+    }
+}
+#else
+__attribute__((naked)) void sub_812A0E8(u8 taskId)
+{
+    asm_unified("\tpush {r4-r7,lr}\n"
+                    "\tlsls r0, 24\n"
+                    "\tlsrs r6, r0, 24\n"
+                    "\tldr r4, =sCurDecorSelectedInRearrangement\n"
+                    "\tmovs r0, 0\n"
+                    "\tstrb r0, [r4]\n"
+                    "\tadds r0, r6, 0\n"
+                    "\tbl sub_8129FC8\n"
+                    "\tlsls r0, 24\n"
+                    "\tlsrs r0, 24\n"
+                    "\tcmp r0, 0x1\n"
+                    "\tbeq _0812A18C\n"
+                    "\tmovs r5, 0\n"
+                    "\tldr r0, =gUnknown_0203A17C\n"
+                    "\tldrb r1, [r0, 0x8]\n"
+                    "\tcmp r5, r1\n"
+                    "\tbcs _0812A15A\n"
+                    "\tadds r7, r4, 0\n"
+                    "_0812A10E:\n"
+                    "\tldr r0, [r0]\n"
+                    "\tadds r0, r5\n"
+                    "\tldrb r1, [r0]\n"
+                    "\tcmp r1, 0\n"
+                    "\tbeq _0812A14C\n"
+                    "\tldr r4, =sDecorRearrangementDataBuffer\n"
+                    "\tadds r0, r1, 0\n"
+                    "\tadds r1, r4, 0\n"
+                    "\tbl sub_8129D8C\n"
+                    "\tadds r0, r6, 0\n"
+                    "\tadds r1, r5, 0\n"
+                    "\tadds r2, r4, 0\n"
+                    "\tbl sub_8129E74\n"
+                    "\tlsls r0, 24\n"
+                    "\tlsrs r0, 24\n"
+                    "\tcmp r0, 0x1\n"
+                    "\tbne _0812A14C\n"
+                    "\tstrb r5, [r4]\n"
+                    "\tldrb r0, [r7]\n"
+                    "\tadds r0, 0x1\n"
+                    "\tstrb r0, [r7]\n"
+                    "\tb _0812A15A\n"
+                    "\t.pool\n"
+                    "_0812A14C:\n"
+                    "\tadds r0, r5, 0x1\n"
+                    "\tlsls r0, 24\n"
+                    "\tlsrs r5, r0, 24\n"
+                    "\tldr r0, =gUnknown_0203A17C\n"
+                    "\tldrb r1, [r0, 0x8]\n"
+                    "\tcmp r5, r1\n"
+                    "\tbcc _0812A10E\n"
+                    "_0812A15A:\n"
+                    "\tldr r0, =sCurDecorSelectedInRearrangement\n"
+                    "\tldrb r0, [r0]\n"
+                    "\tcmp r0, 0\n"
+                    "\tbeq _0812A18C\n"
+                    "\tldr r0, =gUnknown_0203A17C\n"
+                    "\tldr r2, =sDecorRearrangementDataBuffer\n"
+                    "\tldrb r1, [r2]\n"
+                    "\tldr r0, [r0, 0x4]\n"
+                    "\tadds r0, r1\n"
+                    "\tldrb r1, [r0]\n"
+                    "\tlsrs r0, r1, 4\n"
+                    "\tmovs r3, 0xF\n"
+                    "\tands r3, r1\n"
+                    "\tldrb r1, [r2, 0x2]\n"
+                    "\tsubs r1, r3, r1\n"
+                    "\tadds r1, 0x1\n"
+                    "\tlsls r1, 24\n"
+                    "\tlsrs r1, 24\n"
+                    "\tldrb r2, [r2, 0x1]\n"
+                    "\tadds r2, r0\n"
+                    "\tsubs r2, 0x1\n"
+                    "\tlsls r2, 24\n"
+                    "\tlsrs r2, 24\n"
+                    "\tbl sub_812A040\n"
+                    "_0812A18C:\n"
+                    "\tpop {r4-r7}\n"
+                    "\tpop {r0}\n"
+                    "\tbx r0\n"
+                    "\t.pool");
+}
+#endif
+
+void sub_812A1A0(u8 taskId)
+{
+    sub_8197930();
+    sub_8121F68(taskId, &gUnknown_085A7348);
+}
+
+void sub_812A1C0(u8 taskId)
+{
+    fade_screen(1, 0);
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].func = sub_81298EC;
+}
+
+void sub_812A1F0(u8 taskId)
+{
+    sub_8197930();
+    sub_8121F68(taskId, &gUnknown_085A7350);
+}
+
+void sub_812A210(u8 taskId)
+{
+    sub_8197434(0, 0);
+    sub_812A22C(taskId);
+}
+
+void sub_812A22C(u8 taskId)
+{
+    fade_screen(1, 0);
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].func = sub_812A25C;
+}
+
+void sub_812A25C(u8 taskId)
+{
+    switch (gTasks[taskId].data[2])
+    {
+        case 0:
+            if (!gPaletteFade.active)
+            {
+                sub_8127B04(taskId);
+                gTasks[taskId].data[2] = 1;
+            }
+            break;
+        case 1:
+            sub_812A3C8();
+            gFieldCallback = sub_812A334;
+            SetMainCallback2(c2_exit_to_overworld_2_switch);
+            DestroyTask(taskId);
+            break;
+    }
+}
+
+void sub_812A2C4(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    switch (data[2])
+    {
+        case 0:
+            sub_80E9578();
+            data[2] ++;
+            break;
+        case 1:
+            ScriptContext1_SetupScript(gUnknown_08275D0C);
+            data[2] ++;
+            break;
+        case 2:
+            ScriptContext2_Enable();
+            data[2] ++;
+            break;
+        case 3:
+            if (sub_80ABDFC() == TRUE)
+            {
+                gTasks[taskId].func = sub_8126B80;
+            }
+            break;
+    }
+}
+
+void sub_812A334(void)
+{
+    u8 taskId;
+
+    pal_fill_black();
+    sub_81973C4(0, 1);
+    sub_8126ABC();
+    taskId = CreateTask(sub_812A2C4, 8);
+    gTasks[taskId].data[2] = 0;
+}
+
+void sub_812A36C(struct Sprite *sprite)
+{
+    sprite->data0 ++;
+    sprite->data0 &= 0x1F;
+    if (sprite->data0 > 15)
+    {
+        sprite->invisible = TRUE;
+    }
+    else
+    {
+        sprite->invisible = FALSE;
+    }
+}
+
+void sub_812A39C(void)
+{
+    if (gSaveBlock2Ptr->playerGender == MALE)
+    {
+        LoadSpritePalette(&gUnknown_085A73D8);
+    }
+    else
+    {
+        LoadSpritePalette(&gUnknown_085A73E0);
+    }
+}
+
+void sub_812A3C8(void)
+{
+    FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG);
+}
+
+void sub_812A3D4(u8 taskId)
+{
+    if (IsSelectedDecorInThePC() == TRUE)
+    {
+        StringCopy(gStringVar1, gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].name);
+        StringExpandPlaceholders(gStringVar4, gText_DecorationWillBeDiscarded);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_812A458);
+    }
+    else
+    {
+        StringExpandPlaceholders(gStringVar4, gText_CantThrowAwayInUse);
+        DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+    }
+}
+
+void sub_812A458(u8 taskId)
+{
+    sub_8197930();
+    sub_8121F68(taskId, &gUnknown_085A741C);
+}
+
+void sub_812A478(u8 taskId)
+{
+    gCurDecorInventoryItems[gCurDecorationIndex] = DECOR_NONE;
+    sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory);
+    CondenseDecorationCategoryN(sCurDecorationCategory);
+    IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+    StringExpandPlaceholders(gStringVar4, gText_DecorationThrownAway);
+    DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+}
diff --git a/src/decoration_inventory.c b/src/decoration_inventory.c
new file mode 100644
index 000000000..03ab6c00c
--- /dev/null
+++ b/src/decoration_inventory.c
@@ -0,0 +1,189 @@
+
+// Includes
+#include "global.h"
+#include "decoration.h"
+#include "decoration_inventory.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+EWRAM_DATA struct DecorationInventory gDecorationInventories[8] = {};
+
+// Static ROM declarations
+
+// .rodata
+
+// .text
+
+#define SET_DECOR_INV(i, ptr) {\
+    gDecorationInventories[i].items = ptr;\
+    gDecorationInventories[i].size = sizeof(ptr);\
+}
+
+void SetDecorationInventoriesPointers(void)
+{
+    SET_DECOR_INV(0, gSaveBlock1Ptr->decorDesk);
+    SET_DECOR_INV(1, gSaveBlock1Ptr->decorChair);
+    SET_DECOR_INV(2, gSaveBlock1Ptr->decorPlant);
+    SET_DECOR_INV(3, gSaveBlock1Ptr->decorOrnament);
+    SET_DECOR_INV(4, gSaveBlock1Ptr->decorMat);
+    SET_DECOR_INV(5, gSaveBlock1Ptr->decorPoster);
+    SET_DECOR_INV(6, gSaveBlock1Ptr->decorDoll);
+    SET_DECOR_INV(7, gSaveBlock1Ptr->decorCushion);
+    sub_8126968();
+}
+
+static void ClearDecorationInventory(u8 idx)
+{
+    u8 i;
+
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        gDecorationInventories[idx].items[i] = DECOR_NONE;
+    }
+}
+
+void ClearDecorationInventories(void)
+{
+    u8 idx;
+
+    for (idx = 0; idx < 8; idx ++)
+    {
+        ClearDecorationInventory(idx);
+    }
+}
+
+s8 GetFirstEmptyDecorSlot(u8 idx)
+{
+    s8 i;
+
+    for (i = 0; i < (s8)gDecorationInventories[idx].size; i ++)
+    {
+        if (gDecorationInventories[idx].items[i] == DECOR_NONE)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+bool8 CheckHasDecoration(u8 decor)
+{
+    u8 i;
+    u8 category;
+
+    category = gDecorations[decor].category;
+    for (i = 0; i < gDecorationInventories[category].size; i ++)
+    {
+        if (gDecorationInventories[category].items[i] == decor)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 DecorationAdd(u8 decor)
+{
+    u8 category;
+    s8 idx;
+
+    if (decor == DECOR_NONE)
+    {
+        return FALSE;
+    }
+    category = gDecorations[decor].category;
+    idx = GetFirstEmptyDecorSlot(category);
+    if (idx == -1)
+    {
+        return FALSE;
+    }
+    gDecorationInventories[category].items[idx] = decor;
+    return TRUE;
+}
+
+bool8 DecorationCheckSpace(u8 decor)
+{
+    if (decor == DECOR_NONE)
+    {
+        return FALSE;
+    }
+    if (GetFirstEmptyDecorSlot(gDecorations[decor].category) == -1)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+s8 DecorationRemove(u8 decor)
+{
+    u8 i;
+    u8 idx;
+
+    i = 0;
+    if (decor == DECOR_NONE)
+    {
+        return 0;
+    }
+    for (i = 0; i < gDecorationInventories[gDecorations[decor].category].size; i ++)
+    {
+        idx = gDecorations[decor].category;
+        if (gDecorationInventories[idx].items[i] == decor)
+        {
+            gDecorationInventories[idx].items[i] = DECOR_NONE;
+            CondenseDecorationCategoryN(idx);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void CondenseDecorationCategoryN(u8 idx)
+{
+    u8 i;
+    u8 j;
+    u8 tmp;
+
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        for (j = i + 1; j < gDecorationInventories[idx].size; j ++)
+        {
+            if (gDecorationInventories[idx].items[j] != DECOR_NONE && (gDecorationInventories[idx].items[i] == DECOR_NONE || gDecorationInventories[idx].items[i] > gDecorationInventories[idx].items[j]))
+            {
+                tmp = gDecorationInventories[idx].items[i];
+                gDecorationInventories[idx].items[i] = gDecorationInventories[idx].items[j];
+                gDecorationInventories[idx].items[j] = tmp;
+            }
+        }
+    }
+}
+
+u8 CountDecorationCategoryN(u8 idx)
+{
+    u8 i;
+    u8 ct;
+
+    ct = 0;
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        if (gDecorationInventories[idx].items[i] != DECOR_NONE)
+        {
+            ct ++;
+        }
+    }
+    return ct;
+}
+
+u8 CountDecorations(void)
+{
+    u8 idx;
+    u8 ct;
+
+    ct = 0;
+    for (idx = 0; idx < 8; idx ++)
+    {
+        ct += CountDecorationCategoryN(idx);
+    }
+    return ct;
+}
diff --git a/src/international_string_util.c b/src/international_string_util.c
index c77b4f8ff..81985d614 100644
--- a/src/international_string_util.c
+++ b/src/international_string_util.c
@@ -28,13 +28,13 @@ s32 GetStringWidthDifference(s32 fontId, const u8 *str, s32 totalWidth, s32 lett
         return 0;
 }
 
-s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1)
+s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1)
 {
     s32 i, var;
 
     for (var = 0, i = 0; i < arg1; i++)
     {
-        s32 stringWidth = GetStringWidth(1, str[i * 2], 0);
+        s32 stringWidth = GetStringWidth(1, str[i].text, 0);
         if (stringWidth > var)
             var = stringWidth;
     }
@@ -42,13 +42,13 @@ s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1)
     return convert_pixel_width_to_tile_width(var);
 }
 
-s32 sub_81DB3D8(const u8 **str, u8* arg1, s32 arg2)
+s32 sub_81DB3D8(const struct MenuAction *str, u8* arg1, s32 arg2)
 {
     s32 i, var;
 
     for (var = 0, i = 0; i < arg2; i++)
     {
-        s32 stringWidth = GetStringWidth(1, str[arg1[i] * 2], 0);
+        s32 stringWidth = GetStringWidth(1, str[arg1[i]].text, 0);
         if (stringWidth > var)
             var = stringWidth;
     }
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
new file mode 100755
index 000000000..37ecdc982
--- /dev/null
+++ b/src/pokemon_summary_screen.c
@@ -0,0 +1,3679 @@
+#include "global.h"
+#include "battle.h"
+#include "bg.h"
+#include "decompress.h"
+#include "item.h"
+#include "items.h"
+#include "link.h"
+#include "m4a.h"
+#include "main.h"
+#include "malloc.h"
+#include "moves.h"
+#include "palette.h"
+#include "pokemon.h"
+#include "songs.h"
+#include "sound.h"
+#include "species.h"
+#include "sprite.h"
+#include "string_util.h"
+#include "task.h"
+#include "text.h"
+#include "window.h"
+
+struct ContestMove
+{
+    u8 effect;
+    u8 type;
+    u8 comboID;
+    u8 combo[4];
+};
+
+struct ContestEffect
+{
+    u8 type;
+    u8 appeal;
+    u8 jam;
+};
+
+
+
+extern struct UnkSummaryStruct* gUnknown_0203CF1C;
+extern struct BgTemplate gUnknown_0861CBB4;
+extern u8 gUnknown_0203CF20;
+extern struct MusicPlayerInfo gMPlay_BGM;
+extern s8 gUnknown_0861CC1C[];
+extern u8 gUnknown_08329D22[];
+extern u8 gUnknown_0203CF21;
+extern u16 gSpecialVar_0x8005;
+extern struct UnkStruct_61CC04 gUnknown_0861CC04;
+extern struct UnkStruct_61CC04 gUnknown_0861CC10;
+extern struct UnkStruct_61CC04 gUnknown_0861CBEC;
+extern struct UnkStruct_61CC04 gUnknown_0861CBF8;
+extern u16 gUnknown_08DC3CD4[];
+extern struct ContestMove gContestMoves[];
+extern struct ContestEffect gContestEffects[];
+extern struct WindowTemplate gUnknown_0861CC24;
+extern struct TextColor gUnknown_0861CD2C[];
+extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1];
+extern u8 gText_MaleSymbol[];
+extern u8 gText_FemaleSymbol[];
+extern u8 gUnknown_0861CDD3[];
+extern void (*const gUnknown_0861CE54[])();
+extern void (*const gUnknown_0861CE64[])(u8 taskId);
+extern struct WindowTemplate gUnknown_0861CCCC;
+extern u8 gUnknown_0861CE74[];
+extern u8 gUnknown_0861CE7B[];
+extern struct WindowTemplate gUnknown_0861CCEC;
+extern struct WindowTemplate gUnknown_0861CD14;
+
+extern void sub_806F2AC(u8 a, u8 b);
+void sub_81C488C(u8 a);
+extern void do_scheduled_bg_tilemap_copies_to_vram(void);
+extern u8 sub_81221EC();
+extern u8 sub_81221AC();
+extern void SetVBlankHBlankCallbacksToNull();
+extern void sub_8121DA0();
+extern void clear_scheduled_bg_copies_to_vram();
+extern void remove_some_task();
+extern void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable);
+extern void ShowBg(u8 a);
+extern void SetGpuReg(u8 regOffset, u16 value);
+extern void schedule_bg_copy_tilemap_to_vram(u8 a);
+extern void SetBgTilemapBuffer(u8 bg, void *tilemap);
+extern u8 gUnknown_08D9862C;
+extern u8 gUnknown_08D98CC8;
+extern u8 gUnknown_08D987FC;
+extern u8 gUnknown_08D9898C;
+extern u8 gUnknown_08D98B28;
+extern u8 gUnknown_08D9853C;
+extern u8 gUnknown_08D85620;
+extern struct CompressedSpriteSheet gUnknown_0861CFBC;
+extern struct CompressedSpriteSheet gUnknown_0861D074;
+extern struct CompressedSpriteSheet gUnknown_0861D0F8;
+extern struct CompressedSpritePalette gUnknown_0861D100;
+extern struct CompressedSpritePalette gUnknown_0861D07C;
+extern u8 gUnknown_08D97B84;
+extern u8 gUnknown_08D97D0C;
+extern void reset_temp_tile_data_buffers();
+extern void decompress_and_copy_tile_data_to_vram(u8 a, void* tiledata, u8 b, u8 c, u8 d);
+extern u8 free_temp_tile_data_buffers_if_possible();
+extern void sub_8069004(struct BoxPokemon* a, void* b);
+extern void sub_81C1E20(u8 taskId);
+extern u8 *GetMonNickname(struct Pokemon *mon, u8 *dest);
+extern u16 SpeciesToPokedexNum(u16 species);
+extern u8 gText_UnkCtrlF908Clear01[];
+extern u8 gText_LevelSymbol[];
+extern u8 gText_PkmnInfo[];
+extern u8 gText_PkmnSkills[];
+extern u8 gText_BattleMoves[];
+extern u8 gText_ContestMoves[];
+extern u8 gText_Cancel2[];
+extern u8 gText_Info[];
+extern u8 gText_Switch[];
+extern u8 gText_RentalPkmn[];
+extern u8 gText_TypeSlash[];
+extern u8 gText_HP4[];
+extern u8 gText_Attack3[];
+extern u8 gText_Defense3[];
+extern u8 gText_SpAtk4[];
+extern u8 gText_SpDef4[];
+extern u8 gText_Speed2[];
+extern u8 gText_ExpPoints[];
+extern u8 gText_NextLv[];
+extern u8 gText_Status[];
+extern u8 gText_Power[];
+extern u8 gText_Accuracy2[];
+extern u8 gText_Appeal[];
+extern u8 gText_Jam[];
+extern u8 gText_OTSlash[];
+extern u8 gText_UnkCtrlF907F908[];
+extern u8 gAbilityNames[][13];
+extern u8 *gAbilityDescriptionPointers[];
+extern u8 gText_XNature[];
+extern u8 gText_XNatureHatchedAtYZ[];
+extern u8 gText_XNatureHatchedSomewhereAt[];
+extern u8 gText_XNatureMetAtYZ[];
+extern u8 gText_XNatureMetSomewhereAt[];
+extern u8 gText_XNatureFatefulEncounter[];
+extern u8 gText_XNatureProbablyMetAt[];
+extern u8 gText_XNatureObtainedInTrade[];
+extern u8 *gNatureNamePointers[];
+extern u8 gText_EmptyString5[];
+extern u32 gBattleTypeFlags;
+extern u8 gText_FiveMarks[];
+extern u8 gText_EggWillTakeALongTime[];
+extern u8 gText_EggAboutToHatch[];
+extern u8 gText_EggWillHatchSoon[];
+extern u8 gText_EggWillTakeSomeTime[];
+extern u8 gText_PeculiarEggNicePlace[];
+extern u8 gText_PeculiarEggTrade[];
+extern u8 gText_EggFromTraveler[];
+extern u8 gText_EggFromHotSprings[];
+extern u8 gText_OddEggFoundByCouple[];
+extern u8 gText_None[];
+extern u8 gText_RibbonsVar1[];
+extern u8 gUnknown_0861CE82[];
+extern u8 gUnknown_0861CE8E[];
+extern u8 gText_OneDash[];
+extern u8 gText_TwoDashes[];
+extern u8 gText_ThreeDashes[];
+extern u8 gUnknown_0861CE97[];
+extern struct BattleMove gBattleMoves[];
+
+extern u32 ChangeBgX(u8 bg, u32 value, u8 op);
+extern void sub_8199C30(u8 a, u8 b, u8 c, u8 d, u8 e, u8 f);
+extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor* colors, s8 speed, u8 *str);
+extern s32 GetStringCenterAlignXOffset(u8 fontId, u8 *str, s32 totalWidth);
+extern s32 GetStringRightAlignXOffset(u8 fontId, u8 *str, s32 totalWidth);
+extern bool8 sub_81A6BF4();
+extern bool8 sub_81B9E94();
+extern void sub_81AFBF0();
+extern u8 sub_81AFC0C(u8 a, u8 *b);
+extern void sub_81AFC28(u8 *a, u8 *b);
+extern void sub_8124610(u8 *a, u8 b);
+extern int GetPlayerIDAsU32();
+extern u8 GetCurrentPpToMaxPpState(u8 a, u8 b);
+
+void sub_81BFAE4(void);
+void sub_81BFE24();
+u8 sub_81BFEB0();
+void sub_81C2554();
+void sub_81C1BA0();
+void sub_81C0098(struct Pokemon* a);
+bool8 sub_81C00F0(struct Pokemon* a);
+void sub_81C25E8();
+void sub_81C286C();
+void sub_81C2D9C(u8 a);
+void sub_81C0348();
+void sub_81C2AFC(u8 a);
+void sub_81C4190();
+void sub_81C42C8();
+u8 sub_81C45F4(void* a, u16* b);
+void sub_81C4984();
+void sub_81C4A08();
+void sub_81C4A88();
+void sub_81C4280();
+void sub_81C0510(u8 taskId);
+void sub_81C171C(u8 taskId);
+void sub_8121E10();
+u8 sub_81B205C(struct Pokemon* a);
+void sub_81C1DA4(u16 a, s16 b);
+void sub_81C1EFC(u16 a, s16 b, u16 c);
+void sub_81C240C(u16 a);
+void sub_81C2194(u16 *a, u16 b, u8 c);
+void sub_81C2074(u16 a, s16 b);
+void sub_81C2524();
+void sub_81C2228(struct Pokemon* mon);
+void sub_81C0484(u8 taskId);
+void sub_81C4898();
+void sub_806F47C(u8 a);
+u8 GetLRKeysState();
+void sub_81C0604(u8 taskId, s8 a);
+void sub_81C0A8C(u8 taskId, s8 a);
+void sub_81C48F0();
+void sub_81C0E48(u8 taskId);
+void sub_81C0704(u8 taskId);
+s8 sub_81C09B4(s8 a);
+s8 sub_81C08F8(s8 a);
+void sub_81C4204(u8 a, u8 b);
+void sub_81C20F0(u8 taskId);
+bool8 sub_81C0A50(struct Pokemon* mon);
+void sub_81C49E0();
+void sub_81C0E24();
+void sub_81C2C38(u8 a);
+void sub_81C0B8C(u8 taskId);
+void sub_81C0CC4(u8 taskId);
+void sub_81C2DE4(u8 a);
+void sub_81C424C();
+void sub_81C0C68(u8 taskId);
+void sub_81C0D44(u8 taskId);
+void sub_81C22CC(struct Pokemon* mon);
+void sub_81C0F44(u8 taskId);
+void sub_81C3E9C(u16 a);
+void sub_81C3F44();
+void sub_81C44F0();
+void sub_81C4AF8(u8 a);
+void sub_81C1070(s16* a, s8 b, u8* c);
+void sub_81C11F4(u8 a);
+void sub_81C129C(u8 a);
+bool8 sub_81C1040();
+void sub_81C4064();
+void sub_81C4C60(u8 a);
+void sub_81C12E4(u8 taskId);
+void sub_81C4C84(u8 a);
+void sub_81C13B0(u8 a, u8 b);
+void sub_81C14BC(struct Pokemon *mon, u8 a, u8 b);
+void sub_81C15EC(struct BoxPokemon *mon, u8 a, u8 b);
+void sub_81C40A0(u8 a, u8 b);
+void sub_81C4568(u8 a, u8 b);
+void sub_81C174C(u8 taskId);
+bool8 sub_81C18A8();
+void sub_81C18F4(u8 a);
+u8 sub_81B6D14(u16 a);
+void sub_81C1940(u8 taskId);
+void sub_81C4154();
+void sub_81C1F80(u8 taskId);
+void sub_81C2628();
+void sub_81C2794();
+void sub_81C27DC(struct Pokemon *mon, u16 a);
+void sub_81C2D68(u8 a);
+void sub_81C335C();
+void sub_81C33CC();
+void sub_81C3428();
+void sub_81C349C();
+void sub_81C2EC4();
+void sub_81C2F5C();
+void sub_81C2FD8();
+void sub_81C302C();
+void sub_81C307C();
+void sub_81C3194();
+void sub_81C31C0();
+bool8 sub_81C3304();
+void sub_81C31F0(u8 *a);
+u8 sub_81C3220();
+bool8 sub_81C32BC();
+void sub_81C35E4();
+void sub_81C3690();
+void sub_81C3710();
+void sub_81C37D8();
+void sub_81C3808();
+void sub_81C3890();
+void sub_81C38C0();
+void sub_81C3B08(u8 a);
+void sub_81C3E2C(u8 a);
+void sub_81C4D18();
+
+void SetBgAttribute(u8 bg, u8 attributeId, u8 value);
+
+bool8 sub_81BFB10();
+u8 sub_81B1250();
+
+union UnkUnion
+{
+    struct Pokemon mon[6];
+    struct BoxPokemon boxMon[6];
+};
+
+
+u8 sub_80D214C(union UnkUnion* a, u8 b, u8 c, u8 d);
+
+struct PokeSummary
+{
+    u16 species; // 0x0
+    u16 species2; // 0x2
+    u8 isEgg; // 0x4
+    u8 level; // 0x5
+    u8 ribbons; // 0x6
+    u8 unk7; // 0x7
+    u8 altAbility; // 0x8
+    u8 metLocation; // 0x9
+    u8 metLevel; // 0xA
+    u8 metGame; // 0xB
+    u32 pid; // 0xC
+    u32 exp; // 0x10
+    u16 moves[4]; // 0x14
+    u8 pp[4]; // 0x1C
+    u16 currentHP; // 0x20
+    u16 maxHP; // 0x22
+    u16 atk; // 0x24
+    u16 def; // 0x26
+    u16 spatk; // 0x28
+    u16 spdef; // 0x2A
+    u16 speed; // 0x2C
+    u16 item; // 0x2E
+    u16 friendship; // 0x30
+    u8 OTGender; // 0x32
+    u8 nature; // 0x33
+    u8 ppBonuses; // 0x34
+    u8 sanity; // 0x35
+    u8 OTName[8]; // 0x36
+    u8 unk3E[9]; // 0x3E
+    u32 OTID; // 0x48
+};
+
+struct UnkSummaryStruct
+{
+    /*0x00*/ union UnkUnion *unk0;
+    /*0x04*/ void *unk4;
+    /*0x08*/ void *unk8;
+    /*0x0C*/ struct Pokemon currentMon;
+    /*0x70*/ struct PokeSummary summary;
+    u16 unkTilemap0[0x400];
+    u16 unkTilemap0_1[0x400];
+    u16 unkTilemap1[0x400];
+    u16 unkTilemap1_1[0x400];
+    u16 unkTilemap2[0x400];
+    u16 unkTilemap2_1[0x400];
+    u16 unkTilemap3[0x400];
+    u16 unkTilemap3_1[0x400];
+    u8 unk40BC;
+    u8 unk40BD;
+    u8 unk40BE;
+    u8 unk40BF;
+    u8 unk40C0;
+    u8 unk40C1;
+    u8 unk40C2;
+    u8 unk40C3;
+    u16 unk40C4;
+    u8 unk40C6;
+    u8 unk40C7;
+    u8 unk40C8;
+    u8 unk40C9;
+    u8 unk40CA;
+    u8 unk40CB[8];
+    u8 unk40D3;
+    u8 unk40D4;
+    u8 unk40D5;
+    u8 unk_filler5[0x19];
+    u8 unk40EF;
+    s16 unk40F0;
+    u8 unk_filler4[6];
+};
+
+void sub_81BF8EC(u8 a, void *b, u8 c, u8 d, void *e)
+{
+    u8 byte;
+    gUnknown_0203CF1C = AllocZeroed(sizeof(struct UnkSummaryStruct));
+    gUnknown_0203CF1C->unk40BC = a;
+    gUnknown_0203CF1C->unk0 = b;
+    gUnknown_0203CF1C->unk40BE = c;
+    gUnknown_0203CF1C->unk40BF = d;
+    gUnknown_0203CF1C->unk4 = e;
+    if (a == 2)
+        gUnknown_0203CF1C->unk40BD = 1;
+    else
+        gUnknown_0203CF1C->unk40BD = 0;
+    switch (a)
+    {
+    case 0:
+    case 2:
+        gUnknown_0203CF1C->unk40C1 = 0;
+        gUnknown_0203CF1C->unk40C2 = 3;
+        break;
+    case 1:
+        gUnknown_0203CF1C->unk40C1 = 0;
+        gUnknown_0203CF1C->unk40C2 = 3;
+        gUnknown_0203CF1C->unk40C8 = 1;
+        break;
+    case 3:
+        gUnknown_0203CF1C->unk40C1 = 2;
+        gUnknown_0203CF1C->unk40C2 = 3;
+        gUnknown_0203CF1C->unk40C3 = 1;
+        break;
+    }
+    byte = gUnknown_0203CF1C->unk40C1;
+    gUnknown_0203CF1C->unk40C0 = byte;
+    sub_81C488C(0xFF);
+    if (gMonSpritesGfxPtr == 0)
+        sub_806F2AC(0, 0);
+    SetMainCallback2(sub_81BFAE4);
+}
+
+void sub_81BFA38(void *a, u8 b, u8 c, void *d, u16 e)
+{
+    sub_81BF8EC(3, a, b, c, d);
+    gUnknown_0203CF1C->unk40C4 = e;
+}
+
+void sub_81BFA80(u8 a, void *b, u8 c, u8 d, void *e)
+{
+    sub_81BF8EC(a, b, c, d, e);
+    gUnknown_0203CF1C->unk40EF = 1;
+}
+
+void sub_81BFAB4(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    do_scheduled_bg_tilemap_copies_to_vram();
+    UpdatePaletteFade();
+}
+
+void sub_81BFAD0(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void sub_81BFAE4()
+{
+    while (1)
+    {
+        if (sub_81221EC() == 1 || sub_81BFB10() == TRUE || sub_81221AC() == 1)
+            break;
+    }
+}
+
+bool8 sub_81BFB10(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        SetVBlankHBlankCallbacksToNull();
+        sub_8121DA0();
+        clear_scheduled_bg_copies_to_vram();
+        gMain.state++;
+        break;
+    case 1:
+        remove_some_task();
+        gMain.state++;
+        break;
+    case 2:
+        ResetPaletteFade();
+        gPaletteFade.bufferTransferDisabled = 1;
+        gMain.state++;
+        break;
+    case 3:
+        ResetSpriteData();
+        gMain.state++;
+        break;
+    case 4:
+        FreeAllSpritePalettes();
+        gMain.state++;
+        break;
+    case 5:
+        sub_81BFE24();
+        gUnknown_0203CF1C->unk40F0 = 0;
+        gMain.state++;
+        break;
+    case 6:
+        if (sub_81BFEB0() != 0)
+            gMain.state++;
+        break;
+    case 7:
+        sub_81C2554();
+        gMain.state++;
+        break;
+    case 8:
+        sub_81C1BA0();
+        gMain.state++;
+        break;
+    case 9:
+        sub_81C0098(&gUnknown_0203CF1C->currentMon);
+        gUnknown_0203CF1C->unk40F0 = 0;
+        gMain.state++;
+        break;
+    case 10:
+        if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) != 0)
+            gMain.state++;
+        break;
+    case 11:
+        sub_81C25E8();
+        gMain.state++;
+        break;
+    case 12:
+        sub_81C286C();
+        gMain.state++;
+        break;
+    case 13:
+        sub_81C2D9C(gUnknown_0203CF1C->unk40C0);
+        gMain.state++;
+        break;
+    case 14:
+        sub_81C0348();
+        gMain.state++;
+        break;
+    case 15:
+        sub_81C2AFC(gUnknown_0203CF1C->unk40C0);
+        gMain.state++;
+        break;
+    case 16:
+        sub_81C4190();
+        sub_81C42C8();
+        gUnknown_0203CF1C->unk40F0 = 0;
+        gMain.state++;
+        break;
+    case 17:
+        gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &gUnknown_0203CF1C->unk40F0);
+        if (gUnknown_0203CF1C->unk40D3 != 0xFF)
+        {
+            gUnknown_0203CF1C->unk40F0 = 0;
+            gMain.state++;
+        }
+        break;
+    case 18:
+        sub_81C4984(&gUnknown_0203CF1C->currentMon);
+        gMain.state++;
+        break;
+    case 19:
+        sub_81C4A08(&gUnknown_0203CF1C->currentMon);
+        gMain.state++;
+        break;
+    case 20:
+        sub_81C4A88();
+        gMain.state++;
+        break;
+    case 21:
+        sub_81C4280();
+        gMain.state++;
+        break;
+    case 22:
+        if (gUnknown_0203CF1C->unk40BC != 3)
+            CreateTask(sub_81C0510, 0);
+        else
+            CreateTask(sub_81C171C, 0);
+        gMain.state++;
+        break;
+    case 23:
+        BlendPalettes(-1, 16, 0);
+        gMain.state++;
+        break;
+    case 24:
+        BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+        gPaletteFade.bufferTransferDisabled = 0;
+        gMain.state++;
+        break;
+    default:
+        SetVBlankCallback(sub_81BFAD0);
+        SetMainCallback2(sub_81BFAB4);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_81BFE24()
+{
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, &gUnknown_0861CBB4, 4);
+    SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap2);
+    SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap1);
+    SetBgTilemapBuffer(3, &gUnknown_0203CF1C->unkTilemap0);
+    sub_8121E10();
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+    schedule_bg_copy_tilemap_to_vram(3);
+    SetGpuReg(REG_OFFSET_DISPCNT, 0x1040);
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    ShowBg(0);
+    ShowBg(1);
+    ShowBg(2);
+    ShowBg(3);
+}
+
+u8 sub_81BFEB0()
+{
+    switch (gUnknown_0203CF1C->unk40F0)
+    {
+    case 0:
+        reset_temp_tile_data_buffers();
+        decompress_and_copy_tile_data_to_vram(1, &gUnknown_08D97D0C, 0, 0, 0);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 1:
+        if (free_temp_tile_data_buffers_if_possible() != 1)
+        {
+            LZDecompressWram(&gUnknown_08D9862C, gUnknown_0203CF1C->unkTilemap0);
+            gUnknown_0203CF1C->unk40F0++;
+        }
+        break;
+    case 2:
+        LZDecompressWram(&gUnknown_08D98CC8, gUnknown_0203CF1C->unkTilemap0_1);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 3:
+        LZDecompressWram(&gUnknown_08D987FC, gUnknown_0203CF1C->unkTilemap1_1);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 4:
+        LZDecompressWram(&gUnknown_08D9898C, gUnknown_0203CF1C->unkTilemap2_1);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 5:
+        LZDecompressWram(&gUnknown_08D98B28, gUnknown_0203CF1C->unkTilemap3_1);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 6:
+        LoadCompressedPalette(&gUnknown_08D9853C, 0, 0x100);
+        LoadPalette(&gUnknown_08D85620, 0x81, 0x1E);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 7:
+        LoadCompressedObjectPic(&gUnknown_0861CFBC);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 8:
+        LoadCompressedObjectPic(&gUnknown_0861D074);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 9:
+        LoadCompressedObjectPic(&gUnknown_0861D0F8);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 10:
+        LoadCompressedObjectPalette(&gUnknown_0861D100);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 11:
+        LoadCompressedObjectPalette(&gUnknown_0861D07C);
+        gUnknown_0203CF1C->unk40F0++;
+        break;
+    case 12:
+        LoadCompressedPalette(&gUnknown_08D97B84, 0x1D0, 0x60);
+        gUnknown_0203CF1C->unk40F0 = 0;
+        return 1;
+    }
+    return 0;
+}
+
+void sub_81C0098(struct Pokemon *mon)
+{
+    if (gUnknown_0203CF1C->unk40BD == 0)
+    {
+        struct Pokemon *partyMon = gUnknown_0203CF1C->unk0->mon;
+        *mon = partyMon[gUnknown_0203CF1C->unk40BE];
+    }
+    else
+    {
+        struct BoxPokemon *boxMon = gUnknown_0203CF1C->unk0->boxMon;
+        sub_8069004(&boxMon[gUnknown_0203CF1C->unk40BE], mon);
+    }
+}
+
+bool8 sub_81C00F0(struct Pokemon *a)
+{
+    u32 i;
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    switch (gUnknown_0203CF1C->unk40F0)
+    {
+    case 0:
+        sum->species = GetMonData(a, MON_DATA_SPECIES);
+        sum->species2 = GetMonData(a, MON_DATA_SPECIES2);
+        sum->exp = GetMonData(a, MON_DATA_EXP);
+        sum->level = GetMonData(a, MON_DATA_LEVEL);
+        sum->altAbility = GetMonData(a, MON_DATA_ALT_ABILITY);
+        sum->item = GetMonData(a, MON_DATA_HELD_ITEM);
+        sum->pid = GetMonData(a, MON_DATA_PERSONALITY);
+        sum->sanity = GetMonData(a, MON_DATA_SANITY_BIT1);
+        if (sum->sanity != 0)
+            sum->isEgg = 1;
+        else
+            sum->isEgg = GetMonData(a, MON_DATA_IS_EGG);
+        break;
+    case 1:
+        for (i = 0; i < 4; i++)
+        {
+            sum->moves[i] = GetMonData(a, MON_DATA_MOVE1+i);
+            sum->pp[i] = GetMonData(a, MON_DATA_PP1+i);
+        }
+        sum->ppBonuses = GetMonData(a, MON_DATA_PP_BONUSES);
+        break;
+    case 2:
+        if ((struct Pokemon*)gUnknown_0203CF1C->unk0 == gPlayerParty || gUnknown_0203CF1C->unk40BC == 2 || gUnknown_0203CF1C->unk40EF == 1)
+        {
+            sum->nature = GetNature(a);
+            sum->currentHP = GetMonData(a, MON_DATA_HP);
+            sum->maxHP = GetMonData(a, MON_DATA_MAX_HP);
+            sum->atk = GetMonData(a, MON_DATA_ATK);
+            sum->def = GetMonData(a, MON_DATA_DEF);
+            sum->spatk = GetMonData(a, MON_DATA_SPATK);
+            sum->spdef = GetMonData(a, MON_DATA_SPDEF);
+            sum->speed = GetMonData(a, MON_DATA_SPD);
+        }
+        else
+        {
+            sum->nature = GetNature(a);
+            sum->currentHP = GetMonData(a, MON_DATA_HP);
+            sum->maxHP = GetMonData(a, MON_DATA_MAX_HP);
+            sum->atk = GetMonData(a, MON_DATA_ATK2);
+            sum->def = GetMonData(a, MON_DATA_DEF2);
+            sum->spatk = GetMonData(a, MON_DATA_SPATK2);
+            sum->spdef = GetMonData(a, MON_DATA_SPDEF2);
+            sum->speed = GetMonData(a, MON_DATA_SPD2);
+        }
+        break;
+    case 3:
+        GetMonData(a, MON_DATA_OT_NAME, &sum->OTName);
+        ConvertInternationalString((u8*)&sum->OTName, GetMonData(a, MON_DATA_LANGUAGE));
+        sum->unk7 = sub_81B205C(a);
+        sum->OTGender = GetMonData(a, MON_DATA_OT_GENDER);
+        sum->OTID = GetMonData(a, MON_DATA_OT_ID);
+        sum->metLocation = GetMonData(a, MON_DATA_MET_LOCATION);
+        sum->metLevel = GetMonData(a, MON_DATA_MET_LEVEL);
+        sum->metGame = GetMonData(a, MON_DATA_MET_GAME);
+        sum->friendship = GetMonData(a, MON_DATA_FRIENDSHIP);
+        break;
+    default:
+        sum->ribbons = GetMonData(a, MON_DATA_RIBBON_COUNT);
+        return TRUE;
+    }
+    gUnknown_0203CF1C->unk40F0++;
+    return FALSE;
+}
+
+void sub_81C0348(void)
+{
+    if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3)
+    {
+        sub_81C1DA4(0, 255);
+        sub_81C1EFC(0, 255, 0);
+    }
+    else
+    {
+        sub_81C240C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]);
+        sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0);
+        sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0);
+        SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap3);
+        SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap2);
+        ChangeBgX(2, 0x10000, 1);
+        ClearWindowTilemap(0x13);
+        ClearWindowTilemap(0xD);
+    }
+    if (gUnknown_0203CF1C->summary.unk7 == 0)
+    {
+        sub_81C2074(0, 0xFF);
+    }
+    else
+    {
+        if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3)
+            PutWindowTilemap(0xD);
+    }
+    sub_81C2524();
+    sub_81C2228(&gUnknown_0203CF1C->currentMon);
+}
+
+void sub_81C0434()
+{
+    FreeAllWindowBuffers();
+    Free(gUnknown_0203CF1C);
+}
+
+void sub_81C044C(u8 taskId)
+{
+    BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+    gTasks[taskId].func = sub_81C0484;
+}
+
+void sub_81C0484(u8 taskId)
+{
+    if (sub_81221EC() != 1 && !gPaletteFade.active)
+    {
+        SetMainCallback2(gUnknown_0203CF1C->unk4);
+        gUnknown_0203CF20 = gUnknown_0203CF1C->unk40BE;
+        sub_81C4898();
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        StopCryAndClearCrySongs();
+        m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100);
+        if (gMonSpritesGfxPtr == 0)
+            sub_806F47C(0);
+        sub_81C0434();
+        DestroyTask(taskId);
+    }
+}
+
+void sub_81C0510(u8 taskId)
+{
+    if (sub_81221EC() != 1 && !gPaletteFade.active)
+    {
+        if (gMain.newKeys & DPAD_UP)
+        {
+            sub_81C0604(taskId, -1);
+        }
+        else if (gMain.newKeys & DPAD_DOWN)
+        {
+            sub_81C0604(taskId, 1);
+        }
+        else if ((gMain.newKeys & DPAD_LEFT) || GetLRKeysState() == 1)
+        {
+            sub_81C0A8C(taskId, -1);
+        }
+        else if ((gMain.newKeys & DPAD_RIGHT) || GetLRKeysState() == 2)
+        {
+            sub_81C0A8C(taskId, 1);
+        }
+        else if (gMain.newKeys & A_BUTTON)
+        {
+            if (gUnknown_0203CF1C->unk40C0 != 1)
+            {
+                if (gUnknown_0203CF1C->unk40C0 == 0)
+                {
+                    sub_81C48F0();
+                    PlaySE(SE_SELECT);
+                    sub_81C044C(taskId);
+                }
+                else
+                {
+                    PlaySE(SE_SELECT);
+                    sub_81C0E48(taskId);
+                }
+            }
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            sub_81C48F0();
+            PlaySE(SE_SELECT);
+            sub_81C044C(taskId);
+        }
+    }
+}
+
+void sub_81C0604(u8 taskId, s8 a)
+{
+    s8 r4_2;
+
+    if (gUnknown_0203CF1C->unk40C3 == 0)
+    {
+        if (gUnknown_0203CF1C->unk40BD == 1)
+        {
+            if (gUnknown_0203CF1C->unk40C0 != 0)
+            {
+                if (a == 1)
+                    a = 0;
+                else
+                    a = 2;
+            }
+            else
+            {
+                if (a == 1)
+                    a = 1;
+                else
+                    a = 3;
+            }
+            r4_2 = sub_80D214C(gUnknown_0203CF1C->unk0, gUnknown_0203CF1C->unk40BE, gUnknown_0203CF1C->unk40BF, a);
+        }
+        else if (sub_81B1250() == 1)
+        {
+            r4_2 = sub_81C09B4(a);
+        }
+        else
+        {
+            r4_2 = sub_81C08F8(a);
+        }
+
+        if (r4_2 != -1)
+        {
+            PlaySE(SE_SELECT);
+            if (gUnknown_0203CF1C->summary.unk7 != 0)
+            {
+                sub_81C4204(2, 1);
+                ClearWindowTilemap(0xD);
+                schedule_bg_copy_tilemap_to_vram(0);
+                sub_81C2074(0, 2);
+            }
+            gUnknown_0203CF1C->unk40BE = r4_2;
+            gTasks[taskId].data[0] = 0;
+            gTasks[taskId].func = sub_81C0704;
+        }
+    }
+}
+
+void sub_81C0704(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        StopCryAndClearCrySongs();
+        break;
+    case 1:
+        sub_81C4898();
+        DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D3]);
+        break;
+    case 2:
+        DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D4]);
+        break;
+    case 3:
+        sub_81C0098(&gUnknown_0203CF1C->currentMon);
+        gUnknown_0203CF1C->unk40F0 = 0;
+        break;
+    case 4:
+        if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) == FALSE)
+            return;
+        break;
+    case 5:
+        sub_81C49E0(&gUnknown_0203CF1C->currentMon);
+        break;
+    case 6:
+        sub_81C4A08(&gUnknown_0203CF1C->currentMon);
+        break;
+    case 7:
+        if (gUnknown_0203CF1C->summary.unk7)
+            sub_81C2074(10, -2);
+        sub_81C2228(&gUnknown_0203CF1C->currentMon);
+        data[1] = 0;
+        break;
+    case 8:
+        gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &data[1]);
+        if (gUnknown_0203CF1C->unk40D3 == 0xFF)
+            return;
+        gSprites[gUnknown_0203CF1C->unk40D3].data2 = 1;
+        sub_81C0E24();
+        data[1] = 0;
+        break;
+    case 9:
+        sub_81C4280();
+        break;
+    case 10:
+        sub_81C25E8();
+        break;
+    case 11:
+        sub_81C2D9C(gUnknown_0203CF1C->unk40C0);
+        sub_81C2524();
+        break;
+    case 12:
+        gSprites[gUnknown_0203CF1C->unk40D3].data2 = 0;
+        break;
+    default:
+        if (sub_81221EC() == 0 && FuncIsActiveTask(sub_81C20F0) == 0)
+        {
+            data[0] = 0;
+            gTasks[taskId].func = sub_81C0510;
+        }
+        return;
+    }
+    data[0]++;
+}
+
+s8 sub_81C08F8(s8 a)
+{
+    struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon;
+
+    if (gUnknown_0203CF1C->unk40C0 == 0)
+    {
+        if (a == -1 && gUnknown_0203CF1C->unk40BE == 0)
+            return -1;
+        if (a == 1 && gUnknown_0203CF1C->unk40BE >= gUnknown_0203CF1C->unk40BF)
+            return -1;
+        return gUnknown_0203CF1C->unk40BE + a;
+    }
+    else
+    {
+        s8 index = gUnknown_0203CF1C->unk40BE;
+
+        do
+        {
+            index += a;
+            if (index < 0 || index > gUnknown_0203CF1C->unk40BF)
+                return -1;
+        } while (GetMonData(&mon[index], MON_DATA_IS_EGG) != 0);
+        return index;
+    }
+}
+
+s8 sub_81C09B4(s8 a)
+{
+    struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon;
+    s8 r5 = 0;
+    u8 i;
+
+    for (i = 0; i < 6; i++)
+    {
+        if (gUnknown_0861CC1C[i] == gUnknown_0203CF1C->unk40BE)
+        {
+            r5 = i;
+            break;
+        }
+    }
+
+    while (1)
+    {
+        int b;
+        s8* c = &gUnknown_0861CC1C[0];
+
+        r5 += a;
+        if (r5 < 0 || r5 >= 6)
+            return -1;
+        b = c[r5];
+        if (sub_81C0A50(&mon[b]) == TRUE)
+            return b;
+    }
+}
+
+bool8 sub_81C0A50(struct Pokemon* mon)
+{
+    if (GetMonData(mon, MON_DATA_SPECIES) == 0)
+        return FALSE;
+    else if (gUnknown_0203CF1C->unk40BE != 0 || GetMonData(mon, MON_DATA_IS_EGG) == 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_81C0A8C(u8 taskId, s8 b)
+{
+    struct PokeSummary *summary = &gUnknown_0203CF1C->summary;
+    s16 *data = gTasks[taskId].data;
+
+    if (summary->isEgg)
+        return;
+    if (b == -1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C1)
+        return;
+    if (b == 1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C2)
+        return;
+    PlaySE(SE_SELECT);
+    sub_81C2C38(gUnknown_0203CF1C->unk40C0);
+    gUnknown_0203CF1C->unk40C0 += b;
+    data[0] = 0;
+    if (b == 1)
+        SetTaskFuncWithFollowupFunc(taskId, sub_81C0B8C, gTasks[taskId].func);
+    else
+        SetTaskFuncWithFollowupFunc(taskId, sub_81C0CC4, gTasks[taskId].func);
+    sub_81C2DE4(gUnknown_0203CF1C->unk40C0);
+    sub_81C424C();
+}
+
+void sub_81C0B8C(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        if (gUnknown_0203CF1C->unk40C9 == 0)
+        {
+            data[1] = 1;
+            SetBgAttribute(1, 7, 1);
+            SetBgAttribute(2, 7, 2);
+            schedule_bg_copy_tilemap_to_vram(1);
+        }
+        else
+        {
+            data[1] = 2;
+            SetBgAttribute(2, 7, 1);
+            SetBgAttribute(1, 7, 2);
+            schedule_bg_copy_tilemap_to_vram(2);
+        }
+        ChangeBgX(data[1], 0, 0);
+        SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xBC));
+        ShowBg(1);
+        ShowBg(2);
+    }
+    ChangeBgX(data[1], 0x2000, 1);
+    data[0] += 32;
+    if (data[0] > 0xFF)
+        gTasks[taskId].func = sub_81C0C68;
+}
+
+void sub_81C0C68(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    gUnknown_0203CF1C->unk40C9 ^= 1;
+    data[1] = 0;
+    data[0] = 0;
+    sub_81C1BA0();
+    sub_81C2AFC(gUnknown_0203CF1C->unk40C0);
+    sub_81C4280();
+    sub_81C0E24();
+    SwitchTaskToFollowupFunc(taskId);
+}
+
+void sub_81C0CC4(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        if (gUnknown_0203CF1C->unk40C9 == 0)
+            data[1] = 2;
+        else
+            data[1] = 1;
+        ChangeBgX(data[1], 0x10000, 0);
+    }
+    ChangeBgX(data[1], 0x2000, 2);
+    data[0] += 32;
+    if (data[0] > 0xFF)
+        gTasks[taskId].func = sub_81C0D44;
+}
+
+void sub_81C0D44(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (gUnknown_0203CF1C->unk40C9 == 0)
+    {
+        SetBgAttribute(1, 7, 1);
+        SetBgAttribute(2, 7, 2);
+        schedule_bg_copy_tilemap_to_vram(2);
+    }
+    else
+    {
+        SetBgAttribute(2, 7, 1);
+        SetBgAttribute(1, 7, 2);
+        schedule_bg_copy_tilemap_to_vram(1);
+    }
+    if (gUnknown_0203CF1C->unk40C0 > 1)
+    {
+        SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xFFFFF0BC));
+        ChangeBgX(data[1], 0x10000, 0);
+    }
+    ShowBg(1);
+    ShowBg(2);
+    gUnknown_0203CF1C->unk40C9 ^= 1;
+    data[1] = 0;
+    data[0] = 0;
+    sub_81C1BA0();
+    sub_81C2AFC(gUnknown_0203CF1C->unk40C0);
+    sub_81C4280();
+    sub_81C0E24();
+    SwitchTaskToFollowupFunc(taskId);
+}
+
+void sub_81C0E24()
+{
+    if (gUnknown_0203CF1C->unk40C0 == 1)
+        sub_81C22CC(&gUnknown_0203CF1C->currentMon);
+}
+
+void sub_81C0E48(u8 taskId)
+{
+    u16 move;
+    gUnknown_0203CF1C->unk40C6 = 0;
+    move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+    ClearWindowTilemap(0x13);
+    if (gSprites[gUnknown_0203CF1C->unk40D5].invisible == 0)
+        ClearWindowTilemap(0xD);
+    sub_81C1DA4(9, -3);
+    sub_81C1EFC(9, -3, move);
+    if (gUnknown_0203CF1C->unk40C8 == 0)
+    {
+        ClearWindowTilemap(5);
+        PutWindowTilemap(6);
+    }
+    sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0);
+    sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0);
+    sub_81C3E9C(move);
+    sub_81C3F44();
+    sub_81C44F0();
+    schedule_bg_copy_tilemap_to_vram(0);
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+    sub_81C4AF8(8);
+    gTasks[taskId].func = sub_81C0F44;
+}
+
+void sub_81C0F44(u8 taskId)
+{
+    u8 id = taskId;
+    s16 *data = gTasks[taskId].data;
+
+    if (sub_81221EC() != 1)
+    {
+        if (gMain.newKeys & DPAD_UP)
+        {
+            data[0] = 4;
+            sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6);
+        }
+        else if (gMain.newKeys & DPAD_DOWN)
+        {
+            data[0] = 4;
+            sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6);
+        }
+        else if (gMain.newKeys & A_BUTTON)
+        {
+            if (gUnknown_0203CF1C->unk40C8 == 1
+             || (gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+            {
+                PlaySE(SE_SELECT);
+                sub_81C11F4(taskId);
+            }
+            else if (sub_81C1040() == TRUE)
+            {
+                PlaySE(SE_SELECT);
+                sub_81C129C(taskId);
+            }
+            else
+            {
+                PlaySE(SE_HAZURE);
+            }
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sub_81C11F4(id);
+        }
+    }
+}
+
+bool8 sub_81C1040(void)
+{
+    u8 i;
+    for (i = 1; i < 4; i++)
+    {
+        if (gUnknown_0203CF1C->summary.moves[i] != 0)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_81C1070(s16 *a, s8 b, u8 *c)
+{
+    s8 i;
+    s8 moveIndex;
+    u16 move;
+
+    PlaySE(SE_SELECT);
+    moveIndex = *c;
+    for (i = 0; i < 4; i++)
+    {
+        moveIndex += b;
+        if (moveIndex > a[0])
+            moveIndex = 0;
+        else if (moveIndex < 0)
+            moveIndex = a[0];
+        if (moveIndex == 4)
+        {
+            move = gUnknown_0203CF1C->unk40C4;
+            break;
+        }
+        move = gUnknown_0203CF1C->summary.moves[moveIndex];
+        if (move != 0)
+            break;
+    }
+    sub_81C240C(move);
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+    sub_81C3E9C(move);
+    if ((*c == 4 && gUnknown_0203CF1C->unk40C4 == 0) || a[1] == 1)
+    {
+        ClearWindowTilemap(19);
+        if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+            ClearWindowTilemap(13);
+        schedule_bg_copy_tilemap_to_vram(0);
+        sub_81C1DA4(9, -3);
+        sub_81C1EFC(9, -3, move);
+    }
+    if (*c != 4 && moveIndex == 4 && gUnknown_0203CF1C->unk40C4 == 0)
+    {
+        ClearWindowTilemap(14);
+        ClearWindowTilemap(15);
+        schedule_bg_copy_tilemap_to_vram(0);
+        sub_81C1DA4(0, 3);
+        sub_81C1EFC(0, 3, 0);
+    }
+    *c = moveIndex;
+    if (c == &gUnknown_0203CF1C->unk40C6)
+        sub_81C4D18(8);
+    else
+        sub_81C4D18(18);
+}
+
+void sub_81C11F4(u8 taskId)
+{
+    sub_81C4C60(8);
+    ClearWindowTilemap(6);
+    PutWindowTilemap(5);
+    sub_81C3E9C(0);
+    sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 1);
+    sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 1);
+    sub_81C4064();
+    if (gUnknown_0203CF1C->unk40C6 != 4)
+    {
+        ClearWindowTilemap(14);
+        ClearWindowTilemap(15);
+        sub_81C1DA4(0, 3);
+        sub_81C1EFC(0, 3, 0);
+    }
+    schedule_bg_copy_tilemap_to_vram(0);
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+    gTasks[taskId].func = sub_81C0510;
+}
+
+void sub_81C129C(u8 taskId)
+{
+    gUnknown_0203CF1C->unk40C7 = gUnknown_0203CF1C->unk40C6;
+    sub_81C4C84(1);
+    sub_81C4AF8(18);
+    gTasks[taskId].func = sub_81C12E4;
+}
+
+void sub_81C12E4(u8 taskId)
+{
+    u8 a = taskId;
+    s16* data = gTasks[taskId].data;
+    if (sub_81221EC() != 1)
+    {
+        if (gMain.newKeys & DPAD_UP)
+        {
+            data[0] = 3;
+            sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C7);
+        }
+        else if (gMain.newKeys & DPAD_DOWN)
+        {
+            data[0] = 3;
+            sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C7);
+        }
+        else if (gMain.newKeys & A_BUTTON)
+        {
+            if (gUnknown_0203CF1C->unk40C6 == gUnknown_0203CF1C->unk40C7)
+            {
+                sub_81C13B0(taskId, 0);
+            }
+            else
+                sub_81C13B0(taskId, 1);
+        }
+        else if (gMain.newKeys & B_BUTTON)
+            sub_81C13B0(a, 0);
+    }
+}
+
+void sub_81C13B0(u8 taskId, u8 b)
+{
+    u16 move;
+    PlaySE(SE_SELECT);
+    sub_81C4C84(0);
+    sub_81C4C60(18);
+    if (b == 1)
+    {
+        if (gUnknown_0203CF1C->unk40BD == 0)
+        {
+            struct Pokemon *why = gUnknown_0203CF1C->unk0->mon;
+            sub_81C14BC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7);
+        }
+        else
+        {
+            struct BoxPokemon *why = gUnknown_0203CF1C->unk0->boxMon;
+            sub_81C15EC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7);
+        }
+        sub_81C0098(&gUnknown_0203CF1C->currentMon);
+        sub_81C40A0(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7);
+        sub_81C4568(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7);
+        gUnknown_0203CF1C->unk40C6 = gUnknown_0203CF1C->unk40C7;
+    }
+    move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+    sub_81C3E9C(move);
+    sub_81C240C(move);
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+    gTasks[taskId].func = sub_81C0F44;
+}
+
+
+#ifdef NONMATCHING
+void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId)
+{
+    u16 localMoveTo;
+    u16 localMoveFrom;
+    u8 localPpTo;
+    u8 localPpFrom;
+    u8 localPpBonuses;
+    u16* moveFromPtr;
+    u16* moveToPtr;
+    u8* ppFromPtr;
+    u8* ppToPtr;
+    u8* ppBonusesPtr;
+
+    moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId];
+    localMoveFrom = *moveFromPtr;
+
+    moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId];
+    localMoveTo = *moveToPtr;
+
+    ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId];
+    localPpFrom = *ppFromPtr;
+
+    ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId];
+    localPpTo = *ppToPtr;
+
+    ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses;
+    localPpBonuses = *ppBonusesPtr;
+
+{
+    u8 bitsFrom, bitsTo;
+
+    bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1);
+    bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1);
+
+
+    localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]);
+    localPpBonuses &= ~(gUnknown_08329D22[swappingToId]);
+
+    localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1)));
+}
+
+    SetMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo);
+    SetMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom);
+
+    SetMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo);
+    SetMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom);
+
+    SetMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses);
+
+    *moveFromPtr = localMoveTo;
+    *moveToPtr = localMoveFrom;
+
+    *ppFromPtr = localPpTo;
+    *ppToPtr = localPpFrom;
+
+    *ppBonusesPtr = localPpBonuses;
+}
+#else
+__attribute__((naked))
+void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+	mov r7, r10\n\
+	mov r6, r9\n\
+	mov r5, r8\n\
+	push {r5-r7}\n\
+	sub sp, 0x28\n\
+	adds r7, r0, 0\n\
+	adds r4, r1, 0\n\
+	adds r6, r2, 0\n\
+	lsls r4, 24\n\
+	lsrs r4, 24\n\
+	lsls r6, 24\n\
+	lsrs r6, 24\n\
+	ldr r0, =gUnknown_0203CF1C\n\
+	ldr r2, [r0]\n\
+	lsls r0, r4, 1\n\
+	mov r10, r0\n\
+	adds r1, r2, 0\n\
+	adds r1, 0x84\n\
+	adds r0, r1, r0\n\
+	str r0, [sp, 0x8]\n\
+	ldrh r0, [r0]\n\
+	mov r3, sp\n\
+	adds r3, 0x2\n\
+	str r3, [sp, 0x1C]\n\
+	strh r0, [r3]\n\
+	lsls r0, r6, 1\n\
+	mov r9, r0\n\
+	add r1, r9\n\
+	str r1, [sp, 0xC]\n\
+	ldrh r1, [r1]\n\
+	mov r0, sp\n\
+	strh r1, [r0]\n\
+	adds r1, r2, 0\n\
+	adds r1, 0x8C\n\
+	adds r3, r1, r4\n\
+	str r3, [sp, 0x10]\n\
+	ldrb r0, [r3]\n\
+	mov r3, sp\n\
+	adds r3, 0x5\n\
+	str r3, [sp, 0x24]\n\
+	strb r0, [r3]\n\
+	adds r1, r6\n\
+	str r1, [sp, 0x14]\n\
+	ldrb r0, [r1]\n\
+	mov r1, sp\n\
+	adds r1, 0x4\n\
+	str r1, [sp, 0x20]\n\
+	strb r0, [r1]\n\
+	adds r2, 0xA4\n\
+	str r2, [sp, 0x18]\n\
+	ldrb r0, [r2]\n\
+	mov r5, sp\n\
+	adds r5, 0x6\n\
+	strb r0, [r5]\n\
+	ldr r1, =gUnknown_08329D22\n\
+	adds r0, r4, r1\n\
+	ldrb r0, [r0]\n\
+	mov r8, r0\n\
+	ldrb r0, [r5]\n\
+	adds r2, r0, 0\n\
+	mov r3, r8\n\
+	ands r2, r3\n\
+	mov r3, r10\n\
+	asrs r2, r3\n\
+	lsls r2, 24\n\
+	lsrs r2, 24\n\
+	adds r1, r6, r1\n\
+	ldrb r1, [r1]\n\
+	mov r12, r1\n\
+	adds r1, r0, 0\n\
+	mov r3, r12\n\
+	ands r1, r3\n\
+	mov r3, r9\n\
+	asrs r1, r3\n\
+	lsls r1, 24\n\
+	lsrs r1, 24\n\
+	mov r3, r8\n\
+	bics r0, r3\n\
+	strb r0, [r5]\n\
+	ldrb r0, [r5]\n\
+	mov r3, r12\n\
+	bics r0, r3\n\
+	strb r0, [r5]\n\
+	mov r0, r9\n\
+	lsls r2, r0\n\
+	mov r3, r10\n\
+	lsls r1, r3\n\
+	adds r2, r1\n\
+	ldrb r0, [r5]\n\
+	orrs r0, r2\n\
+	strb r0, [r5]\n\
+	adds r1, r4, 0\n\
+	adds r1, 0xD\n\
+	adds r0, r7, 0\n\
+	mov r2, sp\n\
+	bl SetMonData\n\
+	adds r1, r6, 0\n\
+	adds r1, 0xD\n\
+	adds r0, r7, 0\n\
+	ldr r2, [sp, 0x1C]\n\
+	bl SetMonData\n\
+	adds r4, 0x11\n\
+	adds r0, r7, 0\n\
+	adds r1, r4, 0\n\
+	ldr r2, [sp, 0x20]\n\
+	bl SetMonData\n\
+	adds r6, 0x11\n\
+	adds r0, r7, 0\n\
+	adds r1, r6, 0\n\
+	ldr r2, [sp, 0x24]\n\
+	bl SetMonData\n\
+	adds r0, r7, 0\n\
+	movs r1, 0x15\n\
+	adds r2, r5, 0\n\
+	bl SetMonData\n\
+	mov r0, sp\n\
+	ldrh r0, [r0]\n\
+	ldr r1, [sp, 0x8]\n\
+	strh r0, [r1]\n\
+	ldr r3, [sp, 0x1C]\n\
+	ldrh r0, [r3]\n\
+	ldr r1, [sp, 0xC]\n\
+	strh r0, [r1]\n\
+	ldr r3, [sp, 0x20]\n\
+	ldrb r0, [r3]\n\
+	ldr r1, [sp, 0x10]\n\
+	strb r0, [r1]\n\
+	ldr r3, [sp, 0x24]\n\
+	ldrb r0, [r3]\n\
+	ldr r1, [sp, 0x14]\n\
+	strb r0, [r1]\n\
+	ldrb r0, [r5]\n\
+	ldr r3, [sp, 0x18]\n\
+	strb r0, [r3]\n\
+	add sp, 0x28\n\
+	pop {r3-r5}\n\
+	mov r8, r3\n\
+	mov r9, r4\n\
+	mov r10, r5\n\
+	pop {r4-r7}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+#ifdef NONMATCHING
+void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId)
+{
+    u16 localMoveTo;
+    u16 localMoveFrom;
+    u8 localPpTo;
+    u8 localPpFrom;
+    u8 localPpBonuses;
+    u16* moveFromPtr;
+    u16* moveToPtr;
+    u8* ppFromPtr;
+    u8* ppToPtr;
+    u8* ppBonusesPtr;
+
+    moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId];
+    localMoveFrom = *moveFromPtr;
+
+    moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId];
+    localMoveTo = *moveToPtr;
+
+    ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId];
+    localPpFrom = *ppFromPtr;
+
+    ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId];
+    localPpTo = *ppToPtr;
+
+    ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses;
+    localPpBonuses = *ppBonusesPtr;
+
+{
+    u8 bitsFrom, bitsTo;
+
+    bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1);
+    bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1);
+
+
+    localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]);
+    localPpBonuses &= ~(gUnknown_08329D22[swappingToId]);
+
+    localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1)));
+}
+
+    SetBoxMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo);
+    SetBoxMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom);
+
+    SetBoxMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo);
+    SetBoxMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom);
+
+    SetBoxMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses);
+
+    *moveFromPtr = localMoveTo;
+    *moveToPtr = localMoveFrom;
+
+    *ppFromPtr = localPpTo;
+    *ppToPtr = localPpFrom;
+
+    *ppBonusesPtr = localPpBonuses;
+}
+#else
+__attribute__((naked))
+void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+	mov r7, r10\n\
+	mov r6, r9\n\
+	mov r5, r8\n\
+	push {r5-r7}\n\
+	sub sp, 0x28\n\
+	adds r7, r0, 0\n\
+	adds r4, r1, 0\n\
+	adds r6, r2, 0\n\
+	lsls r4, 24\n\
+	lsrs r4, 24\n\
+	lsls r6, 24\n\
+	lsrs r6, 24\n\
+	ldr r0, =gUnknown_0203CF1C\n\
+	ldr r2, [r0]\n\
+	lsls r0, r4, 1\n\
+	mov r10, r0\n\
+	adds r1, r2, 0\n\
+	adds r1, 0x84\n\
+	adds r0, r1, r0\n\
+	str r0, [sp, 0x8]\n\
+	ldrh r0, [r0]\n\
+	mov r3, sp\n\
+	adds r3, 0x2\n\
+	str r3, [sp, 0x1C]\n\
+	strh r0, [r3]\n\
+	lsls r0, r6, 1\n\
+	mov r9, r0\n\
+	add r1, r9\n\
+	str r1, [sp, 0xC]\n\
+	ldrh r1, [r1]\n\
+	mov r0, sp\n\
+	strh r1, [r0]\n\
+	adds r1, r2, 0\n\
+	adds r1, 0x8C\n\
+	adds r3, r1, r4\n\
+	str r3, [sp, 0x10]\n\
+	ldrb r0, [r3]\n\
+	mov r3, sp\n\
+	adds r3, 0x5\n\
+	str r3, [sp, 0x24]\n\
+	strb r0, [r3]\n\
+	adds r1, r6\n\
+	str r1, [sp, 0x14]\n\
+	ldrb r0, [r1]\n\
+	mov r1, sp\n\
+	adds r1, 0x4\n\
+	str r1, [sp, 0x20]\n\
+	strb r0, [r1]\n\
+	adds r2, 0xA4\n\
+	str r2, [sp, 0x18]\n\
+	ldrb r0, [r2]\n\
+	mov r5, sp\n\
+	adds r5, 0x6\n\
+	strb r0, [r5]\n\
+	ldr r1, =gUnknown_08329D22\n\
+	adds r0, r4, r1\n\
+	ldrb r0, [r0]\n\
+	mov r8, r0\n\
+	ldrb r0, [r5]\n\
+	adds r2, r0, 0\n\
+	mov r3, r8\n\
+	ands r2, r3\n\
+	mov r3, r10\n\
+	asrs r2, r3\n\
+	lsls r2, 24\n\
+	lsrs r2, 24\n\
+	adds r1, r6, r1\n\
+	ldrb r1, [r1]\n\
+	mov r12, r1\n\
+	adds r1, r0, 0\n\
+	mov r3, r12\n\
+	ands r1, r3\n\
+	mov r3, r9\n\
+	asrs r1, r3\n\
+	lsls r1, 24\n\
+	lsrs r1, 24\n\
+	mov r3, r8\n\
+	bics r0, r3\n\
+	strb r0, [r5]\n\
+	ldrb r0, [r5]\n\
+	mov r3, r12\n\
+	bics r0, r3\n\
+	strb r0, [r5]\n\
+	mov r0, r9\n\
+	lsls r2, r0\n\
+	mov r3, r10\n\
+	lsls r1, r3\n\
+	adds r2, r1\n\
+	ldrb r0, [r5]\n\
+	orrs r0, r2\n\
+	strb r0, [r5]\n\
+	adds r1, r4, 0\n\
+	adds r1, 0xD\n\
+	adds r0, r7, 0\n\
+	mov r2, sp\n\
+	bl SetBoxMonData\n\
+	adds r1, r6, 0\n\
+	adds r1, 0xD\n\
+	adds r0, r7, 0\n\
+	ldr r2, [sp, 0x1C]\n\
+	bl SetBoxMonData\n\
+	adds r4, 0x11\n\
+	adds r0, r7, 0\n\
+	adds r1, r4, 0\n\
+	ldr r2, [sp, 0x20]\n\
+	bl SetBoxMonData\n\
+	adds r6, 0x11\n\
+	adds r0, r7, 0\n\
+	adds r1, r6, 0\n\
+	ldr r2, [sp, 0x24]\n\
+	bl SetBoxMonData\n\
+	adds r0, r7, 0\n\
+	movs r1, 0x15\n\
+	adds r2, r5, 0\n\
+	bl SetBoxMonData\n\
+	mov r0, sp\n\
+	ldrh r0, [r0]\n\
+	ldr r1, [sp, 0x8]\n\
+	strh r0, [r1]\n\
+	ldr r3, [sp, 0x1C]\n\
+	ldrh r0, [r3]\n\
+	ldr r1, [sp, 0xC]\n\
+	strh r0, [r1]\n\
+	ldr r3, [sp, 0x20]\n\
+	ldrb r0, [r3]\n\
+	ldr r1, [sp, 0x10]\n\
+	strb r0, [r1]\n\
+	ldr r3, [sp, 0x24]\n\
+	ldrb r0, [r3]\n\
+	ldr r1, [sp, 0x14]\n\
+	strb r0, [r1]\n\
+	ldrb r0, [r5]\n\
+	ldr r3, [sp, 0x18]\n\
+	strb r0, [r3]\n\
+	add sp, 0x28\n\
+	pop {r3-r5}\n\
+	mov r8, r3\n\
+	mov r9, r4\n\
+	mov r10, r5\n\
+	pop {r4-r7}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+    .syntax divided\n");
+}
+#endif
+
+void sub_81C171C(u8 taskId)
+{
+    sub_81C44F0();
+    sub_81C4AF8(8);
+    gTasks[taskId].func = sub_81C174C;
+}
+
+void sub_81C174C(u8 taskId)
+{
+    s16* data = gTasks[taskId].data;
+    
+    if (sub_81221EC() != 1)
+    {
+        if (gPaletteFade.active != 1)
+        {
+            if (gMain.newKeys & DPAD_UP)
+            {
+                data[0] = 4;
+                sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6);
+            }
+            else if (gMain.newKeys & DPAD_DOWN)
+            {
+                data[0] = 4;
+                sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6);
+            }
+            else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1)
+            {
+                sub_81C0A8C(taskId, -1);
+            }
+            else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2)
+            {
+                sub_81C0A8C(taskId, 1);
+            }
+            else if (gMain.newKeys & A_BUTTON)
+            {
+                if (sub_81C18A8() == TRUE)
+                {
+                    sub_81C48F0();
+                    PlaySE(SE_SELECT);
+                    gUnknown_0203CF21 = gUnknown_0203CF1C->unk40C6;
+                    gSpecialVar_0x8005 = gUnknown_0203CF21;
+                    sub_81C044C(taskId);
+                }
+                else
+                {
+                    PlaySE(0x20);
+                    sub_81C18F4(taskId);
+                }
+            }
+            else if (gMain.newKeys & B_BUTTON)
+            {
+                u32 var1;
+                sub_81C48F0();
+                PlaySE(SE_SELECT);
+                gUnknown_0203CF21 = 4;
+                gSpecialVar_0x8005 = 4;
+                sub_81C044C(taskId);
+            }   
+        }
+    }
+}
+
+bool8 sub_81C18A8()
+{
+    if (gUnknown_0203CF1C->unk40C6 == 4 || gUnknown_0203CF1C->unk40C4 == 0 || sub_81B6D14(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]) != 1)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_81C18F4(u8 taskId)
+{
+    ClearWindowTilemap(14);
+    ClearWindowTilemap(15);
+    schedule_bg_copy_tilemap_to_vram(0);
+    sub_81C1DA4(0, 3);
+    sub_81C1EFC(0, 3, 0);
+    sub_81C4154();
+    gTasks[taskId].func = sub_81C1940;
+}
+
+void sub_81C1940(u8 taskId)
+{
+    s16* data = gTasks[taskId].data;
+    u16 move;
+    if (FuncIsActiveTask(sub_81C1E20) != 1)
+    {
+        if (gMain.newKeys & DPAD_UP)
+        {
+            data[1] = 1;
+            data[0] = 4;
+            sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C6);
+            data[1] = 0;
+            gTasks[taskId].func = sub_81C174C;
+        }
+        else if (gMain.newKeys & DPAD_DOWN)
+        {
+            data[1] = 1;
+            data[0] = 4;
+            sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C6);
+            data[1] = 0;
+            gTasks[taskId].func = sub_81C174C;
+        }
+        else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1)
+        {
+            if (gUnknown_0203CF1C->unk40C0 != 2)
+            {
+                
+                ClearWindowTilemap(19);
+                if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+                    ClearWindowTilemap(13);
+                move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+                gTasks[taskId].func = sub_81C174C;
+                sub_81C0A8C(taskId, -1);
+                sub_81C1DA4(9, -2);
+                sub_81C1EFC(9, -2, move);
+            }
+        }
+        else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2)
+        {
+            if (gUnknown_0203CF1C->unk40C0 != 3)
+            {
+                ClearWindowTilemap(19);
+                if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+                    ClearWindowTilemap(13);
+                move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+                gTasks[taskId].func = sub_81C174C;
+                sub_81C0A8C(taskId, 1);
+                sub_81C1DA4(9, -2);
+                sub_81C1EFC(9, -2, move);
+            }
+        }
+        else if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+        {
+            ClearWindowTilemap(19);
+            if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+                ClearWindowTilemap(13);
+            move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+            sub_81C3E9C(move);
+            schedule_bg_copy_tilemap_to_vram(0);
+            sub_81C1DA4(9, -3);
+            sub_81C1EFC(9, -3, move);
+            gTasks[taskId].func = sub_81C174C;
+        }
+    }
+}
+
+u8 sub_81C1B94()
+{
+    return gUnknown_0203CF21;
+}
+
+void sub_81C1BA0()
+{
+    u16 *alloced = Alloc(32);
+    u8 i;
+    for (i = 0; i < 4; i++)
+    {
+        u8 j = i << 1;
+        if (i < gUnknown_0203CF1C->unk40C1)
+        {
+            alloced[j+0] = 0x40;
+            alloced[j+1] = 0x40;
+            alloced[j+8] = 0x50;
+            alloced[j+9] = 0x50;
+        }
+        else if (i > gUnknown_0203CF1C->unk40C2)
+        {
+            alloced[j+0] = 0x4A;
+            alloced[j+1] = 0x4A;
+            alloced[j+8] = 0x5A;
+            alloced[j+9] = 0x5A;
+        }
+        else if (i < gUnknown_0203CF1C->unk40C0)
+        {
+            alloced[j+0] = 0x46;
+            alloced[j+1] = 0x47;
+            alloced[j+8] = 0x56;
+            alloced[j+9] = 0x57;
+        }
+        else if (i == gUnknown_0203CF1C->unk40C0)
+        {
+            if (i != gUnknown_0203CF1C->unk40C2)
+            {
+                alloced[j+0] = 0x41;
+                alloced[j+1] = 0x42;
+                alloced[j+8] = 0x51;
+                alloced[j+9] = 0x52;
+            }
+            else
+            {
+                alloced[j+0] = 0x4B;
+                alloced[j+1] = 0x4C;
+                alloced[j+8] = 0x5B;
+                alloced[j+9] = 0x5C;
+            }
+        }
+        else if (i != gUnknown_0203CF1C->unk40C2)
+        {
+            alloced[j+0] = 0x43;
+            alloced[j+1] = 0x44;
+            alloced[j+8] = 0x53;
+            alloced[j+9] = 0x54;
+        }
+        else
+        {
+            alloced[j+0] = 0x48;
+            alloced[j+1] = 0x49;
+            alloced[j+8] = 0x58;
+            alloced[j+9] = 0x59;
+        }
+    }
+    CopyToBgTilemapBufferRect_ChangePalette(3, alloced, 11, 0, 8, 2, 16);
+    schedule_bg_copy_tilemap_to_vram(3);
+    Free(alloced);
+}
+
+struct UnkStruct_61CC04
+{
+    u8 *ptr;
+    u8 field_4;
+    u8 field_5;
+    u8 field_6;
+    u8 field_7;
+    u8 field_8;
+    u8 field_9;
+};
+
+#ifdef NONMATCHING
+void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d)
+{
+    u8 *alloced = Alloc(a->field_6 * (a->field_7 << 1));
+    CpuFill16(a->field_4, alloced, a->field_7*a->field_6);
+    if (a->field_6 != c)
+    {
+        if (!d)
+        {
+            for (d;d < a->field_7; d++)
+            {
+                CpuCopy16(&a->ptr + ((c + a->field_6*d)), alloced + ((a->field_6*d) << 1), (a->field_6 - c) * 2);
+            }
+        }
+        else
+        {
+            for (d = 0;d < a->field_7; d++)
+            {
+                CpuCopy16(&a->ptr + (a->field_6*d), alloced + ((c + a->field_6*d) << 1), (a->field_6 - c) * 2);
+            }
+        }
+    }
+    d = 0;
+    while (d < a->field_7)
+    {
+        CpuCopy16(alloced + ((a->field_6*d) << 1), b + ((((a->field_9 + d) << 5) + a->field_8) << 1), a->field_6 * 2);
+        d++;
+    }
+    Free(alloced);
+}
+#else
+__attribute__((naked))
+void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d)
+{
+    asm(".syntax unified\n\
+        push {r4-r7,lr}\n\
+	mov r7, r8\n\
+	push {r7}\n\
+	sub sp, 0x4\n\
+	adds r4, r0, 0\n\
+	mov r8, r1\n\
+	lsls r2, 24\n\
+	lsrs r6, r2, 24\n\
+	lsls r3, 24\n\
+	lsrs r5, r3, 24\n\
+	ldrb r1, [r4, 0x6]\n\
+	ldrb r0, [r4, 0x7]\n\
+	lsls r0, 1\n\
+	muls r0, r1\n\
+	bl Alloc\n\
+	adds r7, r0, 0\n\
+	mov r1, sp\n\
+	ldrh r0, [r4, 0x4]\n\
+	strh r0, [r1]\n\
+	ldrb r1, [r4, 0x7]\n\
+	ldrb r0, [r4, 0x6]\n\
+	adds r2, r1, 0\n\
+	muls r2, r0\n\
+	movs r0, 0x80\n\
+	lsls r0, 17\n\
+	orrs r2, r0\n\
+	mov r0, sp\n\
+	adds r1, r7, 0\n\
+	bl CpuSet\n\
+	ldrb r0, [r4, 0x6]\n\
+	cmp r0, r6\n\
+	beq _081C1D60\n\
+	cmp r5, 0\n\
+	bne _081C1D30\n\
+	movs r5, 0\n\
+	ldrb r0, [r4, 0x7]\n\
+	cmp r5, r0\n\
+	bcs _081C1D60\n\
+_081C1D00:\n\
+	ldrb r2, [r4, 0x6]\n\
+	adds r1, r2, 0\n\
+	muls r1, r5\n\
+	adds r3, r6, r1\n\
+	lsls r3, 1\n\
+	ldr r0, [r4]\n\
+	adds r0, r3\n\
+	lsls r1, 1\n\
+	adds r1, r7, r1\n\
+	subs r2, r6\n\
+	ldr r3, =0x001fffff\n\
+	ands r2, r3\n\
+	bl CpuSet\n\
+	adds r0, r5, 0x1\n\
+	lsls r0, 16\n\
+	lsrs r5, r0, 16\n\
+	ldrb r3, [r4, 0x7]\n\
+	cmp r5, r3\n\
+	bcc _081C1D00\n\
+	b _081C1D60\n\
+	.pool\n\
+_081C1D30:\n\
+	movs r5, 0\n\
+	ldrb r0, [r4, 0x7]\n\
+	cmp r5, r0\n\
+	bcs _081C1D60\n\
+_081C1D38:\n\
+	ldrb r2, [r4, 0x6]\n\
+	adds r1, r2, 0\n\
+	muls r1, r5\n\
+	lsls r3, r1, 1\n\
+	ldr r0, [r4]\n\
+	adds r0, r3\n\
+	adds r1, r6, r1\n\
+	lsls r1, 1\n\
+	adds r1, r7, r1\n\
+	subs r2, r6\n\
+	ldr r3, =0x001fffff\n\
+	ands r2, r3\n\
+	bl CpuSet\n\
+	adds r0, r5, 0x1\n\
+	lsls r0, 16\n\
+	lsrs r5, r0, 16\n\
+	ldrb r3, [r4, 0x7]\n\
+	cmp r5, r3\n\
+	bcc _081C1D38\n\
+_081C1D60:\n\
+	movs r5, 0\n\
+	b _081C1D8A\n\
+	.pool\n\
+_081C1D68:\n\
+	ldrb r2, [r4, 0x6]\n\
+	adds r0, r2, 0\n\
+	muls r0, r5\n\
+	lsls r0, 1\n\
+	adds r0, r7, r0\n\
+	ldrb r1, [r4, 0x9]\n\
+	adds r1, r5\n\
+	lsls r1, 5\n\
+	ldrb r3, [r4, 0x8]\n\
+	adds r1, r3\n\
+	lsls r1, 1\n\
+	add r1, r8\n\
+	bl CpuSet\n\
+	adds r0, r5, 0x1\n\
+	lsls r0, 16\n\
+	lsrs r5, r0, 16\n\
+_081C1D8A:\n\
+	ldrb r0, [r4, 0x7]\n\
+	cmp r5, r0\n\
+	bcc _081C1D68\n\
+	adds r0, r7, 0\n\
+	bl Free\n\
+	add sp, 0x4\n\
+	pop {r3}\n\
+	mov r8, r3\n\
+	pop {r4-r7}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.syntax divided\n");
+}
+#endif
+
+void sub_81C1DA4(u16 a, s16 b)
+{
+    if (b > gUnknown_0861CC04.field_6)
+        b = gUnknown_0861CC04.field_6;
+    if (b == 0 || b == gUnknown_0861CC04.field_6)
+    {
+        sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], b, 1);
+    }
+    else
+    {
+        u8 taskId = FindTaskIdByFunc(sub_81C1E20);
+        if (taskId == 0xFF)
+        {
+            taskId = CreateTask(sub_81C1E20, 8);
+        }
+        gTasks[taskId].data[0] = b;
+        gTasks[taskId].data[1] = a;
+    }
+}
+
+void sub_81C1E20(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    data[1] += data[0];
+    if (data[1] < 0)
+    {
+        data[1] = 0;
+    }
+    else if (data[1] > gUnknown_0861CC04.field_6)
+    {
+        data[1] = gUnknown_0861CC04.field_6;
+    }
+    sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], data[1], 1);
+    if (data[1] <= 0 || data[1] >= gUnknown_0861CC04.field_6)
+    {
+        if (data[0] < 0)
+        {
+            if (gUnknown_0203CF1C->unk40C0 == 2)
+                PutWindowTilemap(14);
+            
+        }
+        else
+        {
+            if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+                PutWindowTilemap(13);
+            PutWindowTilemap(19);
+        }
+        schedule_bg_copy_tilemap_to_vram(0);
+        DestroyTask(taskId);
+    }
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+}
+
+void sub_81C1EFC(u16 a, s16 b, u16 move)
+{
+    if (b > gUnknown_0861CC10.field_6)
+        b = gUnknown_0861CC10.field_6;
+    if (b == 0 || b == gUnknown_0861CC10.field_6)
+        sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], b, 1);
+    else
+    {
+        u8 taskId = FindTaskIdByFunc(sub_81C1F80);
+        if (taskId == 0xFF)
+            taskId = CreateTask(sub_81C1F80, 8);
+        gTasks[taskId].data[0] = b;
+        gTasks[taskId].data[1] = a;
+        gTasks[taskId].data[2] = move;
+    }
+}
+
+void sub_81C1F80(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    data[1] += data[0];
+    if (data[1] < 0)
+    {
+        data[1] = 0;
+    }
+    else if (data[1] > gUnknown_0861CC10.field_6)
+    {
+        data[1] = gUnknown_0861CC10.field_6;
+    }
+    sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], data[1], 1);
+    if (data[1] <= 0 || data[1] >= gUnknown_0861CC10.field_6)
+    {
+        if (data[0] < 0)
+        {
+            if (gUnknown_0203CF1C->unk40C0 == 3 && FuncIsActiveTask(sub_81C0B8C) == 0)
+                PutWindowTilemap(15);
+            sub_81C240C(data[2]);
+        }
+        else 
+        {
+            if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible)
+            {
+                PutWindowTilemap(13);
+            }
+            PutWindowTilemap(19);
+        }
+        schedule_bg_copy_tilemap_to_vram(0);
+        DestroyTask(taskId);
+    }
+    schedule_bg_copy_tilemap_to_vram(1);
+    schedule_bg_copy_tilemap_to_vram(2);
+}
+
+void sub_81C2074(u16 a, s16 b)
+{
+    if (b > gUnknown_0861CBEC.field_6)
+        b = gUnknown_0861CBEC.field_6;
+    if (b == 0 || b == gUnknown_0861CBEC.field_6)
+    {
+        sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], b, 0);
+        sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], b, 0);
+    }
+    else
+    {
+        u8 taskId = CreateTask(sub_81C20F0, 8);
+        gTasks[taskId].data[0] = b;
+        gTasks[taskId].data[1] = a;
+    }
+}
+
+void sub_81C20F0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    data[1] += data[0];
+    if (data[1] < 0)
+        data[1] = 0;
+    else if (data[1] > gUnknown_0861CBEC.field_6)
+        data[1] = gUnknown_0861CBEC.field_6;
+    sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0);
+    sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0);
+    schedule_bg_copy_tilemap_to_vram(3);
+    if (data[1] <= 0 || data[1] >= gUnknown_0861CBEC.field_6)
+    {
+        if (data[0] < 0)
+        {
+            sub_81C4A88();
+            PutWindowTilemap(13);
+            schedule_bg_copy_tilemap_to_vram(0);
+        }
+        DestroyTask(taskId);
+    }
+}
+
+// somebody send help this is a complete fucking mess
+#ifdef NONMATCHING
+void sub_81C2194(u16 *a, u16 b, u8 c)
+{
+    u16 i;
+    int var;
+    b *= 0x1000;
+    var = 0x56A;
+
+    if (c == 0)
+    {
+        for (i = 0; i < 20; i++)
+        {
+            a[(i + var) << 1] = gUnknown_08DC3CD4[i] + b;
+            a[((i + var) << 1) + 0x40] = gUnknown_08DC3CD4[i] + b;
+            a[((i + var) << 1) + 0x80] = gUnknown_08DC3CD4[i + 20] + b;
+        }
+    }
+    else
+    {
+        for (i = 0; i < 20; i++)
+        {
+            a[(i + var)] = gUnknown_08DC3CD4[i + 20] + b;
+            a[((i + var)) + 0x40] = gUnknown_08DC3CD4[i + 40] + b;
+            a[((i + var)) + 0x80] = gUnknown_08DC3CD4[i + 40] + b;
+        }
+    }
+}
+#else
+__attribute__((naked))
+void sub_81C2194(u16 *a, u16 b, u8 c)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+	adds r6, r0, 0\n\
+	lsls r2, 24\n\
+	lsls r1, 28\n\
+	lsrs r4, r1, 16\n\
+	ldr r7, =0x0000056a\n\
+	cmp r2, 0\n\
+	bne _081C21E4\n\
+	movs r3, 0\n\
+	ldr r5, =gUnknown_08DC3CD4\n\
+_081C21A8:\n\
+	adds r2, r7, r3\n\
+	lsls r2, 1\n\
+	adds r2, r6\n\
+	lsls r0, r3, 1\n\
+	adds r0, r5\n\
+	ldrh r1, [r0]\n\
+	adds r1, r4, r1\n\
+	strh r1, [r2]\n\
+	adds r0, r2, 0\n\
+	adds r0, 0x40\n\
+	strh r1, [r0]\n\
+	adds r2, 0x80\n\
+	adds r0, r3, 0\n\
+	adds r0, 0x14\n\
+	lsls r0, 1\n\
+	adds r0, r5\n\
+	ldrh r0, [r0]\n\
+	adds r0, r4, r0\n\
+	strh r0, [r2]\n\
+	adds r0, r3, 0x1\n\
+	lsls r0, 16\n\
+	lsrs r3, r0, 16\n\
+	cmp r3, 0x13\n\
+	bls _081C21A8\n\
+	b _081C221C\n\
+	.pool\n\
+_081C21E4:\n\
+	movs r3, 0\n\
+	ldr r5, =gUnknown_08DC3CD4\n\
+_081C21E8:\n\
+	adds r1, r7, r3\n\
+	lsls r1, 1\n\
+	adds r1, r6\n\
+	adds r0, r3, 0\n\
+	adds r0, 0x14\n\
+	lsls r0, 1\n\
+	adds r0, r5\n\
+	ldrh r0, [r0]\n\
+	adds r0, r4, r0\n\
+	strh r0, [r1]\n\
+	adds r2, r1, 0\n\
+	adds r2, 0x40\n\
+	adds r0, r3, 0\n\
+	adds r0, 0x28\n\
+	lsls r0, 1\n\
+	adds r0, r5\n\
+	ldrh r0, [r0]\n\
+	adds r0, r4, r0\n\
+	strh r0, [r2]\n\
+	adds r1, 0x80\n\
+	strh r0, [r1]\n\
+	adds r0, r3, 0x1\n\
+	lsls r0, 16\n\
+	lsrs r3, r0, 16\n\
+	cmp r3, 0x13\n\
+	bls _081C21E8\n\
+_081C221C:\n\
+	pop {r4-r7}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+void sub_81C2228(struct Pokemon *mon)
+{
+    if (!CheckPartyPokerus(mon, 0) && CheckPartyHasHadPokerus(mon, 0))
+    {
+        gUnknown_0203CF1C->unkTilemap0[0x223] = 0x2C;
+        gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x2C;
+    }
+    else
+    {
+        gUnknown_0203CF1C->unkTilemap0[0x223] = 0x81A;
+        gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x81A;
+    }
+    schedule_bg_copy_tilemap_to_vram(3);
+}
+
+void sub_81C228C(u8 a)
+{
+    if (a == 0)
+        sub_8199C30(3, 1, 4, 8, 8, 0);
+    else
+        sub_8199C30(3, 1, 4, 8, 8, 5);
+    schedule_bg_copy_tilemap_to_vram(3);
+}
+
+void sub_81C22CC(struct Pokemon *unused)
+{
+    s64 r6r7;
+    struct PokeSummary *summary = &gUnknown_0203CF1C->summary;
+    u16 *r9;
+    u8 i;
+
+    if (summary->level < MAX_MON_LEVEL)
+    {
+        u32 r1 = gExperienceTables[gBaseStats[summary->species].growthRate][summary->level + 1] - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level];
+        u32 r4 = summary->exp - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level];
+
+        r6r7 = r4 * 64 / r1;
+        if (r6r7 == 0 && r4 != 0)
+            r6r7 = 1;
+    }
+    else
+    {
+        r6r7 = 0;
+    }
+
+    r9 = &gUnknown_0203CF1C->unkTilemap1_1[0x255];
+    for (i = 0; i < 8; i++)
+    {
+        if (r6r7 > 7)
+            r9[i] = 0x206A;
+        else
+            r9[i] = 0x2062 + (r6r7 % 8);
+        r6r7 -= 8;
+        if (r6r7 < 0)
+            r6r7 = 0;
+    }
+
+    if (GetBgTilemapBuffer(1) == gUnknown_0203CF1C->unkTilemap1)
+        schedule_bg_copy_tilemap_to_vram(1);
+    else
+        schedule_bg_copy_tilemap_to_vram(2);
+}
+
+void sub_81C240C(u16 move)
+{
+    u16* r5 = &gUnknown_0203CF1C->unkTilemap3_1[0];
+    u8 i;
+    u8 r4;
+    if (move != MOVE_NONE)
+    {
+        r4 = gContestEffects[gContestMoves[move].effect].appeal;
+        if (r4 != 0xFF)
+            r4 /= 10;
+        for (i = 0;i < 8; i++)
+        {
+            if (r4 != 0xFF && i < r4)
+            {
+                r5[((i>>2)*32)+(i&3)+0x1E6] = 0x103A;
+            }
+            else
+                r5[((i>>2)*32)+(i&3)+0x1E6] = 0x1039;
+        }
+        r4 = gContestEffects[gContestMoves[move].effect].jam;
+        if (r4 != 0xFF)
+            r4 /= 10;
+        for (i = 0;i < 8; i++)
+        {
+            if (r4 != 0xFF && i < r4)
+            {
+                r5[((i>>2)*32)+(i&3)+0x226] = 0x103C;
+            }
+            else
+                r5[((i>>2)*32)+(i&3)+0x226] = 0x103D;
+        }
+    }
+}
+
+void sub_81C2524()
+{
+    if (gUnknown_0203CF1C->summary.isEgg != 0)
+        ChangeBgX(3, 0x10000, 0);
+    else
+        ChangeBgX(3, 0, 0);
+}
+
+void sub_81C2554()
+{
+    u8 i;
+    InitWindows(&gUnknown_0861CC24);
+    DeactivateAllTextPrinters();
+    for (i = 0; i < 20; i++)
+        FillWindowPixelBuffer(i, 0);
+    for (i = 0; i < 8; i++)
+        gUnknown_0203CF1C->unk40CB[i] |= 0xFF;
+}
+
+void sub_81C25A4(u8 a, u8 *b, u8 c, u8 d, u8 e, u8 f)
+{
+    AddTextPrinterParametrized2(a, 1, c, d, 0, e, &gUnknown_0861CD2C[f], 0, b);
+}
+
+void sub_81C25E8()
+{
+    FillWindowPixelBuffer(17, 0);
+    FillWindowPixelBuffer(18, 0);
+    FillWindowPixelBuffer(19, 0);
+    if (gUnknown_0203CF1C->summary.isEgg == 0)
+        sub_81C2628();
+    else
+        sub_81C2794();
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_81C2628()
+{
+    u8 strArray[16];
+    struct Pokemon *mon = &gUnknown_0203CF1C->currentMon;
+    struct PokeSummary *summary = &gUnknown_0203CF1C->summary;
+    u16 r5 = SpeciesToPokedexNum(summary->species);
+    if (r5 != 0xFFFF)
+    {
+        StringCopy(gStringVar1, &gText_UnkCtrlF908Clear01[0]);
+        ConvertIntToDecimalStringN(gStringVar2, r5, 2, 3);
+        StringAppend(gStringVar1, gStringVar2);
+        if (IsMonShiny(mon) == 0)
+        {
+            sub_81C25A4(17, gStringVar1, 0, 1, 0, 1);
+            sub_81C228C(0);
+        }
+        else
+        {
+            sub_81C25A4(17, gStringVar1, 0, 1, 0, 7);
+            sub_81C228C(1);
+        }
+        PutWindowTilemap(17);
+    }
+    else
+    {
+        ClearWindowTilemap(17);
+        if (IsMonShiny(mon) == 0)
+            sub_81C228C(0);
+        else
+            sub_81C228C(1);
+    }
+    StringCopy(gStringVar1, &gText_LevelSymbol[0]);
+    ConvertIntToDecimalStringN(gStringVar2, summary->level, 0, 3);
+    StringAppend(gStringVar1, gStringVar2);
+    sub_81C25A4(19, gStringVar1, 0x18, 17, 0, 1);
+    GetMonNickname(mon, gStringVar1);
+    sub_81C25A4(18, gStringVar1, 0, 1, 0, 1);
+    strArray[0] = CHAR_SLASH;
+    StringCopy(&strArray[1], &gSpeciesNames[summary->species2][0]);
+    sub_81C25A4(19, &strArray[0], 0, 1, 0, 1);
+    sub_81C27DC(mon, summary->species2);
+    PutWindowTilemap(18);
+    PutWindowTilemap(19);
+}
+
+void sub_81C2794()
+{
+    GetMonNickname(&gUnknown_0203CF1C->currentMon, gStringVar1);
+    sub_81C25A4(18, gStringVar1, 0, 1, 0, 1);
+    PutWindowTilemap(18);
+    ClearWindowTilemap(17);
+    ClearWindowTilemap(19);
+}
+
+void sub_81C27DC(struct Pokemon *mon, u16 a)
+{
+    if (a != SPECIES_NIDORAN_M && a != SPECIES_NIDORAN_F)
+    {
+        u8 gender = GetMonGender(mon);
+        switch (gender)
+        {
+            case 0:
+                sub_81C25A4(0x13, &gText_MaleSymbol[0], 0x39, 17, 0, 3);
+                break;
+            case 0xFE:
+                sub_81C25A4(0x13, &gText_FemaleSymbol[0], 0x39, 17, 0, 4);
+                break;
+        }
+    }
+}
+
+void sub_81C2838(u8 a, bool8 b, u32 c)
+{
+    BlitBitmapToWindow(a, (b) ? &gUnknown_0861CDD3[0] : &gUnknown_0861CDD3[0] - 0x80, c, 0, 16, 16);
+}
+
+void sub_81C286C()
+{
+    int r4;
+    int r2;
+    int temp;
+    sub_81C25A4(0, gText_PkmnInfo, 2, 1, 0, 1);
+    sub_81C25A4(1, gText_PkmnSkills, 2, 1, 0, 1);
+    sub_81C25A4(2, gText_BattleMoves, 2, 1, 0, 1);
+    sub_81C25A4(3, gText_ContestMoves, 2, 1, 0, 1);
+    r4 = GetStringRightAlignXOffset(1, gText_Cancel2, 0x3E);
+    r2 = r4 - 16;
+    if (r2 < 0)
+        r2 = 0;
+    sub_81C2838(4, 0, r2);
+    sub_81C25A4(4, gText_Cancel2, r4, 1, 0, 0);
+    r4 = GetStringRightAlignXOffset(1, gText_Info, 0x3E);
+    r2 = r4 - 16;
+    if (r2 < 0)
+        r2 = 0;
+    sub_81C2838(5, 0, r2);
+    sub_81C25A4(5, gText_Info, r4, 1, 0, 0);
+    r4 = GetStringRightAlignXOffset(1, gText_Switch, 0x3E);
+    r2 = r4 - 16;
+    if (r2 < 0)
+        r2 = 0;
+    sub_81C2838(6, 0, r2);
+    sub_81C25A4(6, gText_Switch, r4, 1, 0, 0);
+    sub_81C25A4(8, gText_RentalPkmn, 0, 1, 0, 1);
+    sub_81C25A4(9, gText_TypeSlash, 0, 1, 0, 0);
+    temp = 6;
+    temp += GetStringCenterAlignXOffset(1, gText_HP4, 42);
+    sub_81C25A4(10, gText_HP4, temp, 1, 0, 1);
+    temp = 6;
+    temp += GetStringCenterAlignXOffset(1, gText_Attack3, 42);
+    sub_81C25A4(10, gText_Attack3, temp, 17, 0, 1);
+    temp = 6;
+    temp += GetStringCenterAlignXOffset(1, gText_Defense3, 42);
+    sub_81C25A4(10, gText_Defense3, temp, 33, 0, 1);
+    temp = 2;
+    temp += GetStringCenterAlignXOffset(1, gText_SpAtk4, 36);
+    sub_81C25A4(11, gText_SpAtk4, temp, 1, 0, 1);
+    temp = 2;
+    temp += GetStringCenterAlignXOffset(1, gText_SpDef4, 36);
+    sub_81C25A4(11, gText_SpDef4, temp, 17, 0, 1);
+    temp = 2;
+    temp += GetStringCenterAlignXOffset(1, gText_Speed2, 36);
+    sub_81C25A4(11, gText_Speed2, temp, 33, 0, 1);
+    sub_81C25A4(12, gText_ExpPoints, 6, 1, 0, 1);
+    sub_81C25A4(12, gText_NextLv, 6, 17, 0, 1);
+    sub_81C25A4(13, gText_Status, 2, 1, 0, 1);
+    sub_81C25A4(14, gText_Power, 0, 1, 0, 1);
+    sub_81C25A4(14, gText_Accuracy2, 0, 17, 0, 1);
+    sub_81C25A4(15, gText_Appeal, 0, 1, 0, 1);
+    sub_81C25A4(15, gText_Jam, 0, 17, 0, 1);
+}
+
+void sub_81C2AFC(u8 a)
+{
+    u8 i;
+    ClearWindowTilemap(0);
+    ClearWindowTilemap(1);
+    ClearWindowTilemap(2);
+    ClearWindowTilemap(3);
+    switch (a)
+    {
+        case 0:
+            PutWindowTilemap(0);
+            PutWindowTilemap(4);
+            if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE)
+                PutWindowTilemap(8);
+            PutWindowTilemap(9);
+            break;
+        case 1:
+            PutWindowTilemap(1);
+            PutWindowTilemap(10);
+            PutWindowTilemap(11);
+            PutWindowTilemap(12);
+            break;
+        case 2:
+            PutWindowTilemap(2);
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    PutWindowTilemap(14);
+            }
+            else
+                PutWindowTilemap(5);
+            break;
+        case 3:
+            PutWindowTilemap(3);
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    PutWindowTilemap(15);
+            }
+            else
+                PutWindowTilemap(5);
+            break;
+    }
+    for (i = 0; i < 8; i++)
+    {
+        PutWindowTilemap(gUnknown_0203CF1C->unk40CB[i]);
+    }
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_81C2C38(u8 a)
+{
+    u8 i;
+    switch (a)
+    {
+        case 0:
+            ClearWindowTilemap(4);
+            if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE)
+                ClearWindowTilemap(8);
+            ClearWindowTilemap(9);
+            break;
+        case 1:
+            ClearWindowTilemap(10);
+            ClearWindowTilemap(11);
+            ClearWindowTilemap(12);
+            break;
+        case 2:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    ClearWindowTilemap(14);
+            }
+            else
+                ClearWindowTilemap(5);
+            break;
+        case 3:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    ClearWindowTilemap(15);
+            }
+            else
+                ClearWindowTilemap(5);
+            break;
+    }
+    for (i = 0; i < 8; i++)
+        sub_81C2D68(i);
+    schedule_bg_copy_tilemap_to_vram(0);
+}
+
+
+
+#ifdef NONMATCHING
+u8 sub_81C2D2C(struct WindowTemplate *template, u8 a)
+{
+    u8 *r4 = gUnknown_0203CF1C->unk40CB;
+    if (r4[a] == 0xFF)
+    {
+        r4[a] = AddWindow(&template[a]);
+        FillWindowPixelBuffer(r4[a], 0);
+    }
+    return r4[a];
+}
+#else
+__attribute__((naked))
+u8 sub_81C2D2C(struct WindowTemplate *template, u8 a)
+{
+    asm(".syntax unified\n\
+    push {r4,lr}\n\
+	adds r3, r0, 0\n\
+	lsls r1, 24\n\
+	lsrs r2, r1, 24\n\
+	ldr r0, =gUnknown_0203CF1C\n\
+	ldr r4, =0x000040cb\n\
+	adds r1, r2, r4\n\
+	ldr r0, [r0]\n\
+	adds r4, r0, r1\n\
+	ldrb r0, [r4]\n\
+	cmp r0, 0xFF\n\
+	bne _081C2D56\n\
+	lsls r0, r2, 3\n\
+	adds r0, r3, r0\n\
+	bl AddWindow\n\
+	strb r0, [r4]\n\
+	ldrb r0, [r4]\n\
+	movs r1, 0\n\
+	bl FillWindowPixelBuffer\n\
+_081C2D56:\n\
+	ldrb r0, [r4]\n\
+	pop {r4}\n\
+	pop {r1}\n\
+	bx r1\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+#ifdef NONMATCHING
+void sub_81C2D68(u8 a)
+{
+    u8 *r4 = gUnknown_0203CF1C->unk40CB;
+    if (r4[a] != 0xFF)
+    {
+        ClearWindowTilemap(r4[a]);
+        RemoveWindow(r4[a]);
+        r4[a] = 0xFF;
+    }
+}
+#else
+__attribute__((naked))
+void sub_81C2D68(u8 a)
+{
+    asm(".syntax unified\n\
+    push {r4,lr}\n\
+	lsls r0, 24\n\
+	lsrs r0, 24\n\
+	ldr r1, =gUnknown_0203CF1C\n\
+	ldr r2, =0x000040cb\n\
+	adds r0, r2\n\
+	ldr r1, [r1]\n\
+	adds r4, r1, r0\n\
+	ldrb r0, [r4]\n\
+	cmp r0, 0xFF\n\
+	beq _081C2D8C\n\
+	bl ClearWindowTilemap\n\
+	ldrb r0, [r4]\n\
+	bl RemoveWindow\n\
+	movs r0, 0xFF\n\
+	strb r0, [r4]\n\
+_081C2D8C:\n\
+	pop {r4}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+void sub_81C2D9C(u8 a)
+{
+    u16 i;
+    for (i = 0; i < 8; i++)
+    {
+        if (gUnknown_0203CF1C->unk40CB[i] != 0xFF)
+            FillWindowPixelBuffer(gUnknown_0203CF1C->unk40CB[i], 0);
+    }
+    gUnknown_0861CE54[a]();
+}
+
+void sub_81C2DE4(u8 a)
+{
+    CreateTask(gUnknown_0861CE64[a], 16);
+}
+
+void sub_81C2E00()
+{
+    if (gUnknown_0203CF1C->summary.isEgg)
+    {
+        sub_81C335C();
+        sub_81C33CC();
+        sub_81C3428();
+        sub_81C349C();
+    }
+    else
+    {
+        sub_81C2EC4();
+        sub_81C2F5C();
+        sub_81C2FD8();
+        sub_81C302C();
+        sub_81C307C();
+        sub_81C3194();
+    }
+}
+
+void sub_81C2E40(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 dataa = data[0] - 1;
+    switch (dataa)
+    {
+        case 0:
+            sub_81C2EC4();
+            break;
+        case 1:
+            sub_81C2F5C();
+            break;
+        case 2:
+            sub_81C2FD8();
+            break;
+        case 3:
+            sub_81C302C();
+            break;
+        case 4:
+            sub_81C307C();
+            break;
+        case 5:
+            sub_81C3194();
+            break;
+        case 6:
+            DestroyTask(taskId);
+            return;
+    }
+    data[0]++;
+}
+
+void sub_81C2EC4()
+{
+    u8 r5;
+    int r2;
+    if (sub_81A6BF4() != 1 && sub_81B9E94() != 1)
+    {
+        r5 = sub_81C2D2C(&gUnknown_0861CCCC, 0);
+        sub_81C25A4(r5, gText_OTSlash, 0, 1, 0, 1);
+        r2 = GetStringWidth(1, gText_OTSlash, 0);
+        if (gUnknown_0203CF1C->summary.OTGender == 0)
+            sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 5);
+        else
+            sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 6);
+    }
+}
+
+void sub_81C2F5C()
+{
+    int r4;
+    if (sub_81A6BF4() != TRUE && sub_81B9E94() != TRUE)
+    {
+        ConvertIntToDecimalStringN(StringCopy(gStringVar1, gText_UnkCtrlF907F908), (u16)gUnknown_0203CF1C->summary.OTID, 2, 5);
+        r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38);
+        sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1);
+    }
+}
+
+void sub_81C2FD8()
+{
+    u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility);
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityNames[ability], 0, 1, 0, 1);
+}
+
+void sub_81C302C()
+{
+    u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility);
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityDescriptionPointers[ability], 0, 17, 0, 0);
+}
+
+void sub_81C307C()
+{
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    u8 *text;
+    sub_81AFBF0();
+    sub_81AFC0C(0, gUnknown_0861CE74);
+    sub_81AFC0C(1, gUnknown_0861CE7B);
+    sub_81C31C0();
+    if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE || sub_81C3304() == TRUE)
+        sub_81AFC28(gStringVar4, gText_XNature);
+    else
+    {
+        u8 *alloced1 = Alloc(32);
+        u8 *alloced2 = Alloc(32);
+        sub_81C31F0(alloced1);
+        if (sum->metLocation <= 0xD4)
+        {
+            sub_8124610(alloced2, sum->metLocation);
+            sub_81AFC0C(4, alloced2);
+        }
+        if (sub_81C3220() == 1)
+        {
+            if (sum->metLevel == 0)
+                text = (sum->metLocation > 0xD4) ? gText_XNatureHatchedSomewhereAt : gText_XNatureHatchedAtYZ;
+            else
+                text = (sum->metLocation > 0xD4) ? gText_XNatureMetSomewhereAt : gText_XNatureMetAtYZ;
+        }
+        else if (sum->metLocation == 0xFF)
+            text = gText_XNatureFatefulEncounter;
+        else if (sum->metLocation != 0xFE && sub_81C32BC())
+            text = (sum->metLocation > 0xD4) ? gText_XNatureObtainedInTrade : gText_XNatureProbablyMetAt;
+        else
+            text = gText_XNatureObtainedInTrade;
+        sub_81AFC28(gStringVar4, text);
+        Free(alloced1);
+        Free(alloced2);
+    }
+}
+
+void sub_81C3194()
+{
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), gStringVar4, 0, 1, 0, 0);
+}
+
+void sub_81C31C0()
+{
+    struct UnkSummaryStruct *sumStruct = gUnknown_0203CF1C;
+    sub_81AFC0C(2, gNatureNamePointers[sumStruct->summary.nature]);
+    sub_81AFC0C(5, gText_EmptyString5);
+}
+
+void sub_81C31F0(u8 *a)
+{
+    u8 level = gUnknown_0203CF1C->summary.metLevel;
+    if (level == 0)
+        level = 5;
+    ConvertIntToDecimalStringN(a, level, 0, 3);
+    sub_81AFC0C(3, a);
+}
+
+u8 sub_81C3220()
+{
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    u32 r4;
+    u8 r5;
+    if (gUnknown_0203CF1C->unk0 == (union UnkUnion *)&gEnemyParty)
+    {
+        u8 multiID = GetMultiplayerId()^1;
+        r4 = (u16)gLinkPlayers[multiID].trainerId;
+        r5 = gLinkPlayers[multiID].gender;
+        StringCopy(gStringVar1, gLinkPlayers[multiID].name);
+    }
+    else
+    {
+        r4 = GetPlayerIDAsU32() & 0xFFFF;
+        r5 = gSaveBlock2Ptr->playerGender;
+        StringCopy(gStringVar1, gSaveBlock2Ptr->playerName);
+    }
+    if (r5 != sum->OTGender || r4 != (sum->OTID & 0xFFFF) || StringCompareWithoutExtCtrlCodes(gStringVar1, sum->OTName))
+    {
+            return 0;
+    }
+    return 1;
+}
+
+bool8 sub_81C32BC()
+{
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    u8 r0 = sum->metGame - 1;
+    if (r0 <= 4)
+        return TRUE;
+    return FALSE;
+}
+
+bool8 sub_81C32E0()
+{
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    u8 r0 = sum->metGame - 1;
+    if (r0 <= 2)
+        return TRUE;
+    return FALSE;
+}
+
+bool8 sub_81C3304()
+{
+    if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) && gMain.inBattle)
+    {
+        if (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+#ifdef NONMATCHING
+void sub_81C335C()
+{
+    u8 r4 = sub_81C2D2C(&gUnknown_0861CCCC, 0);
+    u32 r5 = GetStringWidth(1, gText_OTSlash, 0);
+    sub_81C25A4(r4, gText_OTSlash, 0, 1, 0, 1);
+    sub_81C25A4(r4, gText_FiveMarks, r5, 1, 0, 1);
+}
+#else
+__attribute__((naked))
+void sub_81C335C()
+{
+    asm(".syntax unified\n\
+    push {r4-r6,lr}\n\
+	mov r6, r9\n\
+	mov r5, r8\n\
+	push {r5,r6}\n\
+	sub sp, 0x8\n\
+	ldr r0, =gUnknown_0861CCCC\n\
+	movs r1, 0\n\
+	bl sub_81C2D2C\n\
+	adds r4, r0, 0\n\
+	lsls r4, 24\n\
+	lsrs r4, 24\n\
+	ldr r0, =gText_OTSlash\n\
+	mov r8, r0\n\
+	movs r0, 0x1\n\
+	mov r1, r8\n\
+	movs r2, 0\n\
+	bl GetStringWidth\n\
+	adds r5, r0, 0\n\
+	movs r0, 0\n\
+	mov r9, r0\n\
+	str r0, [sp]\n\
+	movs r6, 0x1\n\
+	str r6, [sp, 0x4]\n\
+	adds r0, r4, 0\n\
+	mov r1, r8\n\
+	movs r2, 0\n\
+	movs r3, 0x1\n\
+	bl sub_81C25A4\n\
+	ldr r1, =gText_FiveMarks\n\
+	lsls r5, 24\n\
+	lsrs r5, 24\n\
+	mov r0, r9\n\
+	str r0, [sp]\n\
+	str r6, [sp, 0x4]\n\
+	adds r0, r4, 0\n\
+	adds r2, r5, 0\n\
+	movs r3, 0x1\n\
+	bl sub_81C25A4\n\
+	add sp, 0x8\n\
+	pop {r3,r4}\n\
+	mov r8, r3\n\
+	mov r9, r4\n\
+	pop {r4-r6}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+void sub_81C33CC()
+{
+    int r4;
+    StringCopy(gStringVar1, gText_UnkCtrlF907F908);
+    StringAppend(gStringVar1, gText_FiveMarks);
+    r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38);
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1);
+}
+
+void sub_81C3428()
+{
+    u8 *text;
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    if (gUnknown_0203CF1C->summary.sanity == 1)
+        text = gText_EggWillTakeALongTime;
+    else if (sum->friendship <= 5)
+        text = gText_EggAboutToHatch;
+    else if (sum->friendship <= 10)
+        text = gText_EggWillHatchSoon;
+    else if (sum->friendship <= 40)
+        text = gText_EggWillTakeSomeTime;
+    else
+        text = gText_EggWillTakeALongTime;
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), text, 0, 1, 0, 0);
+}
+
+void sub_81C349C()
+{
+    u8 *text;
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    if (gUnknown_0203CF1C->summary.sanity != 1)
+    {
+        if (sum->metLocation == 0xFF)
+            text = gText_PeculiarEggNicePlace;
+        else if (sub_81C32BC() == 0 || sub_81C3220() == 0)
+            text = gText_PeculiarEggTrade;
+        else if (sum->metLocation == 0xFD)
+            text = (sub_81C32E0() == TRUE) ? gText_EggFromHotSprings : gText_EggFromTraveler;
+        else
+            text = gText_OddEggFoundByCouple;
+    }
+    else
+        text = gText_OddEggFoundByCouple;
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), text, 0, 1, 0, 0);
+}
+
+void sub_81C3530()
+{
+    sub_81C35E4();
+    sub_81C3690();
+    sub_81C3710();
+    sub_81C37D8();
+    sub_81C3808();
+    sub_81C3890();
+    sub_81C38C0();
+}
+
+void sub_81C3554(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 dataa = data[0] - 1;
+    switch (dataa)
+    {
+        case 0:
+            sub_81C35E4();
+            break;
+        case 1:
+            sub_81C3690();
+            break;
+        case 2:
+            sub_81C3710();
+            break;
+        case 3:
+            sub_81C37D8();
+            break;
+        case 4:
+            sub_81C3808();
+            break;
+        case 5:
+            sub_81C3890();
+            break;
+        case 6:
+            sub_81C38C0();
+            break;
+        case 7:
+            DestroyTask(taskId);
+            return;
+    }
+    data[0]++;
+}
+
+void sub_81C35E4()
+{
+    u8 *text;
+    int offset;
+    if (gUnknown_0203CF1C->summary.item == ITEM_ENIGMA_BERRY && sub_81B1250() == 1 && (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5))
+    {
+        text = (u8*)ItemId_GetItem(ITEM_ENIGMA_BERRY);
+    }
+    else if (gUnknown_0203CF1C->summary.item == ITEM_NONE)
+        text = gText_None;
+    else
+    {
+        CopyItemName(gUnknown_0203CF1C->summary.item, gStringVar1);
+        text = gStringVar1;
+    }
+    offset = GetStringCenterAlignXOffset(1, text, 0x48) + 6;
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 0), text, offset, 1, 0, 0);
+}
+
+void sub_81C3690()
+{
+    u8 *text;
+    int offset;
+    if (gUnknown_0203CF1C->summary.ribbons == 0)
+        text = gText_None;
+    else
+    {
+        ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.ribbons, 1, 2);
+        StringExpandPlaceholders(gStringVar4, gText_RibbonsVar1);
+        text = gStringVar4;
+    }
+    offset = GetStringCenterAlignXOffset(1, text, 0x46) + 6;
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 1), text, offset, 1, 0, 0);
+}
+
+void sub_81C3710()
+{
+    u8 *alloced1 = Alloc(8);
+    u8 *alloced2 = Alloc(8);
+    u8 *alloced3 = Alloc(8);
+    u8 *alloced4 = Alloc(8);
+    ConvertIntToDecimalStringN(alloced1, gUnknown_0203CF1C->summary.currentHP, 1, 3);
+    ConvertIntToDecimalStringN(alloced2, gUnknown_0203CF1C->summary.maxHP, 1, 3);
+    ConvertIntToDecimalStringN(alloced3, gUnknown_0203CF1C->summary.atk, 1, 7);
+    ConvertIntToDecimalStringN(alloced4, gUnknown_0203CF1C->summary.def, 1, 7);
+    sub_81AFBF0();
+    sub_81AFC0C(0, alloced1);
+    sub_81AFC0C(1, alloced2);
+    sub_81AFC0C(2, alloced3);
+    sub_81AFC0C(3, alloced4);
+    sub_81AFC28(gStringVar4, gUnknown_0861CE82);
+    Free(alloced1);
+    Free(alloced2);
+    Free(alloced3);
+    Free(alloced4);
+}
+
+void sub_81C37D8()
+{
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 2), gStringVar4, 4, 1, 0, 0);
+}
+
+void sub_81C3808()
+{
+    ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.spatk, 1, 3);
+    ConvertIntToDecimalStringN(gStringVar2, gUnknown_0203CF1C->summary.spdef, 1, 3);
+    ConvertIntToDecimalStringN(gStringVar3, gUnknown_0203CF1C->summary.speed, 1, 3);
+    sub_81AFBF0();
+    sub_81AFC0C(0, gStringVar1);
+    sub_81AFC0C(1, gStringVar2);
+    sub_81AFC0C(2, gStringVar3);
+    sub_81AFC28(gStringVar4, gUnknown_0861CE8E);
+}
+
+void sub_81C3890()
+{
+    sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 3), gStringVar4, 2, 1, 0, 0);
+}
+
+void sub_81C38C0()
+{
+    struct PokeSummary *sum = &gUnknown_0203CF1C->summary;
+    u8 r6 = sub_81C2D2C(&gUnknown_0861CCEC, 4);
+    int offset;
+    u32 expToNextLevel;
+    ConvertIntToDecimalStringN(gStringVar1, sum->exp, 1, 7);
+    offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2;
+    sub_81C25A4(r6, gStringVar1, offset, 1, 0, 0);
+    if (sum->level < MAX_MON_LEVEL)
+        expToNextLevel = gExperienceTables[gBaseStats[sum->species].growthRate][sum->level + 1] - sum->exp;
+    else
+        expToNextLevel = 0;
+    ConvertIntToDecimalStringN(gStringVar1, expToNextLevel, 1, 6);
+    offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2;
+    sub_81C25A4(r6, gStringVar1, offset, 17, 0, 0);
+}
+
+void sub_81C3984()
+{
+    sub_81C3B08(0);
+    sub_81C3B08(1);
+    sub_81C3B08(2);
+    sub_81C3B08(3);
+    if (gUnknown_0203CF1C->unk40BC == 3)
+    {
+        sub_81C3F44();
+        if (gUnknown_0203CF1C->unk40C6 == 4)
+        {
+            if (gUnknown_0203CF1C->unk40C4 != 0)
+                sub_81C3E9C(gUnknown_0203CF1C->unk40C4);
+        }
+        else
+            sub_81C3E9C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]);
+    }
+}
+
+void sub_81C39F0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 dataa = data[0] - 1;
+
+    switch (dataa)
+    {
+        case 0:
+            sub_81C3B08(0);
+            break;
+        case 1:
+            sub_81C3B08(1);
+            break;
+        case 2:
+            sub_81C3B08(2);
+            break;
+        case 3:
+            sub_81C3B08(3);
+            break;
+        case 4:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+                sub_81C3F44();
+            break;
+        case 5:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if (gUnknown_0203CF1C->unk40C6 == 4)
+                    data[1] = gUnknown_0203CF1C->unk40C4;
+                else
+                    data[1] = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6];
+            }
+            break;
+        case 6:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    sub_81C3E9C(data[1]);
+            }
+            break;
+        case 7:
+            DestroyTask(taskId);
+            return;
+    }
+    data[0]++;
+}
+
+#ifdef NONMATCHING
+void sub_81C3B08(u8 a)
+{
+    struct UnkSummaryStruct *r10 = gUnknown_0203CF1C;
+    u8 r8 = sub_81C2D2C(&gUnknown_0861CD14, 0);
+    u8 sp = sub_81C2D2C(&gUnknown_0861CD14, 1);
+    u8 r6;
+    u8 r5;
+    u8 *text;
+    int offset;
+    u16 move;
+    if (r10->summary.moves[a] != 0)
+    {
+        move = r10->summary.moves[a];
+        r6 = CalculatePPWithBonus(move, r10->summary.ppBonuses, a);
+        sub_81C25A4(r8, gMoveNames[move], 0, (a<<4) + 1, 0, 1);
+        ConvertIntToDecimalStringN(gStringVar1, r10->summary.pp[a], 1, 2);
+        ConvertIntToDecimalStringN(gStringVar2, r6, 1, 2);
+        sub_81AFBF0();
+        sub_81AFC0C(0, gStringVar1);
+        sub_81AFC0C(1, gStringVar2);
+        sub_81AFC28(gStringVar4, gUnknown_0861CE97);
+        text = gStringVar4;
+        r5 = GetCurrentPpToMaxPpState(r10->summary.pp[a], r6) + 9;
+        offset = GetStringRightAlignXOffset(1, text, 0x2C);
+    }
+    else
+    {
+        sub_81C25A4(r8, gText_OneDash, 0, (a<<4) + 1, 0, 1);
+        text = gText_TwoDashes;
+        r5 = 12;
+        offset = GetStringCenterAlignXOffset(1, text, 0x2C);
+    }
+    sub_81C25A4(sp, text, offset, (a<<4), 0, r5);
+}
+#else
+__attribute__((naked))
+void sub_81C3B08(u8 a)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+	mov r7, r10\n\
+	mov r6, r9\n\
+	mov r5, r8\n\
+	push {r5-r7}\n\
+	sub sp, 0xC\n\
+	lsls r0, 24\n\
+	lsrs r7, r0, 24\n\
+	ldr r0, =gUnknown_0203CF1C\n\
+	ldr r0, [r0]\n\
+	mov r10, r0\n\
+	ldr r4, =gUnknown_0861CD14\n\
+	adds r0, r4, 0\n\
+	movs r1, 0\n\
+	bl sub_81C2D2C\n\
+	lsls r0, 24\n\
+	lsrs r0, 24\n\
+	mov r8, r0\n\
+	adds r0, r4, 0\n\
+	movs r1, 0x1\n\
+	bl sub_81C2D2C\n\
+	lsls r0, 24\n\
+	lsrs r0, 24\n\
+	str r0, [sp, 0x8]\n\
+	lsls r1, r7, 1\n\
+	mov r0, r10\n\
+	adds r0, 0x84\n\
+	adds r0, r1\n\
+	ldrh r5, [r0]\n\
+	cmp r5, 0\n\
+	beq _081C3C00\n\
+	mov r0, r10\n\
+	adds r0, 0xA4\n\
+	ldrb r1, [r0]\n\
+	adds r0, r5, 0\n\
+	adds r2, r7, 0\n\
+	bl CalculatePPWithBonus\n\
+	adds r6, r0, 0\n\
+	lsls r6, 24\n\
+	lsrs r6, 24\n\
+	movs r0, 0xD\n\
+	adds r1, r5, 0\n\
+	muls r1, r0\n\
+	ldr r0, =gMoveNames\n\
+	adds r1, r0\n\
+	lsls r0, r7, 4\n\
+	mov r9, r0\n\
+	mov r3, r9\n\
+	adds r3, 0x1\n\
+	lsls r3, 24\n\
+	lsrs r3, 24\n\
+	movs r0, 0\n\
+	str r0, [sp]\n\
+	movs r0, 0x1\n\
+	str r0, [sp, 0x4]\n\
+	mov r0, r8\n\
+	movs r2, 0\n\
+	bl sub_81C25A4\n\
+	ldr r0, =gStringVar1\n\
+	mov r8, r0\n\
+	mov r5, r10\n\
+	adds r5, 0x8C\n\
+	adds r5, r7\n\
+	ldrb r1, [r5]\n\
+	movs r2, 0x1\n\
+	movs r3, 0x2\n\
+	bl ConvertIntToDecimalStringN\n\
+	ldr r4, =gStringVar2\n\
+	adds r0, r4, 0\n\
+	adds r1, r6, 0\n\
+	movs r2, 0x1\n\
+	movs r3, 0x2\n\
+	bl ConvertIntToDecimalStringN\n\
+	bl sub_81AFBF0\n\
+	movs r0, 0\n\
+	mov r1, r8\n\
+	bl sub_81AFC0C\n\
+	movs r0, 0x1\n\
+	adds r1, r4, 0\n\
+	bl sub_81AFC0C\n\
+	ldr r4, =gStringVar4\n\
+	ldr r1, =gUnknown_0861CE97\n\
+	adds r0, r4, 0\n\
+	bl sub_81AFC28\n\
+	adds r7, r4, 0\n\
+	ldrb r0, [r5]\n\
+	adds r1, r6, 0\n\
+	bl GetCurrentPpToMaxPpState\n\
+	lsls r0, 24\n\
+	lsrs r0, 24\n\
+	adds r5, r0, 0\n\
+	adds r5, 0x9\n\
+	movs r0, 0x1\n\
+	adds r1, r7, 0\n\
+	movs r2, 0x2C\n\
+	bl GetStringRightAlignXOffset\n\
+	mov r4, r9\n\
+	b _081C3C26\n\
+	.pool\n\
+_081C3C00:\n\
+	ldr r1, =gText_OneDash\n\
+	lsls r4, r7, 4\n\
+	adds r3, r4, 0x1\n\
+	lsls r3, 24\n\
+	lsrs r3, 24\n\
+	str r5, [sp]\n\
+	movs r0, 0x1\n\
+	str r0, [sp, 0x4]\n\
+	mov r0, r8\n\
+	movs r2, 0\n\
+	bl sub_81C25A4\n\
+	ldr r7, =gText_TwoDashes\n\
+	movs r5, 0xC\n\
+	movs r0, 0x1\n\
+	adds r1, r7, 0\n\
+	movs r2, 0x2C\n\
+	bl GetStringCenterAlignXOffset\n\
+_081C3C26:\n\
+	lsls r2, r0, 24\n\
+	lsrs r2, 24\n\
+	adds r3, r4, 0x1\n\
+	lsls r3, 24\n\
+	lsrs r3, 24\n\
+	movs r0, 0\n\
+	str r0, [sp]\n\
+	lsls r0, r5, 24\n\
+	lsrs r0, 24\n\
+	str r0, [sp, 0x4]\n\
+	ldr r0, [sp, 0x8]\n\
+	adds r1, r7, 0\n\
+	bl sub_81C25A4\n\
+	add sp, 0xC\n\
+	pop {r3-r5}\n\
+	mov r8, r3\n\
+	mov r9, r4\n\
+	mov r10, r5\n\
+	pop {r4-r7}\n\
+	pop {r0}\n\
+	bx r0\n\
+	.pool\n\
+	.syntax divided\n");
+}
+#endif
+
+void sub_81C3C5C(u16 move)
+{
+    u8 *text;
+    if (move != 0)
+    {
+        FillWindowPixelRect(14, 0, 0x35, 0, 0x13, 0x20);
+        if (gBattleMoves[move].power <= 1)
+            text = gText_ThreeDashes;
+        else
+        {
+            ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].power, 1, 3);
+            text = gStringVar1;
+        }
+        sub_81C25A4(14, text, 0x35, 1, 0, 0);
+        if (gBattleMoves[move].accuracy == 0)
+            text = gText_ThreeDashes;
+        else
+        {
+            ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].accuracy, 1, 3);
+            text = gStringVar1;
+        }
+        sub_81C25A4(14, text, 0x35, 17, 0, 0);
+    }
+}
+
+void sub_81C3D08()
+{
+    sub_81C3B08(0);
+    sub_81C3B08(1);
+    sub_81C3B08(2);
+    sub_81C3B08(3);
+    if (gUnknown_0203CF1C->unk40BC == 3)
+    {
+        sub_81C3F44();
+        sub_81C3E2C(gUnknown_0203CF1C->unk40C6);
+    }
+}
+
+void sub_81C3D54(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 dataa = data[0] - 1;
+    
+    switch (dataa)
+    {
+        case 0:
+            sub_81C3B08(0);
+            break;
+        case 1:
+            sub_81C3B08(1);
+            break;
+        case 2:
+            sub_81C3B08(2);
+            break;
+        case 3:
+            sub_81C3B08(3);
+            break;
+        case 4:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+                sub_81C3F44();
+            break;
+        case 5:
+            if (gUnknown_0203CF1C->unk40BC == 3)
+            {
+                if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4))
+                    sub_81C3E2C(gUnknown_0203CF1C->unk40C6);
+            }
+            break;
+        case 6:
+            DestroyTask(taskId);
+            return;
+    }
+    data[0]++;
+}
\ No newline at end of file
diff --git a/src/start_menu.c b/src/start_menu.c
index be30d0e53..37331a922 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -207,7 +207,7 @@ static bool32 PrintStartMenuItemsMultistep(s16 *index, u32 n)
 
     do
     {
-        if (sStartMenuItems[sCurrentStartMenuActions[_index]].func == StartMenu_PlayerName)
+        if (sStartMenuItems[sCurrentStartMenuActions[_index]].func.u8_void == StartMenu_PlayerName)
         {
 
         }
diff --git a/src/tv.c b/src/tv.c
index 7f64b46ac..3c822b394 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -2353,7 +2353,7 @@ void sub_80EDFB4(TVShow *show)
     show->secretBaseVisit.move = sTV_SecretBaseVisitMonsTemp[j].move;
 }
 
-void sub_80EE104(void)
+void TV_PutSecretBaseVisitOnTheAir(void)
 {
     TVShow *show;