Merge branch 'master' into event_object_movement

200 files changed, 48983 insertions, 12453 deletions

diff --git a/src/AgbRfu_LinkManager.c b/src/AgbRfu_LinkManager.c
new file mode 100644
index 000000000..e4127ee09
--- /dev/null
+++ b/src/AgbRfu_LinkManager.c
@@ -0,0 +1,1398 @@
+#include "global.h"
+#include "librfu.h"
+#include "link_rfu.h"
+
+#define RN_ACCEPT           0x01
+#define RN_NAME_TIMER_CLEAR 0x02
+#define RN_DISCONNECT       0x04
+
+#define LINK_RECOVERY_OFF        0x00
+#define LINK_RECOVERY_START      0x01
+#define LINK_RECOVERY_EXE        0x02
+#define LINK_RECOVERY_IMPOSSIBLE 0x04
+
+#define FSP_ON    0x01
+#define FSP_START 0x02
+
+LINK_MANAGER lman;
+
+static void rfu_LMAN_clearVariables(void);
+static void rfu_LMAN_settingPCSWITCH(u32 rand);
+static void rfu_LMAN_REQ_callback(u16 reqCommandId, u16 reqResult);
+static void rfu_LMAN_MSC_callback(u16 reqCommandId);
+static void rfu_LMAN_PARENT_checkRecvChildName(void);
+static void rfu_LMAN_CHILD_checkSendChildName(void);
+static void rfu_LMAN_CHILD_checkSendChildName2(void);
+static void rfu_LMAN_CHILD_linkRecoveryProcess(void);
+static u8 rfu_LMAN_CHILD_checkEnableParentCandidate(void);
+static void rfu_LMAN_occureCallback(u8 msg, u8 param_count);
+static void rfu_LMAN_disconnect(u8 bmDisconnectSlot);
+static void rfu_LMAN_reflectCommunicationStatus(u8 bm_disconnectedSlot);
+static void rfu_LMAN_checkNICommunicateStatus(void);
+static void rfu_LMAN_managerChangeAgbClockMaster(void);
+
+u32 rfu_LMAN_REQBN_softReset_and_checkID(void)
+{
+    u32 id = rfu_REQBN_softReset_and_checkID();
+    if (id == RFU_ID)
+        lman.RFU_powerOn_flag = 1;
+    if (lman.state != LMAN_FORCED_STOP_AND_RFU_RESET && lman.state != LMAN_STATE_SOFT_RESET_AND_CHECK_ID)
+    {
+        lman.state = lman.next_state = LMAN_STATE_READY;
+    }
+    lman.pcswitch_flag = 0;
+    lman.reserveDisconnectSlot_flag = 0;
+    lman.acceptCount = 0;
+    lman.acceptSlot_flag = 0;
+    lman.parent_child = MODE_NEUTRAL;
+    rfu_LMAN_managerChangeAgbClockMaster();
+    return id;
+}
+
+void rfu_LMAN_REQ_sendData(u8 clockChangeFlag)
+{
+    if (gRfuLinkStatus->parentChild == MODE_CHILD)
+    {
+        if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON)
+            clockChangeFlag = TRUE;
+        else
+            clockChangeFlag = FALSE;
+    }
+    else
+        lman.parentAck_flag = 0;
+    rfu_REQ_sendData(clockChangeFlag);
+}
+
+u8 rfu_LMAN_initializeManager(void (*LMAN_callback_p)(u8, u8), void (*MSC_callback_p)(u16))
+{
+    if (LMAN_callback_p == NULL)
+    {
+        return LMAN_ERROR_ILLEGAL_PARAMETER;
+    }
+    CpuFill16(0, &lman, sizeof(struct linkManagerTag));
+    lman.parent_child = MODE_NEUTRAL;
+    lman.LMAN_callback = LMAN_callback_p;
+    lman.MSC_callback = MSC_callback_p;
+    rfu_setMSCCallback(rfu_LMAN_MSC_callback);
+    rfu_setREQCallback(rfu_LMAN_REQ_callback);
+    return 0;
+}
+
+static void rfu_LMAN_endManager(void)
+{
+    CpuFill16(0, &lman, sizeof(struct linkManagerTag) - 8);
+    lman.parent_child = MODE_NEUTRAL;
+}
+
+void rfu_LMAN_initializeRFU(INIT_PARAM *init_parameters)
+{
+    rfu_LMAN_clearVariables();
+    lman.state = LMAN_STATE_SOFT_RESET_AND_CHECK_ID;
+    lman.next_state = LMAN_STATE_RESET;
+    lman.init_param = init_parameters;
+    lman.linkRecovery_enable = init_parameters->linkRecovery_enable;
+    lman.linkRecoveryTimer.count_max = init_parameters->linkRecovery_period;
+    lman.NI_failCounter_limit = init_parameters->NI_failCounter_limit;
+    if (init_parameters->fastSearchParent_flag)
+    {
+        lman.fastSearchParent_flag = FSP_ON;
+    }
+}
+
+static void rfu_LMAN_clearVariables(void)
+{
+    u8 i;
+
+    lman.state = lman.next_state = LMAN_STATE_READY;
+    lman.parent_child = MODE_NEUTRAL;
+    lman.pcswitch_flag = 0;
+    lman.child_slot = 0;
+    lman.connectSlot_flag_old = 0;
+    lman.nameAcceptTimer.active = 0;
+    lman.linkRecoveryTimer.active = 0;
+    for (i = 0; i < RFU_CHILD_MAX; i++)
+    {
+        lman.nameAcceptTimer.count[i] = 0;
+        lman.linkRecoveryTimer.count[i] = 0;
+    }
+}
+
+void rfu_LMAN_powerDownRFU(void)
+{
+    lman.state = LMAN_STATE_STOP_MODE;
+}
+
+u8 rfu_LMAN_establishConnection(u8 parent_child, u16 connect_period, u16 name_accept_period, u16 *acceptable_serialNo_list)
+{
+    u8 i;
+    u16 *serial_list;
+
+    if (lman.state != LMAN_STATE_READY && (lman.state != LMAN_STATE_WAIT_RECV_CHILD_NAME || parent_child != MODE_PARENT))
+    {
+        lman.param[0] = 1;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_MANAGER_BUSY;
+    }
+    if (rfu_getMasterSlave() == AGB_CLK_SLAVE)
+    {
+        lman.param[0] = 2;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_AGB_CLK_SLAVE;
+    }
+    for (i = 0, serial_list = acceptable_serialNo_list; i < 16; i++)
+    {
+        if (*serial_list++ == 0xFFFF)
+        {
+            break;
+        }
+    }
+    if (i == 16)
+    {
+        lman.param[0] = 4;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_ILLEGAL_PARAMETER;
+    }
+    if (parent_child > MODE_PARENT)
+    {
+        lman.pcswitch_flag = PCSWITCH_1ST_SC_START;
+        parent_child = MODE_PARENT;
+        connect_period = 0;
+    }
+    else
+    {
+        lman.pcswitch_flag = 0;
+    }
+    if (parent_child != MODE_CHILD)
+    {
+        lman.state = LMAN_STATE_START_SEARCH_CHILD;
+    }
+    else
+    {
+        lman.state = LMAN_STATE_START_SEARCH_PARENT;
+        if (lman.fastSearchParent_flag)
+        {
+            lman.fastSearchParent_flag = FSP_START;
+        }
+    }
+    lman.parent_child = parent_child;
+    lman.connect_period = connect_period;
+    lman.nameAcceptTimer.count_max = name_accept_period;
+    lman.acceptable_serialNo_list = acceptable_serialNo_list;
+    return 0;
+}
+
+u8 rfu_LMAN_CHILD_connectParent(u16 parentId, u16 connect_period)
+{
+    u8 i;
+
+    if (lman.state != LMAN_STATE_READY && (lman.state < 9 || lman.state > 11))
+    {
+        lman.param[0] = 1;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_MANAGER_BUSY;
+    }
+    if (rfu_getMasterSlave() == AGB_CLK_SLAVE)
+    {
+        lman.param[0] = 2;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_AGB_CLK_SLAVE;
+    }
+    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
+    {
+        if (gRfuLinkStatus->partner[i].id == parentId)
+        {
+            break;
+        }
+    }
+    if (gRfuLinkStatus->findParentCount == 0 || i == gRfuLinkStatus->findParentCount)
+    {
+        lman.param[0] = 3;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_PID_NOT_FOUND;
+    }
+    if (lman.state == LMAN_STATE_READY || lman.state == LMAN_STATE_START_SEARCH_PARENT)
+    {
+        lman.state = LMAN_STATE_START_CONNECT_PARENT;
+        lman.next_state = LMAN_STATE_POLL_CONNECT_PARENT;
+    }
+    else
+    {
+        lman.state = LMAN_STATE_END_SEARCH_PARENT;
+        lman.next_state = LMAN_STATE_START_CONNECT_PARENT;
+    }
+    lman.work = parentId;
+    lman.connect_period = connect_period;
+    if (lman.pcswitch_flag != 0)
+    {
+        lman.pcswitch_flag = PCSWITCH_CP;
+    }
+    return 0;
+}
+
+static void rfu_LMAN_PARENT_stopWaitLinkRecoveryAndDisconnect(u8 bm_targetSlot)
+{
+    u8 i;
+
+    if ((bm_targetSlot & lman.linkRecoveryTimer.active) == 0)
+        return;
+    lman.linkRecoveryTimer.active &= ~bm_targetSlot;
+    for (i = 0; i < RFU_CHILD_MAX; i++)
+    {
+        if ((bm_targetSlot >> i) & 1)
+        {
+            lman.linkRecoveryTimer.count[i] = 0;
+        }
+    }
+    i = gRfuLinkStatus->linkLossSlotFlag & bm_targetSlot;
+    if (i)
+    {
+        rfu_LMAN_disconnect(i);
+    }
+    lman.param[0] = i;
+    rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, i);
+}
+
+void rfu_LMAN_stopManager(u8 forced_stop_and_RFU_reset_flag)
+{
+    u8 msg = 0;
+    lman.pcswitch_flag = 0;
+    if (forced_stop_and_RFU_reset_flag)
+    {
+        rfu_LMAN_clearVariables();
+        lman.state = LMAN_FORCED_STOP_AND_RFU_RESET;
+        return;
+    }
+    switch (lman.state)
+    {
+    case LMAN_STATE_START_SEARCH_CHILD:
+        lman.state = LMAN_STATE_WAIT_RECV_CHILD_NAME;
+        lman.next_state = LMAN_STATE_READY;
+        msg = LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED;
+        break;
+    case LMAN_STATE_POLL_SEARCH_CHILD:
+        lman.state = LMAN_STATE_END_SEARCH_CHILD;
+        lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME;
+        break;
+    case LMAN_STATE_END_SEARCH_CHILD:
+        lman.state = LMAN_STATE_END_SEARCH_CHILD;
+        lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME;
+        break;
+    case LMAN_STATE_WAIT_RECV_CHILD_NAME:
+        break;
+    case LMAN_STATE_START_SEARCH_PARENT:
+        lman.state = lman.next_state = LMAN_STATE_READY;
+        msg = LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED;
+        break;
+    case LMAN_STATE_POLL_SEARCH_PARENT:
+        lman.state = LMAN_STATE_END_SEARCH_PARENT;
+        lman.next_state = LMAN_STATE_READY;
+        break;
+    case LMAN_STATE_END_SEARCH_PARENT:
+        lman.state = LMAN_STATE_END_SEARCH_PARENT;
+        lman.next_state = LMAN_STATE_READY;
+        break;
+    case LMAN_STATE_START_CONNECT_PARENT:
+        lman.state = lman.next_state = LMAN_STATE_READY;
+        msg = LMAN_MSG_CONNECT_PARENT_FAILED;
+        break;
+    case LMAN_STATE_POLL_CONNECT_PARENT:
+        lman.state = LMAN_STATE_END_CONNECT_PARENT;
+        break;
+    case LMAN_STATE_END_CONNECT_PARENT:
+        lman.state = LMAN_STATE_END_CONNECT_PARENT;
+        break;
+    case LMAN_STATE_SEND_CHILD_NAME:
+        break;
+    case LMAN_STATE_START_LINK_RECOVERY:
+        lman.state = lman.state_bak[0];
+        lman.next_state = lman.state_bak[1];
+        rfu_LMAN_disconnect(gRfuLinkStatus->linkLossSlotFlag);
+        lman.param[0] = gRfuLinkStatus->linkLossSlotFlag;
+        rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1);
+        return;
+    case LMAN_STATE_POLL_LINK_RECOVERY:
+        lman.state = LMAN_STATE_END_LINK_RECOVERY;
+        break;
+    case LMAN_STATE_END_LINK_RECOVERY:
+        lman.state = LMAN_STATE_END_LINK_RECOVERY;
+        break;
+    default:
+        lman.state = lman.next_state = LMAN_STATE_READY;
+        msg = LMAN_MSG_MANAGER_STOPPED;
+        break;
+    }
+    if (lman.state == LMAN_STATE_READY)
+    {
+        rfu_LMAN_occureCallback(msg, 0);
+    }
+}
+
+static bool8 rfu_LMAN_linkWatcher(u16 REQ_commandID)
+{
+    u8 i;
+    u8 bm_linkLossSlot;
+    u8 reason;
+    u8 bm_linkRecoverySlot;
+    u8 bm_disconnectSlot;
+
+    bool8 disconnect_occure_flag = FALSE;
+    rfu_REQBN_watchLink(REQ_commandID, &bm_linkLossSlot, &reason, &bm_linkRecoverySlot);
+    if (bm_linkLossSlot)
+    {
+        lman.param[0] = bm_linkLossSlot;
+        lman.param[1] = reason;
+        if (lman.linkRecovery_enable)
+        {
+            lman.linkRecovery_start_flag = LINK_RECOVERY_START;
+            if (lman.parent_child == MODE_CHILD && reason == REASON_DISCONNECTED)
+            {
+                lman.linkRecovery_start_flag = LINK_RECOVERY_IMPOSSIBLE;
+            }
+            if (lman.linkRecovery_start_flag == LINK_RECOVERY_START)
+            {
+                for (i = 0; i < RFU_CHILD_MAX; i++)
+                {
+                    if ((bm_linkLossSlot >> i) & 1)
+                    {
+                        lman.linkRecoveryTimer.active |= (1 << i);
+                        lman.linkRecoveryTimer.count[i] = lman.linkRecoveryTimer.count_max;
+                    }
+                }
+                rfu_LMAN_occureCallback(LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY, 1);
+            }
+            else
+            {
+                lman.linkRecovery_start_flag = 0;
+                rfu_LMAN_disconnect(bm_linkLossSlot);
+                disconnect_occure_flag = TRUE;
+                rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1);
+            }
+        }
+        else
+        {
+            rfu_LMAN_disconnect(bm_linkLossSlot);
+            disconnect_occure_flag = TRUE;
+            rfu_LMAN_occureCallback(LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED, 2);
+        }
+        rfu_LMAN_managerChangeAgbClockMaster();
+    }
+    if (gRfuLinkStatus->parentChild == MODE_PARENT)
+    {
+        if (bm_linkRecoverySlot)
+        {
+            for (i = 0; i < RFU_CHILD_MAX; i++)
+            {
+                if ((lman.linkRecoveryTimer.active >> i) & 1 && (bm_linkRecoverySlot >> i) & 1)
+                {
+                    lman.linkRecoveryTimer.count[i] = 0;
+                }
+            }
+            lman.linkRecoveryTimer.active &= ~bm_linkRecoverySlot;
+            lman.param[0] = bm_linkRecoverySlot;
+            rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_SUCCESSED, 1);
+        }
+        if (lman.linkRecoveryTimer.active)
+        {
+            bm_disconnectSlot = 0;
+            for (i = 0; i < RFU_CHILD_MAX; i++)
+            {
+                if ((lman.linkRecoveryTimer.active >> i) & 1 && lman.linkRecoveryTimer.count[i] && --lman.linkRecoveryTimer.count[i] == 0)
+                {
+                    lman.linkRecoveryTimer.active &= ~(1 << i);
+                    bm_disconnectSlot |= (1 << i);
+                }
+            }
+            if (bm_disconnectSlot)
+            {
+                rfu_LMAN_disconnect(bm_disconnectSlot);
+                disconnect_occure_flag = TRUE;
+                lman.param[0] = bm_disconnectSlot;
+                rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1);
+            }
+        }
+        if (!lman.linkRecoveryTimer.active)
+        {
+            lman.linkRecovery_start_flag = 0;
+        }
+    }
+    return disconnect_occure_flag;
+}
+
+void rfu_LMAN_syncVBlank(void)
+{
+    if (rfu_syncVBlank())
+    {
+        rfu_LMAN_occureCallback(LMAN_MSG_WATCH_DOG_TIMER_ERROR, 0);
+        rfu_LMAN_managerChangeAgbClockMaster();
+    }
+}
+
+void rfu_LMAN_manager_entity(u32 rand)
+{
+    u8 msg;
+
+    if (lman.LMAN_callback == NULL && lman.state != LMAN_STATE_READY)
+    {
+        lman.state = LMAN_STATE_READY;
+        return;
+    }
+    if (lman.pcswitch_flag)
+    {
+        rfu_LMAN_settingPCSWITCH(rand);
+    }
+    while (1)
+    {
+        if (lman.state != LMAN_STATE_READY)
+        {
+            rfu_waitREQComplete();
+            lman.active = 1;
+            switch (lman.state)
+            {
+            case LMAN_FORCED_STOP_AND_RFU_RESET:
+                if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID)
+                {
+                    msg=LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET;
+                }
+                else
+                {
+                    msg=LMAN_MSG_RFU_FATAL_ERROR;
+                }
+                lman.state = lman.next_state = LMAN_STATE_READY;
+                rfu_LMAN_occureCallback(msg, 0);
+                break;
+            case LMAN_STATE_SOFT_RESET_AND_CHECK_ID:
+                if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID)
+                {
+                    lman.state = lman.next_state;
+                    lman.next_state = LMAN_STATE_CONFIG_SYSTEM;
+                }
+                else
+                {
+                    lman.state = lman.next_state = LMAN_STATE_READY;
+                    rfu_LMAN_occureCallback(LMAN_MSG_RFU_FATAL_ERROR, 0);
+                }
+                break;
+            case LMAN_STATE_RESET:
+                rfu_REQ_reset();
+                break;
+            case LMAN_STATE_CONFIG_SYSTEM:
+                rfu_REQ_configSystem(lman.init_param->availSlot_flag, lman.init_param->maxMFrame, lman.init_param->MC_TimerCount);
+                break;
+            case LMAN_STATE_CONFIG_GAME_DATA:
+                rfu_REQ_configGameData(lman.init_param->mboot_flag, lman.init_param->serialNo, (const u8 *)lman.init_param->gameName, lman.init_param->userName);
+                break;
+            case LMAN_STATE_START_SEARCH_CHILD:
+                rfu_REQ_startSearchChild();
+                break;
+            case LMAN_STATE_POLL_SEARCH_CHILD:
+                rfu_REQ_pollSearchChild();
+                break;
+            case LMAN_STATE_END_SEARCH_CHILD:
+                rfu_REQ_endSearchChild();
+                break;
+            case LMAN_STATE_WAIT_RECV_CHILD_NAME:
+                break;
+            case LMAN_STATE_START_SEARCH_PARENT:
+                rfu_REQ_startSearchParent();
+                break;
+            case LMAN_STATE_POLL_SEARCH_PARENT:
+                rfu_REQ_pollSearchParent();
+                break;
+            case LMAN_STATE_END_SEARCH_PARENT:
+                rfu_REQ_endSearchParent();
+                break;
+            case LMAN_STATE_START_CONNECT_PARENT:
+                rfu_REQ_startConnectParent(lman.work);
+                break;
+            case LMAN_STATE_POLL_CONNECT_PARENT:
+                rfu_REQ_pollConnectParent();
+                break;
+            case LMAN_STATE_END_CONNECT_PARENT:
+                rfu_REQ_endConnectParent();
+                break;
+            case LMAN_STATE_SEND_CHILD_NAME:
+                break;
+            case LMAN_STATE_START_LINK_RECOVERY:
+                rfu_REQ_CHILD_startConnectRecovery(gRfuLinkStatus->linkLossSlotFlag);
+                break;
+            case LMAN_STATE_POLL_LINK_RECOVERY:
+                rfu_REQ_CHILD_pollConnectRecovery();
+                break;
+            case LMAN_STATE_END_LINK_RECOVERY:
+                rfu_REQ_CHILD_endConnectRecovery();
+                break;
+            case LMAN_STATE_MS_CHANGE:
+                rfu_REQ_changeMasterSlave();
+                break;
+            case LMAN_STATE_WAIT_CLOCK_MASTER:
+                break;
+            case LMAN_STATE_STOP_MODE:
+                rfu_REQ_stopMode();
+                break;
+            case LMAN_STATE_BACK_STATE:
+                break;
+            default:
+                break;
+            }
+            rfu_waitREQComplete();
+            lman.active = 0;
+        }
+        if (lman.state == LMAN_STATE_END_LINK_RECOVERY || lman.state == LMAN_STATE_MS_CHANGE)
+            ;
+        else
+            break;
+    }
+    if (gRfuLinkStatus->parentChild == MODE_PARENT)
+    {
+        if (rfu_LMAN_linkWatcher(0))
+            return;
+    }
+    rfu_LMAN_PARENT_checkRecvChildName();
+    rfu_LMAN_CHILD_checkSendChildName();
+    rfu_LMAN_CHILD_linkRecoveryProcess();
+    rfu_LMAN_checkNICommunicateStatus();
+}
+
+static void rfu_LMAN_settingPCSWITCH(u32 rand)
+{
+    if (lman.pcswitch_flag == PCSWITCH_3RD_SC_START)
+    {
+        lman.parent_child = MODE_PARENT;
+        lman.state = LMAN_STATE_START_SEARCH_CHILD;
+        lman.connect_period = lman.pcswitch_period_bak;
+        if (lman.connect_period)
+        {
+            lman.pcswitch_flag = PCSWITCH_3RD_SC;
+        }
+        else
+        {
+            lman.pcswitch_flag = PCSWITCH_1ST_SC_START;
+        }
+    }
+    if (lman.pcswitch_flag == PCSWITCH_1ST_SC_START)
+    {
+        lman.parent_child = MODE_PARENT;
+        lman.state = LMAN_STATE_START_SEARCH_CHILD;
+        lman.connect_period = rand % 140;
+        lman.pcswitch_period_bak = 140 - lman.connect_period;
+        if (lman.connect_period)
+        {
+            lman.pcswitch_flag = PCSWITCH_1ST_SC;
+        }
+        else
+        {
+            lman.pcswitch_flag = PCSWITCH_2ND_SP_START;
+        }
+    }
+    if (lman.pcswitch_flag == PCSWITCH_2ND_SP_START)
+    {
+        lman.parent_child = MODE_CHILD;
+        lman.connect_period = PCSWITCH_SP_PERIOD;
+        lman.pcswitch_flag = PCSWITCH_2ND_SP;
+        lman.state = LMAN_STATE_START_SEARCH_PARENT;
+    }
+}
+
+static void rfu_LMAN_REQ_callback(u16 reqCommandId, u16 reqResult)
+{
+    u8 status;
+    u8 *stwiRecvBuffer;
+    u8 i;
+
+    if (lman.active != 0)
+    {
+        lman.active = 0;
+        switch (reqCommandId)
+        {
+        case ID_RESET_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state;
+                lman.next_state = LMAN_STATE_CONFIG_GAME_DATA;
+            }
+            break;
+        case ID_SYSTEM_CONFIG_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state;
+                lman.next_state = LMAN_STATE_READY;
+            }
+            break;
+        case ID_GAME_CONFIG_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state = LMAN_STATE_READY;
+                rfu_LMAN_occureCallback(LMAN_MSG_INITIALIZE_COMPLETED, 0);
+            }
+            break;
+        case ID_SC_START_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state = LMAN_STATE_POLL_SEARCH_CHILD;
+            }
+            break;
+        case ID_SC_POLL_REQ:
+            if (lman.connect_period && --lman.connect_period == 0)
+            {
+                lman.state = LMAN_STATE_END_SEARCH_CHILD;
+                lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME;
+            }
+            break;
+        case ID_SC_END_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state;
+                lman.next_state = LMAN_STATE_READY;
+                if (lman.pcswitch_flag == 0)
+                {
+                    rfu_LMAN_occureCallback(LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED, 0);
+                }
+            }
+            break;
+        case ID_SP_START_REQ:
+            if (reqResult == 0)
+            {
+                if (lman.fastSearchParent_flag == FSP_ON)
+                {
+                    if (lman.connect_period > 1)
+                    {
+                        lman.connect_period--;
+                    }
+                }
+                lman.state = lman.next_state = LMAN_STATE_POLL_SEARCH_PARENT;
+            }
+            break;
+        case ID_SP_POLL_REQ:
+            if (reqResult == 0)
+            {
+                status = rfu_LMAN_CHILD_checkEnableParentCandidate();
+                lman.param[0] = status;
+                if (status)
+                {
+                    rfu_LMAN_occureCallback(LMAN_MSG_PARENT_FOUND, 1);
+                }
+                if (lman.fastSearchParent_flag && lman.connect_period != 1 && gRfuLinkStatus->findParentCount == RFU_CHILD_MAX)
+                {
+                    rfu_REQ_endSearchParent();
+                    rfu_waitREQComplete();
+                    lman.state = LMAN_STATE_START_SEARCH_PARENT;
+                    lman.fastSearchParent_flag = FSP_ON;
+                }
+            }
+            if (lman.connect_period && --lman.connect_period == 0)
+            {
+                lman.state = LMAN_STATE_END_SEARCH_PARENT;
+                lman.next_state = LMAN_STATE_READY;
+            }
+            break;
+        case ID_SP_END_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state;
+                if (lman.pcswitch_flag == 0)
+                {
+                    if (lman.state == LMAN_STATE_READY)
+                    {
+                        rfu_LMAN_occureCallback(LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED, 0);
+                    }
+                }
+                else if (lman.pcswitch_flag != PCSWITCH_CP)
+                {
+                    lman.state = LMAN_STATE_START_SEARCH_CHILD;
+                    lman.pcswitch_flag = PCSWITCH_3RD_SC_START;
+                }
+            }
+            break;
+        case ID_CP_START_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state = LMAN_STATE_POLL_CONNECT_PARENT;
+            }
+            break;
+        case ID_CP_POLL_REQ:
+            if (reqResult == 0 && !rfu_getConnectParentStatus(&status, &lman.child_slot) && !status)
+            {
+                lman.state = LMAN_STATE_END_CONNECT_PARENT;
+            }
+            if (lman.connect_period && --lman.connect_period == 0)
+            {
+                lman.state = LMAN_STATE_END_CONNECT_PARENT;
+            }
+            break;
+        case ID_CP_END_REQ:
+            if (reqResult == 0 && !rfu_getConnectParentStatus(&status, &lman.child_slot))
+            {
+                if (!status)
+                {
+                    lman.state = LMAN_STATE_MS_CHANGE;
+                    lman.next_state = LMAN_STATE_SEND_CHILD_NAME;
+                    lman.work = 0x22;
+                    lman.param[0] = lman.child_slot;
+                }
+                else
+                {
+                    lman.state = lman.next_state = LMAN_STATE_READY;
+                    lman.work = 0x23;
+                    lman.param[0] = status;
+                    if (lman.pcswitch_flag)
+                    {
+                        lman.pcswitch_flag = PCSWITCH_2ND_SP_START;
+                        lman.state = LMAN_STATE_START_SEARCH_PARENT;
+                    }
+                }
+                rfu_LMAN_occureCallback(lman.work, 0x01);
+                lman.work = 0;
+            }
+            break;
+        case ID_CPR_START_REQ:
+            if (reqResult == 0)
+            {
+                lman.param[0] = gRfuLinkStatus->linkLossSlotFlag;
+                lman.state = lman.next_state = LMAN_STATE_POLL_LINK_RECOVERY;
+                for (lman.child_slot = 0; lman.child_slot < RFU_CHILD_MAX; lman.child_slot++)
+                {
+                    if ((gRfuLinkStatus->linkLossSlotFlag >> lman.child_slot) & 1)
+                    {
+                        break;
+                    }
+                }
+            }
+            break;
+        case ID_CPR_POLL_REQ:
+            if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&status) && status < 2)
+            {
+                lman.state = LMAN_STATE_END_LINK_RECOVERY;
+            }
+            if (lman.linkRecoveryTimer.count[lman.child_slot] && --lman.linkRecoveryTimer.count[lman.child_slot] == 0)
+            {
+                lman.state = LMAN_STATE_END_LINK_RECOVERY;
+            }
+            break;
+        case ID_CPR_END_REQ:
+            if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&status))
+            {
+                if (!status)
+                {
+                    lman.state = LMAN_STATE_MS_CHANGE;
+                    lman.next_state = LMAN_STATE_BACK_STATE;
+                    lman.work = 0x32;
+                }
+                else
+                {
+                    lman.state = lman.next_state = LMAN_STATE_READY;
+                    rfu_LMAN_disconnect(gRfuLinkStatus->linkLossSlotFlag);
+                    lman.work = 0x33;
+                }
+                lman.linkRecoveryTimer.count[lman.child_slot] = 0;
+                lman.linkRecoveryTimer.active = 0;
+                lman.linkRecovery_start_flag = 0;
+                rfu_LMAN_occureCallback(lman.work, 0x01);
+                lman.work = 0;
+            }
+            break;
+        case ID_MS_CHANGE_REQ:
+            if (reqResult == 0)
+            {
+                if (lman.next_state == LMAN_STATE_BACK_STATE)
+                {
+                    lman.state = lman.state_bak[0];
+                    lman.next_state = lman.state_bak[1];
+                    lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_ON;
+                    rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_SLAVE, 0);
+                }
+                else if (lman.next_state == LMAN_STATE_SEND_CHILD_NAME)
+                {
+                    lman.state = lman.next_state;
+                    lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_ON;
+                    rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_SLAVE, 0);
+                    lman.nameAcceptTimer.active |= 1 << lman.child_slot;
+                    lman.nameAcceptTimer.count[lman.child_slot] = lman.nameAcceptTimer.count_max;
+                    rfu_clearSlot(TYPE_NI_SEND, lman.child_slot);
+                    status = rfu_NI_CHILD_setSendGameName(lman.child_slot, 0x0e);
+                    if (status)
+                    {
+                        lman.state = lman.next_state = LMAN_STATE_READY;
+                        rfu_LMAN_managerChangeAgbClockMaster();
+                        rfu_LMAN_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
+                        lman.param[0] = status;
+                        rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED, 1);
+                    }
+                }
+            }
+            break;
+        case ID_STOP_MODE_REQ:
+            if (reqResult == 0)
+            {
+                lman.state = lman.next_state = LMAN_STATE_READY;
+                rfu_LMAN_occureCallback(LMAN_MSG_RFU_POWER_DOWN, 0);
+            }
+            break;
+        }
+        lman.active = 1;
+    }
+    else if (reqResult == 3 && lman.msc_exe_flag && (reqCommandId == ID_DATA_TX_REQ || reqCommandId == ID_DATA_RX_REQ || reqCommandId == ID_MS_CHANGE_REQ))
+    {
+        rfu_REQ_RFUStatus();
+        rfu_waitREQComplete();
+        rfu_getRFUStatus(&status);
+        if (status == 0 && gRfuLinkStatus->parentChild == MODE_CHILD)
+        {
+            stwiRecvBuffer = rfu_getSTWIRecvBuffer() + 4;
+            *stwiRecvBuffer++ = gRfuLinkStatus->connSlotFlag;
+            *stwiRecvBuffer = REASON_LINK_LOSS;
+            rfu_LMAN_linkWatcher(ID_DISCONNECTED_AND_CHANGE_REQ);
+            reqResult = 0;
+        }
+    }
+    switch (reqCommandId)
+    {
+    case ID_DISCONNECT_REQ:
+        if (reqResult == 0)
+        {
+            lman.param[0] = *(rfu_getSTWIRecvBuffer() + 8);
+            rfu_LMAN_reflectCommunicationStatus(lman.param[0]);
+            if (lman.linkRecoveryTimer.active)
+            {
+                lman.linkRecoveryTimer.active &= ~lman.param[0];
+                for (i = 0; i < RFU_CHILD_MAX; i++)
+                {
+                    if ((lman.param[0] >> i) & 1)
+                    {
+                        lman.linkRecoveryTimer.count[i] = 0;
+                    }
+                }
+                if (lman.parent_child == MODE_CHILD)
+                {
+                    lman.state = lman.next_state = LMAN_STATE_READY;
+                }
+            }
+            status = lman.acceptSlot_flag & lman.param[0];
+            for (i = 0; i < RFU_CHILD_MAX; i++)
+            {
+                if ((status >> i) & 1 && lman.acceptCount)
+                {
+                    lman.acceptCount--;
+                }
+            }
+            lman.acceptSlot_flag &= ~lman.param[0];
+            if (lman.pcswitch_flag)
+            {
+                if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
+                {
+                    if (lman.pcswitch_flag == PCSWITCH_SC_LOCK)
+                    {
+                        lman.connect_period = lman.pcswitch_period_bak;
+                        lman.pcswitch_flag = PCSWITCH_3RD_SC;
+                        lman.state = LMAN_STATE_POLL_SEARCH_CHILD;
+                    }
+                    else if (lman.state != LMAN_STATE_POLL_SEARCH_CHILD && lman.state != LMAN_STATE_END_SEARCH_CHILD)
+                    {
+                        lman.pcswitch_flag = PCSWITCH_1ST_SC_START;
+                        lman.state = LMAN_STATE_START_SEARCH_CHILD;
+                    }
+                }
+            }
+            if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
+            {
+                if (lman.state == LMAN_STATE_READY)
+                {
+                    lman.parent_child = MODE_NEUTRAL;
+                }
+            }
+            if (lman.active == 0)
+            {
+                rfu_LMAN_occureCallback(LMAN_MSG_LINK_DISCONNECTED_BY_USER, 1);
+            }
+        }
+        break;
+    case ID_DATA_RX_REQ:
+        rfu_LMAN_CHILD_checkSendChildName2();
+        if (gRfuLinkStatus->parentChild != MODE_NEUTRAL)
+        {
+            rfu_LMAN_occureCallback(LMAN_MSG_RECV_DATA_REQ_COMPLETED, 0);
+        }
+        break;
+    case ID_RESET_REQ:
+    case ID_STOP_MODE_REQ:
+        if (reqResult == 0)
+        {
+            lman.reserveDisconnectSlot_flag = 0;
+            lman.acceptCount = 0;
+            lman.acceptSlot_flag = 0;;
+            lman.parent_child = MODE_NEUTRAL;
+            rfu_LMAN_managerChangeAgbClockMaster();
+            if (reqCommandId == ID_STOP_MODE_REQ)
+            {
+                rfu_LMAN_endManager();
+            }
+        }
+        break;
+    }
+    if (reqResult != 0)
+    {
+        if (reqCommandId == ID_SP_START_REQ && reqResult != 0 && lman.pcswitch_flag == PCSWITCH_2ND_SP)
+        {
+            gRfuLinkStatus->parentChild = MODE_PARENT;
+            gRfuLinkStatus->connSlotFlag = 0xF;
+            rfu_LMAN_disconnect(15);
+            rfu_waitREQComplete();
+            return;
+        }
+        else
+        {
+            lman.param[0] = reqCommandId;
+            lman.param[1] = reqResult;
+            if (lman.active)
+            {
+                lman.state = lman.next_state = LMAN_STATE_READY;
+            }
+            rfu_LMAN_occureCallback(LMAN_MSG_REQ_API_ERROR, 2);
+            rfu_LMAN_managerChangeAgbClockMaster();
+        }
+    }
+    if (reqCommandId == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ)
+    {
+        rfu_LMAN_occureCallback(LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA, 0);
+        rfu_LMAN_managerChangeAgbClockMaster();
+    }
+}
+
+static void rfu_LMAN_MSC_callback(u16 reqCommandId)
+{
+    u8 active_bak;
+    u8 thisAck_flag;
+
+    active_bak = lman.active;
+    lman.active = 0;
+    lman.msc_exe_flag = 1;
+    if (gRfuLinkStatus->parentChild == MODE_CHILD)
+    {
+        rfu_LMAN_linkWatcher(reqCommandId);
+        if (lman.childClockSlave_flag != RFU_CHILD_CLOCK_SLAVE_ON)
+        {
+            rfu_LMAN_managerChangeAgbClockMaster();
+            lman.msc_exe_flag = 0;
+            lman.active = active_bak;
+            return;
+        }
+    }
+    else
+    {
+        if (!rfu_UNI_PARENT_getDRAC_ACK(&thisAck_flag))
+        {
+            lman.parentAck_flag |= thisAck_flag;
+        }
+    }
+    if (lman.MSC_callback != NULL)
+    {
+        lman.MSC_callback(reqCommandId);
+        rfu_waitREQComplete();
+        if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF_REQ)
+        {
+            rfu_LMAN_managerChangeAgbClockMaster();
+        }
+    }
+    lman.msc_exe_flag = 0;
+    lman.active = active_bak;
+}
+
+static void rfu_LMAN_PARENT_checkRecvChildName(void)
+{
+    u8 newSlot;
+    u8 newAcceptSlot;
+    u8 i;
+    u8 flags;
+    u8 tgtSlot;
+    const u16 *ptr;
+
+    if (lman.state == LMAN_STATE_START_SEARCH_CHILD || lman.state == LMAN_STATE_POLL_SEARCH_CHILD || lman.state == LMAN_STATE_END_SEARCH_CHILD || lman.state == LMAN_STATE_WAIT_RECV_CHILD_NAME)
+    {
+        newSlot = ((gRfuLinkStatus->connSlotFlag ^ lman.connectSlot_flag_old) & gRfuLinkStatus->connSlotFlag) & ~gRfuLinkStatus->getNameFlag;
+        lman.connectSlot_flag_old = gRfuLinkStatus->connSlotFlag;
+        if (newSlot)
+        {
+            lman.param[0] = newSlot;
+            rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_DETECTED, 1);
+        }
+        newAcceptSlot = 0x00;
+        for (i = 0; i < RFU_CHILD_MAX; i++)
+        {
+            tgtSlot = 1 << i;
+            flags = 0x00;
+            if (newSlot & tgtSlot)
+            {
+                lman.nameAcceptTimer.count[i] = lman.nameAcceptTimer.count_max;
+                lman.nameAcceptTimer.active |= tgtSlot;
+            }
+            else if (lman.nameAcceptTimer.active & tgtSlot)
+            {
+                if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS)
+                {
+                    if (gRfuSlotStatusNI[i]->recv.dataType == 1)
+                    {
+                        flags = RN_NAME_TIMER_CLEAR;
+                        for (ptr = lman.acceptable_serialNo_list; *ptr != 0xFFFF; ptr++)
+                        {
+                            if (gRfuLinkStatus->partner[i].serialNo == *ptr)
+                            {
+                                lman.acceptSlot_flag |= tgtSlot;
+                                lman.acceptCount++;
+                                newAcceptSlot |= tgtSlot;
+                                flags |= RN_ACCEPT;
+                                break;
+                            }
+                        }
+                        if (!(flags & RN_ACCEPT))
+                        {
+                            flags |= RN_DISCONNECT;
+                        }
+                    }
+                }
+                else if (--lman.nameAcceptTimer.count[i] == 0)
+                {
+                    flags = RN_NAME_TIMER_CLEAR | RN_DISCONNECT;
+                }
+                if (flags & RN_NAME_TIMER_CLEAR)
+                {
+                    lman.nameAcceptTimer.active &= ~tgtSlot;
+                    lman.nameAcceptTimer.count[i] = 0;
+                    rfu_clearSlot(TYPE_NI_RECV, i);
+                }
+                if (flags & RN_DISCONNECT)
+                {
+                    lman.reserveDisconnectSlot_flag |= tgtSlot;
+                }
+            }
+        }
+        if (newAcceptSlot)
+        {
+            lman.param[0] = newAcceptSlot;
+            rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED, 1);
+        }
+        if (lman.reserveDisconnectSlot_flag)
+        {
+            flags = 1;
+            if (gRfuLinkStatus->sendSlotUNIFlag)
+            {
+                if (((lman.parentAck_flag & lman.acceptSlot_flag) != lman.acceptSlot_flag))
+                {
+                    flags = 0;
+                }
+            }
+            if (flags)
+            {
+                rfu_LMAN_disconnect(lman.reserveDisconnectSlot_flag);
+                lman.param[0] = lman.reserveDisconnectSlot_flag;
+                lman.reserveDisconnectSlot_flag = 0;
+                rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_REJECTED, 1);
+            }
+        }
+        if (lman.nameAcceptTimer.active == 0 && lman.state == LMAN_STATE_WAIT_RECV_CHILD_NAME)
+        {
+            if (lman.pcswitch_flag == 0)
+            {
+                lman.state = lman.next_state = LMAN_STATE_READY;
+                rfu_LMAN_occureCallback(LMAN_MSG_END_WAIT_CHILD_NAME, 0);
+            }
+            else
+            {
+                if (lman.pcswitch_flag == PCSWITCH_1ST_SC)
+                {
+                    lman.pcswitch_flag = PCSWITCH_2ND_SP_START;
+                    lman.state = LMAN_STATE_START_SEARCH_PARENT;
+                }
+                else
+                {
+                    lman.pcswitch_flag = PCSWITCH_1ST_SC_START;
+                    lman.state = LMAN_STATE_START_SEARCH_CHILD;
+                }
+                if (lman.acceptSlot_flag)
+                {
+                    lman.connect_period = 0;
+                    lman.pcswitch_flag = PCSWITCH_SC_LOCK;
+                    lman.state = LMAN_STATE_START_SEARCH_CHILD;
+                }
+            }
+        }
+    }
+}
+
+static void rfu_LMAN_CHILD_checkSendChildName(void)
+{
+    u16 imeBak = REG_IME;
+    REG_IME = 0;
+    if (lman.state == LMAN_STATE_SEND_CHILD_NAME)
+    {
+        if (--lman.nameAcceptTimer.count[lman.child_slot] == 0 || gRfuSlotStatusNI[lman.child_slot]->send.state == SLOT_STATE_SEND_FAILED)
+        {
+            rfu_LMAN_requestChangeAgbClockMaster();
+            lman.state = LMAN_STATE_WAIT_CHANGE_CLOCK_MASTER;
+            rfu_clearSlot(TYPE_NI_SEND, lman.child_slot);
+            lman.nameAcceptTimer.active &= ~(1 << lman.child_slot);
+            lman.nameAcceptTimer.count[lman.child_slot] = 0;
+        }
+    }
+    REG_IME = imeBak;
+    if (lman.state == LMAN_STATE_WAIT_CHANGE_CLOCK_MASTER)
+    {
+        if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON)
+        {
+            rfu_LMAN_requestChangeAgbClockMaster();
+        }
+        if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF)
+        {
+            lman.state = lman.next_state = LMAN_STATE_READY;
+            rfu_LMAN_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
+            lman.param[0] = 0;
+            rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED, 1);
+        }
+    }
+}
+
+static void rfu_LMAN_CHILD_checkSendChildName2(void)
+{
+    if (lman.state == LMAN_STATE_SEND_CHILD_NAME && gRfuSlotStatusNI[lman.child_slot]->send.state == SLOT_STATE_SEND_SUCCESS)
+    {
+        lman.state = lman.next_state = LMAN_STATE_READY;
+        rfu_clearSlot(TYPE_NI_SEND, lman.child_slot);
+        lman.nameAcceptTimer.active &= ~(1 << lman.child_slot);
+        lman.nameAcceptTimer.count[lman.child_slot] = 0;
+        rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_COMPLETED, 0);
+    }
+}
+
+static void rfu_LMAN_CHILD_linkRecoveryProcess(void)
+{
+    if (lman.parent_child == MODE_CHILD && lman.linkRecovery_start_flag == LINK_RECOVERY_START)
+    {
+        lman.state_bak[0] = lman.state;
+        lman.state_bak[1] = lman.next_state;
+        lman.state = LMAN_STATE_START_LINK_RECOVERY;
+        lman.next_state = LMAN_STATE_POLL_LINK_RECOVERY;
+        lman.linkRecovery_start_flag = LINK_RECOVERY_EXE;
+    }
+}
+
+static u8 rfu_LMAN_CHILD_checkEnableParentCandidate(void)
+{
+    u8 i;
+    u16 *serialNo;
+    u8 flags = 0x00;
+
+    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
+    {
+        for (serialNo = lman.acceptable_serialNo_list; *serialNo != 0xFFFF; serialNo++)
+        {
+            if (gRfuLinkStatus->partner[i].serialNo == *serialNo)
+            {
+                flags |= (1 << i);
+            }
+        }
+    }
+    return flags;
+}
+
+static void rfu_LMAN_occureCallback(u8 msg, u8 param_count)
+{
+    if (lman.LMAN_callback != NULL)
+    {
+        lman.LMAN_callback(msg, param_count);
+    }
+    lman.param[0] = lman.param[1] = 0;
+}
+
+static void rfu_LMAN_disconnect(u8 bm_disconnectedSlot)
+{
+    u8 active_bak = lman.active;
+    lman.active = 1;
+    rfu_REQ_disconnect(bm_disconnectedSlot);
+    rfu_waitREQComplete();
+    lman.active = active_bak;
+}
+
+static void rfu_LMAN_reflectCommunicationStatus(u8 bm_disconnectedSlot)
+{
+    u8 i;
+
+    if (gRfuLinkStatus->sendSlotNIFlag)
+    {
+        for (i = 0; i < RFU_CHILD_MAX; i++)
+        {
+            if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->send.bmSlot & bm_disconnectedSlot)
+            {
+                rfu_changeSendTarget(TYPE_NI, i, gRfuSlotStatusNI[i]->send.bmSlot & ~bm_disconnectedSlot);
+            }
+        }
+    }
+    if (gRfuLinkStatus->recvSlotNIFlag)
+    {
+        for (i = 0; i < RFU_CHILD_MAX; i++)
+        {
+            if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.bmSlot & bm_disconnectedSlot)
+            {
+                rfu_NI_stopReceivingData(i);
+            }
+        }
+    }
+    if (gRfuLinkStatus->sendSlotUNIFlag)
+    {
+        gRfuLinkStatus->sendSlotUNIFlag &= ~bm_disconnectedSlot;
+        for (i = 0; i < RFU_CHILD_MAX; i++)
+        {
+            if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI && bm_disconnectedSlot & gRfuSlotStatusUNI[i]->send.bmSlot)
+            {
+                gRfuSlotStatusUNI[i]->send.bmSlot &= ~bm_disconnectedSlot;
+            }
+        }
+    }
+}
+
+static void rfu_LMAN_checkNICommunicateStatus(void)
+{
+    u8 i;
+    u8 j;
+    u8 flags;
+
+    if (lman.NI_failCounter_limit)
+    {
+        if (gRfuLinkStatus->sendSlotNIFlag)
+        {
+            for (i = 0; i < RFU_CHILD_MAX; i++)
+            {
+                if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG)
+                {
+                    flags = 0;
+                    for (j = 0; j < RFU_CHILD_MAX; j++)
+                    {
+                        if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > lman.NI_failCounter_limit)
+                        {
+                            flags |= (1 << j);
+                        }
+                        if (flags)
+                        {
+                            rfu_changeSendTarget(TYPE_NI, i, flags ^ gRfuSlotStatusNI[i]->send.bmSlot);
+                        }
+                    }
+                }
+            }
+        }
+        if (gRfuLinkStatus->recvSlotNIFlag)
+        {
+            for (i = 0; i < RFU_CHILD_MAX; i++)
+            {
+                if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.failCounter > lman.NI_failCounter_limit)
+                {
+                    rfu_NI_stopReceivingData(i);
+                }
+            }
+        }
+    }
+}
+
+void rfu_LMAN_setMSCCallback(void (*MSC_callback_p)(u16))
+{
+    lman.MSC_callback = MSC_callback_p;
+    rfu_setMSCCallback(rfu_LMAN_MSC_callback);
+}
+
+static void rfu_LMAN_setLMANCallback(void (*func)(u8, u8))
+{
+    lman.LMAN_callback = func;
+}
+
+u8 rfu_LMAN_setLinkRecovery(u8 enable_flag, u16 recovery_period)
+{
+    u16 imeBak;
+    if (lman.linkRecovery_enable && enable_flag == 0 && lman.linkRecoveryTimer.active)
+    {
+        return LMAN_ERROR_NOW_LINK_RECOVERY;
+    }
+    imeBak = REG_IME;
+    REG_IME = 0;
+    lman.linkRecovery_enable = enable_flag;
+    lman.linkRecoveryTimer.count_max = recovery_period;
+    REG_IME = imeBak;
+    return 0;
+}
+
+static u8 rfu_LMAN_setNIFailCounterLimit(u16 NI_failCounter_limit)
+{
+    if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag)
+    {
+        lman.param[0] = 6;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_NOW_COMMUNICATION;
+    }
+    lman.NI_failCounter_limit = NI_failCounter_limit;
+    return 0;
+}
+
+static u8 rfu_LMAN_setFastSearchParent(u8 enable_flag)
+{
+    if (lman.state == LMAN_STATE_START_SEARCH_PARENT || lman.state == LMAN_STATE_POLL_SEARCH_PARENT || lman.state == LMAN_STATE_END_SEARCH_PARENT)
+    {
+        lman.param[0] = 7;
+        rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1);
+        return LMAN_ERROR_NOW_SEARCH_PARENT;
+    }
+    if (enable_flag)
+    {
+        lman.fastSearchParent_flag = FSP_ON;
+    }
+    else
+    {
+        lman.fastSearchParent_flag = 0;
+    }
+    return 0;
+}
+
+static void rfu_LMAN_managerChangeAgbClockMaster(void)
+{
+    if (lman.childClockSlave_flag != RFU_CHILD_CLOCK_SLAVE_OFF)
+    {
+        lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_OFF;
+        rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_MASTER, 0);
+    }
+}
+
+void rfu_LMAN_requestChangeAgbClockMaster(void)
+{
+    if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF)
+    {
+        rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_MASTER, 0);
+    }
+    else if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON)
+    {
+        lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_OFF_REQ;
+    }
+}
+
+void rfu_LMAN_forceChangeSP(void)
+{
+    if (lman.pcswitch_flag)
+    {
+        switch (lman.state)
+        {
+        case LMAN_STATE_START_SEARCH_CHILD:
+            lman.pcswitch_flag = PCSWITCH_2ND_SP_START;
+            lman.state = LMAN_STATE_START_SEARCH_PARENT;
+            break;
+        case LMAN_STATE_POLL_SEARCH_CHILD:
+            lman.pcswitch_flag = PCSWITCH_1ST_SC;
+            lman.connect_period = 1;
+            break;
+        case LMAN_STATE_END_SEARCH_CHILD:
+        case LMAN_STATE_WAIT_RECV_CHILD_NAME:
+            lman.pcswitch_flag = PCSWITCH_1ST_SC;
+            break;
+        case LMAN_STATE_START_SEARCH_PARENT:
+        case LMAN_STATE_POLL_SEARCH_PARENT:
+            lman.connect_period = PCSWITCH_SP_PERIOD;
+            break;
+        case LMAN_STATE_END_SEARCH_PARENT:
+            lman.connect_period = PCSWITCH_SP_PERIOD;
+            lman.state = LMAN_STATE_POLL_SEARCH_PARENT;
+            break;
+        }
+    }
+}
diff --git a/src/bag.c b/src/bag.c
index 049aa9f8f..2ca62a3b4 100644
--- a/src/bag.c
+++ b/src/bag.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "task.h"
 #include "palette.h"
 #include "item_menu.h"
 #include "text.h"
@@ -9,7 +8,6 @@
 #include "new_menu_helpers.h"
 #include "menu.h"
 #include "money.h"
-#include "bag.h"
 #include "strings.h"
 
 static const u16 sBagWindowPalF[] = INCBIN_U16("data/bag/bag_window_pal.gbapal");
diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c
index 647d2f367..33b5ceacc 100644
--- a/src/battle_anim_effects_1.c
+++ b/src/battle_anim_effects_1.c
@@ -1,15 +1,9 @@
 #include "global.h"
-#include "malloc.h"
 #include "battle_anim.h"
 #include "battle_interface.h"
-#include "decompress.h"
 #include "gpu_regs.h"
-#include "graphics.h"
-#include "main.h"
-#include "math_util.h"
 #include "palette.h"
 #include "random.h"
-#include "scanline_effect.h"
 #include "sound.h"
 #include "trig.h"
 #include "util.h"
diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c
index 23be07785..093660389 100644
--- a/src/battle_anim_effects_2.c
+++ b/src/battle_anim_effects_2.c
@@ -5,7 +5,6 @@
 #include "decompress.h"
 #include "gpu_regs.h"
 #include "graphics.h"
-#include "main.h"
 #include "math_util.h"
 #include "palette.h"
 #include "random.h"
diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c
index d74b743e8..f2740a1a5 100644
--- a/src/battle_anim_sound_tasks.c
+++ b/src/battle_anim_sound_tasks.c
@@ -178,7 +178,7 @@ void sub_80DD148(u8 taskId)
     gTasks[taskId].data[2] = pan;
     if (species != SPECIES_NONE)
     {
-        if (gBattleAnimArgs[1] == TASK_NONE)
+        if (gBattleAnimArgs[1] == TAIL_SENTINEL)
             PlayCry3(species, pan, 9);
         else
             PlayCry3(species, pan, 7);
@@ -199,7 +199,7 @@ static void sub_80DD270(u8 taskId)
     {
         ++gTasks[taskId].data[9];
     }
-    else if (gTasks[taskId].data[0] == TASK_NONE)
+    else if (gTasks[taskId].data[0] == TAIL_SENTINEL)
     {
         if (!IsCryPlaying())
         {
diff --git a/src/battle_bg.c b/src/battle_bg.c
new file mode 100644
index 000000000..1c0b41bb4
--- /dev/null
+++ b/src/battle_bg.c
@@ -0,0 +1,1076 @@
+#include "global.h"
+#include "gflib.h"
+#include "battle.h"
+#include "battle_bg.h"
+#include "battle_message.h"
+#include "decompress.h"
+#include "graphics.h"
+#include "link.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+#include "text_window.h"
+#include "trig.h"
+#include "constants/maps.h"
+#include "constants/songs.h"
+#include "constants/trainer_classes.h"
+
+#define TAG_VS_LETTERS 10000
+
+struct BattleBackground
+{
+    const void *tileset;
+    const void *tilemap;
+    const void *entryTileset;
+    const void *entryTilemap;
+    const void *palette;
+};
+
+static void CB2_unused(void);
+static u8 GetBattleTerrainOverride(void);
+
+static const u8 gUnknown_824829C[] = {1, 2};
+
+static const struct OamData gOamData_82482A0 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_DOUBLE,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0x000,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData gOamData_82482A8 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_DOUBLE,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0x040,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const union AffineAnimCmd gUnknown_82482B0[] = {
+    AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0),
+    AFFINEANIMCMD_END
+};
+
+static const union AffineAnimCmd gUnknown_82482C0[] = {
+    AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0),
+    AFFINEANIMCMD_FRAME(0x18, 0x18, 0x0, 0x80),
+    AFFINEANIMCMD_FRAME(0x18, 0x18, 0x0, 0x80),
+    AFFINEANIMCMD_END
+};
+
+static const union AffineAnimCmd *const gAffineAnimTable_82482E0[] = {
+    gUnknown_82482B0,
+    gUnknown_82482C0
+};
+
+static const struct SpriteTemplate sVsLetter_V_SpriteTemplate = {
+    .tileTag = TAG_VS_LETTERS,
+    .paletteTag = TAG_VS_LETTERS,
+    .oam = &gOamData_82482A0,
+    .anims = gDummySpriteAnimTable,
+    .affineAnims = gAffineAnimTable_82482E0,
+    .callback = nullsub_9
+};
+
+static const struct SpriteTemplate sVsLetter_S_SpriteTemplate = {
+    .tileTag = TAG_VS_LETTERS,
+    .paletteTag = TAG_VS_LETTERS,
+    .oam = &gOamData_82482A8,
+    .anims = gDummySpriteAnimTable,
+    .affineAnims = gAffineAnimTable_82482E0,
+    .callback = nullsub_9
+};
+
+static const struct CompressedSpriteSheet sVsLettersSpriteSheet = {
+    gVsLettersGfx,
+    0x1000,
+    TAG_VS_LETTERS
+};
+
+const struct BgTemplate gBattleBgTemplates[4] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 24,
+        .screenSize = 2,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    }, {
+        .bg = 1,
+        .charBaseIndex = 1,
+        .mapBaseIndex = 28,
+        .screenSize = 2,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    }, {
+        .bg = 2,
+        .charBaseIndex = 1,
+        .mapBaseIndex = 30,
+        .screenSize = 1,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0x000
+    }, {
+        .bg = 3,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 26,
+        .screenSize = 1,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x000
+    }
+};
+
+static const struct WindowTemplate gUnknown_8248330[] = {
+    {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 15,
+        .width = 28,
+        .height = 4,
+        .paletteNum = 0,
+        .baseBlock = 0x090
+    }, {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 35,
+        .width = 14,
+        .height = 4,
+        .paletteNum = 0,
+        .baseBlock = 0x1c0
+    }, {
+        .bg = 0,
+        .tilemapLeft = 17,
+        .tilemapTop = 35,
+        .width = 12,
+        .height = 4,
+        .paletteNum = 5,
+        .baseBlock = 0x190
+    }, {
+        .bg = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 55,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x300
+    }, {
+        .bg = 0,
+        .tilemapLeft = 11,
+        .tilemapTop = 55,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x310
+    }, {
+        .bg = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 57,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x320
+    }, {
+        .bg = 0,
+        .tilemapLeft = 11,
+        .tilemapTop = 57,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x330
+    }, {
+        .bg = 0,
+        .tilemapLeft = 21,
+        .tilemapTop = 55,
+        .width = 3,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x290
+    }, {
+        .bg = 0,
+        .tilemapLeft = 21,
+        .tilemapTop = 57,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x296
+    }, {
+        .bg = 0,
+        .tilemapLeft = 24,
+        .tilemapTop = 55,
+        .width = 5,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x2a6
+    }, {
+        .bg = 0,
+        .tilemapLeft = 25,
+        .tilemapTop = 57,
+        .width = 0,
+        .height = 0,
+        .paletteNum = 5,
+        .baseBlock = 0x2b0
+    }, {
+        .bg = 0,
+        .tilemapLeft = 21,
+        .tilemapTop = 55,
+        .width = 8,
+        .height = 4,
+        .paletteNum = 5,
+        .baseBlock = 0x2b0
+    }, {
+        .bg = 1,
+        .tilemapLeft = 19,
+        .tilemapTop = 8,
+        .width = 10,
+        .height = 11,
+        .paletteNum = 5,
+        .baseBlock = 0x100
+    }, {
+        .bg = 2,
+        .tilemapLeft = 18,
+        .tilemapTop = 0,
+        .width = 12,
+        .height = 3,
+        .paletteNum = 6,
+        .baseBlock = 0x16e
+    }, {
+        .bg = 0,
+        .tilemapLeft = 25,
+        .tilemapTop = 9,
+        .width = 4,
+        .height = 4,
+        .paletteNum = 5,
+        .baseBlock = 0x100
+    }, {
+        .bg = 1,
+        .tilemapLeft = 2,
+        .tilemapTop = 3,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x020
+    }, {
+        .bg = 2,
+        .tilemapLeft = 2,
+        .tilemapTop = 3,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x040
+    }, {
+        .bg = 1,
+        .tilemapLeft = 2,
+        .tilemapTop = 2,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x020
+    }, {
+        .bg = 2,
+        .tilemapLeft = 2,
+        .tilemapTop = 2,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x040
+    }, {
+        .bg = 1,
+        .tilemapLeft = 2,
+        .tilemapTop = 6,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x060
+    }, {
+        .bg = 2,
+        .tilemapLeft = 2,
+        .tilemapTop = 6,
+        .width = 7,
+        .height = 2,
+        .paletteNum = 5,
+        .baseBlock = 0x080
+    }, {
+        .bg = 0,
+        .tilemapLeft = 11,
+        .tilemapTop = 2,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 0,
+        .baseBlock = 0x0a0
+    }, {
+        .bg = 0,
+        .tilemapLeft = 4,
+        .tilemapTop = 2,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 0,
+        .baseBlock = 0x0a0
+    }, {
+        .bg = 0,
+        .tilemapLeft = 19,
+        .tilemapTop = 2,
+        .width = 8,
+        .height = 2,
+        .paletteNum = 0,
+        .baseBlock = 0x0b0
+    }, {
+        .bg = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 15,
+        .width = 26,
+        .height = 4,
+        .paletteNum = 7,
+        .baseBlock = 0x090
+    }, DUMMY_WIN_TEMPLATE
+};
+
+static const u32 sBattleTerrainPalette_Grass[] = INCBIN_U32("graphics/battle/unk_8248400.gbapal.lz");
+static const u32 sBattleTerrainTiles_Grass[] = INCBIN_U32("graphics/battle/unk_824844C.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Grass[] = INCBIN_U32("graphics/battle/unk_82489A8.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Grass[] = INCBIN_U32("graphics/battle/unk_8248C68.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Grass[] = INCBIN_U32("graphics/battle/unk_8248F58.bin.lz");
+static const u32 sBattleTerrainPalette_LongGrass[] = INCBIN_U32("graphics/battle/unk_8249074.gbapal.lz");
+static const u32 sBattleTerrainTiles_LongGrass[] = INCBIN_U32("graphics/battle/unk_82490C4.4bpp.lz");
+static const u32 sBattleTerrainTilemap_LongGrass[] = INCBIN_U32("graphics/battle/unk_8249620.bin.lz");
+static const u32 sBattleTerrainAnimTiles_LongGrass[] = INCBIN_U32("graphics/battle/unk_82498DC.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_LongGrass[] = INCBIN_U32("graphics/battle/unk_8249E10.bin.lz");
+static const u32 sBattleTerrainPalette_Sand[] = INCBIN_U32("graphics/battle/unk_8249F98.gbapal.lz");
+static const u32 sBattleTerrainTiles_Sand[] = INCBIN_U32("graphics/battle/unk_8249FE4.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Sand[] = INCBIN_U32("graphics/battle/unk_824A37C.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Sand[] = INCBIN_U32("graphics/battle/unk_824A618.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Sand[] = INCBIN_U32("graphics/battle/unk_824A844.bin.lz");
+static const u32 sBattleTerrainPalette_Underwater[] = INCBIN_U32("graphics/battle/unk_824A940.gbapal.lz");
+static const u32 sBattleTerrainTiles_Underwater[] = INCBIN_U32("graphics/battle/unk_824A990.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Underwater[] = INCBIN_U32("graphics/battle/unk_824ACD0.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Underwater[] = INCBIN_U32("graphics/battle/unk_824AF70.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Underwater[] = INCBIN_U32("graphics/battle/unk_824B0DC.bin.lz");
+static const u32 sBattleTerrainPalette_Water[] = INCBIN_U32("graphics/battle/unk_824B19C.gbapal.lz");
+static const u32 sBattleTerrainTiles_Water[] = INCBIN_U32("graphics/battle/unk_824B1EC.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Water[] = INCBIN_U32("graphics/battle/unk_824B608.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Water[] = INCBIN_U32("graphics/battle/unk_824B8A8.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Water[] = INCBIN_U32("graphics/battle/unk_824BBE0.bin.lz");
+static const u32 sBattleTerrainPalette_Pond[] = INCBIN_U32("graphics/battle/unk_824BCE0.gbapal.lz");
+static const u32 sBattleTerrainTiles_Pond[] = INCBIN_U32("graphics/battle/unk_824BD38.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Pond[] = INCBIN_U32("graphics/battle/unk_824C07C.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Pond[] = INCBIN_U32("graphics/battle/unk_824C314.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Pond[] = INCBIN_U32("graphics/battle/unk_824C520.bin.lz");
+static const u32 sBattleTerrainPalette_Mountain[] = INCBIN_U32("graphics/battle/unk_824C5D8.gbapal.lz");
+static const u32 sBattleTerrainTiles_Mountain[] = INCBIN_U32("graphics/battle/unk_824C624.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Mountain[] = INCBIN_U32("graphics/battle/unk_824C958.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Mountain[] = INCBIN_U32("graphics/battle/unk_824CBF8.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Mountain[] = INCBIN_U32("graphics/battle/unk_824CEC8.bin.lz");
+static const u32 sBattleTerrainPalette_Cave[] = INCBIN_U32("graphics/battle/unk_824CF98.gbapal.lz");
+static const u32 sBattleTerrainTiles_Cave[] = INCBIN_U32("graphics/battle/unk_824CFEC.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Cave[] = INCBIN_U32("graphics/battle/unk_824D418.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Cave[] = INCBIN_U32("graphics/battle/unk_824D6B8.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Cave[] = INCBIN_U32("graphics/battle/unk_824DC98.bin.lz");
+static const u32 sBattleTerrainPalette_Building[] = INCBIN_U32("graphics/battle/unk_824DDF0.gbapal.lz");
+static const u32 sBattleTerrainTiles_Building[] = INCBIN_U32("graphics/battle/unk_824DE34.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Building[] = INCBIN_U32("graphics/battle/unk_824E16C.bin.lz");
+static const u32 sBattleTerrainAnimTiles_Building[] = INCBIN_U32("graphics/battle/unk_824E410.4bpp.lz");
+static const u32 sBattleTerrainAnimTilemap_Building[] = INCBIN_U32("graphics/battle/unk_824E490.bin.lz");
+static const u32 sBattleTerrainPalette_Link[] = INCBIN_U32("graphics/battle/unk_824E528.gbapal.lz");
+static const u32 sBattleTerrainPalette_Gym[] = INCBIN_U32("graphics/battle/unk_824E56C.gbapal.lz");
+static const u32 sBattleTerrainPalette_Leader[] = INCBIN_U32("graphics/battle/unk_824E5B8.gbapal.lz");
+static const u32 sBattleTerrainPalette_Indoor2[] = INCBIN_U32("graphics/battle/unk_824E604.gbapal.lz");
+static const u32 sBattleTerrainPalette_Indoor1[] = INCBIN_U32("graphics/battle/unk_824E650.gbapal.lz");
+static const u32 sBattleTerrainPalette_Lorelei[] = INCBIN_U32("graphics/battle/unk_824E6A4.gbapal.lz");
+static const u32 sBattleTerrainPalette_Bruno[] = INCBIN_U32("graphics/battle/unk_824E6F0.gbapal.lz");
+static const u32 sBattleTerrainPalette_Agatha[] = INCBIN_U32("graphics/battle/unk_824E740.gbapal.lz");
+static const u32 sBattleTerrainPalette_Lance[] = INCBIN_U32("graphics/battle/unk_824E78C.gbapal.lz");
+static const u32 sBattleTerrainPalette_Champion[] = INCBIN_U32("graphics/battle/unk_824E7DC.gbapal.lz");
+static const u32 sBattleTerrainPalette_Plain[] = INCBIN_U32("graphics/battle/unk_824E81C.gbapal.lz");
+static const u32 sBattleTerrainTiles_Indoor2[] = INCBIN_U32("graphics/battle/unk_824E858.4bpp.lz");
+static const u32 sBattleTerrainTilemap_Indoor2[] = INCBIN_U32("graphics/battle/unk_824EB90.bin.lz");
+
+static const struct BattleBackground sBattleTerrainTable[] = {
+    [BATTLE_TERRAIN_GRASS] =
+    {
+        .tileset = sBattleTerrainTiles_Grass,
+        .tilemap = sBattleTerrainTilemap_Grass,
+        .entryTileset = sBattleTerrainAnimTiles_Grass,
+        .entryTilemap = sBattleTerrainAnimTilemap_Grass,
+        .palette = sBattleTerrainPalette_Grass
+    },
+    [BATTLE_TERRAIN_LONG_GRASS] =
+    {
+        .tileset = sBattleTerrainTiles_LongGrass,
+        .tilemap = sBattleTerrainTilemap_LongGrass,
+        .entryTileset = sBattleTerrainAnimTiles_LongGrass,
+        .entryTilemap = sBattleTerrainAnimTilemap_LongGrass,
+        .palette = sBattleTerrainPalette_LongGrass
+    },
+    [BATTLE_TERRAIN_SAND] =
+    {
+        .tileset = sBattleTerrainTiles_Sand,
+        .tilemap = sBattleTerrainTilemap_Sand,
+        .entryTileset = sBattleTerrainAnimTiles_Sand,
+        .entryTilemap = sBattleTerrainAnimTilemap_Sand,
+        .palette = sBattleTerrainPalette_Sand
+    },
+    [BATTLE_TERRAIN_UNDERWATER] =
+    {
+        .tileset = sBattleTerrainTiles_Underwater,
+        .tilemap = sBattleTerrainTilemap_Underwater,
+        .entryTileset = sBattleTerrainAnimTiles_Underwater,
+        .entryTilemap = sBattleTerrainAnimTilemap_Underwater,
+        .palette = sBattleTerrainPalette_Underwater
+    },
+    [BATTLE_TERRAIN_WATER] =
+    {
+        .tileset = sBattleTerrainTiles_Water,
+        .tilemap = sBattleTerrainTilemap_Water,
+        .entryTileset = sBattleTerrainAnimTiles_Water,
+        .entryTilemap = sBattleTerrainAnimTilemap_Water,
+        .palette = sBattleTerrainPalette_Water
+    },
+    [BATTLE_TERRAIN_POND] =
+    {
+        .tileset = sBattleTerrainTiles_Pond,
+        .tilemap = sBattleTerrainTilemap_Pond,
+        .entryTileset = sBattleTerrainAnimTiles_Pond,
+        .entryTilemap = sBattleTerrainAnimTilemap_Pond,
+        .palette = sBattleTerrainPalette_Pond
+    },
+    [BATTLE_TERRAIN_MOUNTAIN] =
+    {
+        .tileset = sBattleTerrainTiles_Mountain,
+        .tilemap = sBattleTerrainTilemap_Mountain,
+        .entryTileset = sBattleTerrainAnimTiles_Mountain,
+        .entryTilemap = sBattleTerrainAnimTilemap_Mountain,
+        .palette = sBattleTerrainPalette_Mountain
+    },
+    [BATTLE_TERRAIN_CAVE] =
+    {
+        .tileset = sBattleTerrainTiles_Cave,
+        .tilemap = sBattleTerrainTilemap_Cave,
+        .entryTileset = sBattleTerrainAnimTiles_Cave,
+        .entryTilemap = sBattleTerrainAnimTilemap_Cave,
+        .palette = sBattleTerrainPalette_Cave
+    },
+    [BATTLE_TERRAIN_BUILDING] =
+    {
+        .tileset = sBattleTerrainTiles_Building,
+        .tilemap = sBattleTerrainTilemap_Building,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Building
+    },
+    [BATTLE_TERRAIN_PLAIN] =
+    {
+        .tileset = sBattleTerrainTiles_Building,
+        .tilemap = sBattleTerrainTilemap_Building,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Plain
+    },
+    [BATTLE_TERRAIN_LINK] =
+    {
+        .tileset = sBattleTerrainTiles_Building,
+        .tilemap = sBattleTerrainTilemap_Building,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Link
+    },
+    [BATTLE_TERRAIN_GYM] =
+    {
+        .tileset = sBattleTerrainTiles_Building,
+        .tilemap = sBattleTerrainTilemap_Building,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Gym
+    },
+    [BATTLE_TERRAIN_LEADER] =
+    {
+        .tileset = sBattleTerrainTiles_Building,
+        .tilemap = sBattleTerrainTilemap_Building,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Leader
+    },
+    [BATTLE_TERRAIN_INDOOR_2] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Indoor2
+    },
+    [BATTLE_TERRAIN_INDOOR_1] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Indoor1
+    },
+    [BATTLE_TERRAIN_LORELEI] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Lorelei
+    },
+    [BATTLE_TERRAIN_BRUNO] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Bruno
+    },
+    [BATTLE_TERRAIN_AGATHA] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Agatha
+    },
+    [BATTLE_TERRAIN_LANCE] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Lance
+    },
+    [BATTLE_TERRAIN_CHAMPION] =
+    {
+        .tileset = sBattleTerrainTiles_Indoor2,
+        .tilemap = sBattleTerrainTilemap_Indoor2,
+        .entryTileset = sBattleTerrainAnimTiles_Building,
+        .entryTilemap = sBattleTerrainAnimTilemap_Building,
+        .palette = sBattleTerrainPalette_Champion
+    }
+};
+
+static const struct {
+    u8 mapScene;
+    u8 battleTerrain;
+} sMapBattleSceneMapping[] = {
+    {MAP_BATTLE_SCENE_GYM,      BATTLE_TERRAIN_GYM},
+    {MAP_BATTLE_SCENE_INDOOR_1, BATTLE_TERRAIN_INDOOR_1},
+    {MAP_BATTLE_SCENE_INDOOR_2, BATTLE_TERRAIN_INDOOR_2},
+    {MAP_BATTLE_SCENE_LORELEI,  BATTLE_TERRAIN_LORELEI},
+    {MAP_BATTLE_SCENE_BRUNO,    BATTLE_TERRAIN_BRUNO},
+    {MAP_BATTLE_SCENE_AGATHA,   BATTLE_TERRAIN_AGATHA},
+    {MAP_BATTLE_SCENE_LANCE,    BATTLE_TERRAIN_LANCE},
+    {MAP_BATTLE_SCENE_LINK,     BATTLE_TERRAIN_LINK}
+};
+
+UNUSED void CreateUnknownDebugSprite(void)
+{
+    u8 spriteId;
+
+    ResetSpriteData();
+    spriteId = CreateSprite(&gUnknown_824EFF0, 0, 0, 0);
+    gSprites[spriteId].invisible = TRUE;
+    SetMainCallback2(CB2_unused);
+}
+
+static void CB2_unused(void)
+{
+    AnimateSprites();
+    BuildOamBuffer();
+}
+
+static u8 GetBattleTerrainByMapScene(u8 mapBattleScene)
+{
+    int i;
+    for (i = 0; i < NELEMS(sMapBattleSceneMapping); i++)
+    {
+        if (mapBattleScene == sMapBattleSceneMapping[i].mapScene)
+            return sMapBattleSceneMapping[i].battleTerrain;
+    }
+    return 9;
+}
+
+static void LoadBattleTerrainGfx(u16 terrain)
+{
+    if (terrain >= NELEMS(sBattleTerrainTable))
+        terrain = 9;
+    // Copy to bg3
+    LZDecompressVram(sBattleTerrainTable[terrain].tileset, (void *)BG_CHAR_ADDR(2));
+    LZDecompressVram(sBattleTerrainTable[terrain].tilemap, (void *)BG_SCREEN_ADDR(26));
+    LoadCompressedPalette(sBattleTerrainTable[terrain].palette, 0x20, 0x60);
+}
+
+static void LoadBattleTerrainEntryGfx(u16 terrain)
+{
+    if (terrain >= NELEMS(sBattleTerrainTable))
+        terrain = 9;
+    // Copy to bg1
+    LZDecompressVram(sBattleTerrainTable[terrain].entryTileset, (void *)BG_CHAR_ADDR(1));
+    LZDecompressVram(sBattleTerrainTable[terrain].entryTilemap, (void *)BG_SCREEN_ADDR(28));
+}
+
+UNUSED void GetBattleTerrainGfxPtrs(u8 terrain, const u32 **tilesPtr, const u32 **mapPtr, const u32 **palPtr)
+{
+    if (terrain > 9)
+        terrain = 9;
+    *tilesPtr = sBattleTerrainTable[terrain].tileset;
+    *mapPtr = sBattleTerrainTable[terrain].tilemap;
+    *palPtr = sBattleTerrainTable[terrain].palette;
+}
+
+void sub_800F324(void)
+{
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, gBattleBgTemplates, NELEMS(gBattleBgTemplates));
+    InitWindows(gUnknown_8248330);
+    DeactivateAllTextPrinters();
+}
+
+void InitBattleBgsVideo(void)
+{
+    EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
+    sub_800F324();
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_OBJWIN_ON);
+}
+
+void LoadBattleMenuWindowGfx(void)
+{
+    TextWindow_SetUserSelectedFrame(2, 0x012, 0x10);
+    TextWindow_SetUserSelectedFrame(2, 0x022, 0x10);
+    gPlttBufferUnfaded[0x5C] = RGB( 9,  9,  9);
+    gPlttBufferUnfaded[0x5D] = RGB( 9,  9,  9);
+    gPlttBufferUnfaded[0x5E] = RGB(31, 31, 31);
+    gPlttBufferUnfaded[0x5F] = RGB( 26,  26,  25);
+    CpuCopy16(&gPlttBufferUnfaded[0x5C], &gPlttBufferFaded[0x5C], 8);
+    if (gBattleTypeFlags & (BATTLE_TYPE_FIRST_BATTLE | BATTLE_TYPE_POKEDUDE))
+    {
+        Menu_LoadStdPalAt(0x70);
+        TextWindow_LoadResourcesStdFrame0(0, 0x030, 0x70);
+        gPlttBufferUnfaded[0x76] = RGB( 0,  0,  0);
+        CpuCopy16(&gPlttBufferUnfaded[0x76], &gPlttBufferFaded[0x76], 2);
+    }
+}
+
+void DrawMainBattleBackground(void)
+{
+    LoadBattleTerrainGfx(GetBattleTerrainOverride());
+}
+
+void LoadBattleTextboxAndBackground(void)
+{
+    LZDecompressVram(gBattleTextboxTiles, (void *)BG_CHAR_ADDR(0));
+    CopyToBgTilemapBuffer(0, gBattleTextboxTilemap, 0, 0x000);
+    CopyBgTilemapBufferToVram(0);
+    LoadCompressedPalette(gBattleTextboxPalette, 0x00, 0x40);
+    LoadBattleMenuWindowGfx();
+    DrawMainBattleBackground();
+}
+
+static void DrawLinkBattleParticipantPokeballs(u8 taskId, u8 multiplayerId, u8 bgId, u8 destX, u8 destY)
+{
+    s32 i;
+    u16 pokeballStatuses = 0;
+    u16 tiles[6];
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+    {
+        if (gTasks[taskId].data[5] != 0)
+        {
+            switch (multiplayerId)
+            {
+            case 0:
+                pokeballStatuses = 0x3F & gTasks[taskId].data[3];
+                break;
+            case 1:
+                pokeballStatuses = (0xFC0 & gTasks[taskId].data[4]) >> 6;
+                break;
+            case 2:
+                pokeballStatuses = (0xFC0 & gTasks[taskId].data[3]) >> 6;
+                break;
+            case 3:
+                pokeballStatuses = 0x3F & gTasks[taskId].data[4];
+                break;
+            }
+        }
+        else
+        {
+            switch (multiplayerId)
+            {
+            case 0:
+                pokeballStatuses = 0x3F & gTasks[taskId].data[3];
+                break;
+            case 1:
+                pokeballStatuses = 0x3F & gTasks[taskId].data[4];
+                break;
+            case 2:
+                pokeballStatuses = (0xFC0 & gTasks[taskId].data[3]) >> 6;
+                break;
+            case 3:
+                pokeballStatuses = (0xFC0 & gTasks[taskId].data[4]) >> 6;
+                break;
+            }
+        }
+
+        for (i = 0; i < 3; i++)
+            tiles[i] = ((pokeballStatuses & (3 << (i * 2))) >> (i * 2)) + 0x6001;
+
+        CopyToBgTilemapBufferRect_ChangePalette(bgId, tiles, destX, destY, 3, 1, 0x11);
+        CopyBgTilemapBufferToVram(bgId);
+    }
+    else
+    {
+        if (multiplayerId == gBattleStruct->multiplayerId)
+            pokeballStatuses = gTasks[taskId].data[3];
+        else
+            pokeballStatuses = gTasks[taskId].data[4];
+
+        for (i = 0; i < 6; i++)
+            tiles[i] = ((pokeballStatuses & (3 << (i * 2))) >> (i * 2)) + 0x6001;
+
+        CopyToBgTilemapBufferRect_ChangePalette(bgId, tiles, destX, destY, 6, 1, 0x11);
+        CopyBgTilemapBufferToVram(bgId);
+    }
+}
+
+static void DrawLinkBattleVsScreenOutcomeText(void)
+{
+    if (gBattleOutcome == B_OUTCOME_DREW)
+    {
+        BattlePutTextOnWindow(gText_Draw, 0x15);
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+    {
+        if (gBattleOutcome == B_OUTCOME_WON)
+        {
+            switch (gLinkPlayers[gBattleStruct->multiplayerId].id)
+            {
+            case 0:
+                BattlePutTextOnWindow(gText_Win, 0x16);
+                BattlePutTextOnWindow(gText_Loss, 0x17);
+                break;
+            case 1:
+                BattlePutTextOnWindow(gText_Win, 0x17);
+                BattlePutTextOnWindow(gText_Loss, 0x16);
+                break;
+            case 2:
+                BattlePutTextOnWindow(gText_Win, 0x16);
+                BattlePutTextOnWindow(gText_Loss, 0x17);
+                break;
+            case 3:
+                BattlePutTextOnWindow(gText_Win, 0x17);
+                BattlePutTextOnWindow(gText_Loss, 0x16);
+                break;
+            }
+        }
+        else
+        {
+            switch (gLinkPlayers[gBattleStruct->multiplayerId].id)
+            {
+            case 0:
+                BattlePutTextOnWindow(gText_Win, 0x17);
+                BattlePutTextOnWindow(gText_Loss, 0x16);
+                break;
+            case 1:
+                BattlePutTextOnWindow(gText_Win, 0x16);
+                BattlePutTextOnWindow(gText_Loss, 0x17);
+                break;
+            case 2:
+                BattlePutTextOnWindow(gText_Win, 0x17);
+                BattlePutTextOnWindow(gText_Loss, 0x16);
+                break;
+            case 3:
+                BattlePutTextOnWindow(gText_Win, 0x16);
+                BattlePutTextOnWindow(gText_Loss, 0x17);
+                break;
+            }
+        }
+    }
+    else if (gBattleOutcome == B_OUTCOME_WON)
+    {
+        if (gLinkPlayers[gBattleStruct->multiplayerId].id != 0)
+        {
+            BattlePutTextOnWindow(gText_Win, 0x17);
+            BattlePutTextOnWindow(gText_Loss, 0x16);
+        }
+        else
+        {
+            BattlePutTextOnWindow(gText_Win, 0x16);
+            BattlePutTextOnWindow(gText_Loss, 0x17);
+        }
+    }
+    else
+    {
+        if (gLinkPlayers[gBattleStruct->multiplayerId].id != 0)
+        {
+            BattlePutTextOnWindow(gText_Win, 0x16);
+            BattlePutTextOnWindow(gText_Loss, 0x17);
+        }
+        else
+        {
+            BattlePutTextOnWindow(gText_Win, 0x17);
+            BattlePutTextOnWindow(gText_Loss, 0x16);
+        }
+    }
+}
+
+void InitLinkBattleVsScreen(u8 taskId)
+{
+    struct LinkPlayer *linkPlayer;
+    u8 *name;
+    s32 i, palId;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+        {
+            for (i = 0; i < MAX_BATTLERS_COUNT; i++)
+            {
+                name = gLinkPlayers[i].name;
+                linkPlayer = &gLinkPlayers[i];
+
+                switch (linkPlayer->id)
+                {
+                case 0:
+                    BattlePutTextOnWindow(name, 0x11);
+                    DrawLinkBattleParticipantPokeballs(taskId, linkPlayer->id, 1, 2, 4);
+                    break;
+                case 1:
+                    BattlePutTextOnWindow(name, 0x12);
+                    DrawLinkBattleParticipantPokeballs(taskId, linkPlayer->id, 2, 2, 4);
+                    break;
+                case 2:
+                    BattlePutTextOnWindow(name, 0x13);
+                    DrawLinkBattleParticipantPokeballs(taskId, linkPlayer->id, 1, 2, 8);
+                    break;
+                case 3:
+                    BattlePutTextOnWindow(name, 0x14);
+                    DrawLinkBattleParticipantPokeballs(taskId, linkPlayer->id, 2, 2, 8);
+                    break;
+                }
+            }
+        }
+        else
+        {
+            u8 playerId = gBattleStruct->multiplayerId;
+            u8 opponentId = playerId ^ BIT_SIDE;
+            u8 opponentId_copy = opponentId;
+
+            if (gLinkPlayers[playerId].id != 0)
+                opponentId = playerId, playerId = opponentId_copy;
+
+            name = gLinkPlayers[playerId].name;
+            BattlePutTextOnWindow(name, 0xF);
+
+            name = gLinkPlayers[opponentId].name;
+            BattlePutTextOnWindow(name, 0x10);
+
+            DrawLinkBattleParticipantPokeballs(taskId, playerId, 1, 2, 7);
+            DrawLinkBattleParticipantPokeballs(taskId, opponentId, 2, 2, 7);
+        }
+        gTasks[taskId].data[0]++;
+        break;
+    case 1:
+        palId = AllocSpritePalette(TAG_VS_LETTERS);
+        gPlttBufferUnfaded[palId * 16 + 0x10F] = gPlttBufferFaded[palId * 16 + 0x10F] = RGB(31, 31, 31);
+        gBattleStruct->linkBattleVsSpriteId_V = CreateSprite(&sVsLetter_V_SpriteTemplate, 108, 80, 0);
+        gBattleStruct->linkBattleVsSpriteId_S = CreateSprite(&sVsLetter_S_SpriteTemplate, 132, 80, 0);
+        gSprites[gBattleStruct->linkBattleVsSpriteId_V].invisible = TRUE;
+        gSprites[gBattleStruct->linkBattleVsSpriteId_S].invisible = TRUE;
+        gTasks[taskId].data[0]++;
+        break;
+    case 2:
+        if (gTasks[taskId].data[5] != 0)
+        {
+            gBattle_BG1_X = -(20) - (Sin2(gTasks[taskId].data[1]) / 32);
+            gBattle_BG2_X = -(140) - (Sin2(gTasks[taskId].data[2]) / 32);
+            gBattle_BG1_Y = -36;
+            gBattle_BG2_Y = -36;
+        }
+        else
+        {
+            gBattle_BG1_X = -(20) - (Sin2(gTasks[taskId].data[1]) / 32);
+            gBattle_BG1_Y = (Cos2(gTasks[taskId].data[1]) / 32) - 164;
+            gBattle_BG2_X = -(140) - (Sin2(gTasks[taskId].data[2]) / 32);
+            gBattle_BG2_Y = (Cos2(gTasks[taskId].data[2]) / 32) - 164;
+        }
+
+        if (gTasks[taskId].data[2] != 0)
+        {
+            gTasks[taskId].data[2] -= 2;
+            gTasks[taskId].data[1] += 2;
+        }
+        else
+        {
+            if (gTasks[taskId].data[5] != 0)
+                DrawLinkBattleVsScreenOutcomeText();
+
+            PlaySE(SE_W231);
+            DestroyTask(taskId);
+            gSprites[gBattleStruct->linkBattleVsSpriteId_V].invisible = FALSE;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_S].invisible = FALSE;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_S].oam.tileNum += 0x40;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_V].data[0] = 0;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_S].data[0] = 1;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_V].data[1] = gSprites[gBattleStruct->linkBattleVsSpriteId_V].pos1.x;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_S].data[1] = gSprites[gBattleStruct->linkBattleVsSpriteId_S].pos1.x;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_V].data[2] = 0;
+            gSprites[gBattleStruct->linkBattleVsSpriteId_S].data[2] = 0;
+        }
+        break;
+    }
+}
+
+void DrawBattleEntryBackground(void)
+{
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        LZDecompressVram(gFile_graphics_battle_transitions_vs_frame_sheet, (void*)(BG_CHAR_ADDR(1)));
+        LZDecompressVram(gVsLettersGfx, (void*)(VRAM + 0x10000));
+        LoadCompressedPalette(gFile_graphics_battle_transitions_vs_frame_palette, 0x60, 0x20);
+        SetBgAttribute(1, BG_ATTR_SCREENSIZE, 1);
+        SetGpuReg(REG_OFFSET_BG1CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(1) | BGCNT_16COLOR | BGCNT_SCREENBASE(28) | BGCNT_TXT512x256);
+        CopyToBgTilemapBuffer(1, gFile_graphics_battle_transitions_vs_frame_tilemap, 0, 0);
+        CopyToBgTilemapBuffer(2, gFile_graphics_battle_transitions_vs_frame_tilemap, 0, 0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG1 | WININ_WIN0_BG2 | WININ_WIN0_OBJ | WININ_WIN0_CLR);
+        SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR);
+        gBattle_BG1_Y = -164;
+        gBattle_BG2_Y = -164;
+        LoadCompressedSpriteSheetUsingHeap(&sVsLettersSpriteSheet);
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+    {
+        LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_GRASS);
+    }
+    else if (gBattleTypeFlags & (BATTLE_TYPE_TRAINER_TOWER | BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))
+    {
+        LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_BUILDING);
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON)
+    {
+        if (gGameVersion == VERSION_FIRE_RED)
+        {
+            LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_CAVE);
+        }
+        else
+        {
+            LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_WATER);
+        }
+    }
+    else
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+        {
+            u8 trainerClass = gTrainers[gTrainerBattleOpponent_A].trainerClass;
+            if (trainerClass == CLASS_LEADER_2)
+            {
+                LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_BUILDING);
+                return;
+            }
+            else if (trainerClass == CLASS_CHAMPION_2)
+            {
+                LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_BUILDING);
+                return;
+            }
+        }
+
+        if (GetCurrentMapBattleScene() == MAP_BATTLE_SCENE_NORMAL)
+        {
+            LoadBattleTerrainEntryGfx(gBattleTerrain);
+        }
+        else
+        {
+            LoadBattleTerrainEntryGfx(BATTLE_TERRAIN_BUILDING);
+        }
+    }
+}
+
+static u8 GetBattleTerrainOverride(void)
+{
+    u8 battleScene;
+    if (gBattleTypeFlags & (BATTLE_TYPE_TRAINER_TOWER | BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))
+    {
+        return BATTLE_TERRAIN_LINK;
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+    {
+        gBattleTerrain = BATTLE_TERRAIN_GRASS;
+        return BATTLE_TERRAIN_GRASS;
+    }
+    else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+    {
+        if (gTrainers[gTrainerBattleOpponent_A].trainerClass == CLASS_LEADER_2)
+        {
+            return BATTLE_TERRAIN_LEADER;
+        }
+        else if (gTrainers[gTrainerBattleOpponent_A].trainerClass == CLASS_CHAMPION_2)
+        {
+            return BATTLE_TERRAIN_CHAMPION;
+        }
+    }
+    battleScene = GetCurrentMapBattleScene();
+    if (battleScene == MAP_BATTLE_SCENE_NORMAL)
+    {
+        return gBattleTerrain;
+    }
+    return GetBattleTerrainByMapScene(battleScene);
+}
+
+bool8 LoadChosenBattleElement(u8 caseId)
+{
+    bool8 ret = FALSE;
+    u8 battleScene;
+    switch (caseId)
+    {
+    case 0:
+        LZDecompressVram(gBattleTextboxTiles, (void *)BG_CHAR_ADDR(0));
+        break;
+    case 1:
+        CopyToBgTilemapBuffer(0, gBattleTextboxTilemap, 0, 0x000);
+        CopyBgTilemapBufferToVram(0);
+        break;
+    case 2:
+        LoadCompressedPalette(gBattleTextboxPalette, 0x00, 0x40);
+        break;
+    case 3:
+        battleScene = GetBattleTerrainOverride();
+        LZDecompressVram(sBattleTerrainTable[battleScene].tileset, (void *)BG_CHAR_ADDR(2));
+        // fallthrough
+    case 4:
+        battleScene = GetBattleTerrainOverride();
+        LZDecompressVram(sBattleTerrainTable[battleScene].tilemap, (void *)BG_SCREEN_ADDR(26));
+        break;
+    case 5:
+        battleScene = GetBattleTerrainOverride();
+        LoadCompressedPalette(sBattleTerrainTable[battleScene].palette, 0x20, 0x60);
+        break;
+    case 6:
+        LoadBattleMenuWindowGfx();
+        break;
+    default:
+        ret = TRUE;
+        break;
+    }
+    return ret;
+}
diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c
index 7df93e170..a80e79bf4 100644
--- a/src/battle_controller_link_opponent.c
+++ b/src/battle_controller_link_opponent.c
@@ -1,27 +1,20 @@
 #include "global.h"
-#include "bg.h"
 #include "data.h"
 #include "link.h"
-#include "main.h"
 #include "m4a.h"
 #include "palette.h"
 #include "pokeball.h"
 #include "pokemon.h"
-#include "reshow_battle_screen.h"
 #include "sound.h"
 #include "string_util.h"
 #include "task.h"
 #include "text.h"
 #include "util.h"
-#include "window.h"
 #include "battle.h"
-#include "battle_ai_script_commands.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
-#include "battle_setup.h"
-#include "battle_tower.h"
 #include "constants/battle_anim.h"
 #include "constants/songs.h"
 #include "constants/facility_trainer_classes.h"
@@ -1134,11 +1127,11 @@ static void LinkOpponentHandleDrawTrainerPic(void)
         }
         else if (gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender != MALE)
         {
-            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_PLAYER_4];
+            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_LEAF];
         }
         else
         {
-            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_PLAYER_3];
+            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_RED];
         }
     }
     else
@@ -1159,11 +1152,11 @@ static void LinkOpponentHandleDrawTrainerPic(void)
         }
         else if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != MALE)
         {
-            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_PLAYER_4];
+            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_LEAF];
         }
         else
         {
-            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_PLAYER_3];
+            trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_RED];
         }
     }
     DecompressTrainerFrontPic(trainerPicId, gActiveBattler);
diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c
index 96130f049..5ac4f1abc 100644
--- a/src/battle_controller_link_partner.c
+++ b/src/battle_controller_link_partner.c
@@ -1,9 +1,6 @@
 #include "global.h"
-#include "bg.h"
 #include "data.h"
 #include "link.h"
-#include "main.h"
-#include "m4a.h"
 #include "palette.h"
 #include "pokeball.h"
 #include "pokemon.h"
@@ -12,16 +9,11 @@
 #include "task.h"
 #include "text.h"
 #include "util.h"
-#include "window.h"
 #include "battle.h"
-#include "battle_ai_script_commands.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
-#include "battle_setup.h"
-#include "battle_tower.h"
-#include "reshow_battle_screen.h"
 #include "constants/battle_anim.h"
 #include "constants/songs.h"
 
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
index 3cb6d1432..26e35ae65 100644
--- a/src/battle_controller_opponent.c
+++ b/src/battle_controller_opponent.c
@@ -1,15 +1,10 @@
 #include "global.h"
-#include "bg.h"
 #include "data.h"
-#include "item.h"
-#include "link.h"
 #include "main.h"
 #include "m4a.h"
 #include "task.h"
 #include "text.h"
 #include "util.h"
-#include "window.h"
-#include "palette.h"
 #include "pokeball.h"
 #include "pokemon.h"
 #include "random.h"
@@ -20,15 +15,12 @@
 #include "battle_controllers.h"
 #include "battle_message.h"
 #include "battle_interface.h"
-#include "battle_setup.h"
 #include "battle_tower.h"
 #include "battle_gfx_sfx_util.h"
 #include "battle_ai_script_commands.h"
 #include "battle_ai_switch_items.h"
 #include "trainer_tower.h"
-#include "reshow_battle_screen.h"
 #include "constants/battle_anim.h"
-#include "constants/items.h"
 #include "constants/moves.h"
 #include "constants/songs.h"
 
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
index cb9e04a50..a751c0eea 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -10,7 +10,6 @@
 #include "party_menu.h"
 #include "pokeball.h"
 #include "pokemon.h"
-#include "random.h"
 #include "sound.h"
 #include "strings.h"
 #include "string_util.h"
@@ -24,7 +23,6 @@
 #include "battle_controllers.h"
 #include "battle_interface.h"
 #include "battle_message.h"
-#include "battle_setup.h"
 #include "battle_script_commands.h"
 #include "reshow_battle_screen.h"
 #include "constants/battle_anim.h"
@@ -831,9 +829,9 @@ void sub_802F6A8(void)
         if (gBattleTypeFlags & BATTLE_TYPE_LINK)
         {
             if (gWirelessCommType == 0)
-                sub_800AAC0();
+                Link_TryStartSend5FFF();
             else
-                sub_800AB9C();
+                PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             gBattlerControllerFuncs[gActiveBattler] = sub_802F610;
         }
         else
diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c
index d8ebe5ba4..a6b3fe994 100644
--- a/src/battle_controller_pokedude.c
+++ b/src/battle_controller_pokedude.c
@@ -11,7 +11,6 @@
 #include "link.h"
 #include "sound.h"
 #include "event_data.h"
-#include "item.h"
 #include "item_menu.h"
 #include "text.h"
 #include "strings.h"
@@ -25,7 +24,6 @@
 #include "reshow_battle_screen.h"
 #include "teachy_tv.h"
 #include "constants/songs.h"
-#include "constants/items.h"
 #include "constants/moves.h"
 #include "constants/pokemon.h"
 #include "constants/trainers.h"
@@ -127,7 +125,7 @@ static void SetPokedudeMonData(u8 monId);
 static void sub_8159478(u8 battlerId);
 static void PokedudeDoMoveAnimation(void);
 static void sub_81595EC(u8 taskId);
-static const u8 *sub_8159EF0(void);
+static const u8 *GetPokedudeText(void);
 
 u8 *gUnknown_3005EE0[MAX_BATTLERS_COUNT];
 
@@ -224,10 +222,10 @@ static const u8 gUnknown_8479048[][8] =
 
 static const u8 (*const gUnknown_8479060[])[8] =
 {
-    gUnknown_8479008,
-    gUnknown_8479018,
-    gUnknown_8479030,
-    gUnknown_8479048,
+    [TTVSCR_BATTLE]   = gUnknown_8479008,
+    [TTVSCR_STATUS]   = gUnknown_8479018,
+    [TTVSCR_MATCHUPS] = gUnknown_8479030,
+    [TTVSCR_CATCHING] = gUnknown_8479048,
 };
 
 static const u8 gUnknown_8479070[][8] =
@@ -261,10 +259,10 @@ static const u8 gUnknown_84790C0[][8] =
 
 static const u8 (*const gUnknown_84790D8[])[8] =
 {
-    gUnknown_8479070,
-    gUnknown_8479080,
-    gUnknown_84790A0,
-    gUnknown_84790C0,
+    [TTVSCR_BATTLE]   = gUnknown_8479070,
+    [TTVSCR_STATUS]   = gUnknown_8479080,
+    [TTVSCR_MATCHUPS] = gUnknown_84790A0,
+    [TTVSCR_CATCHING] = gUnknown_84790C0,
 };
 
 static const struct Unk_84790E8 gUnknown_84790E8[] =
@@ -417,48 +415,48 @@ static const struct Unk_84790E8 gUnknown_8479168[] =
 
 static const struct Unk_84790E8 *const gUnknown_8479198[] =
 {
-    gUnknown_84790E8,
-    gUnknown_8479108,
-    gUnknown_8479130,
-    gUnknown_8479168,
+    [TTVSCR_BATTLE]   = gUnknown_84790E8,
+    [TTVSCR_STATUS]   = gUnknown_8479108,
+    [TTVSCR_MATCHUPS] = gUnknown_8479130,
+    [TTVSCR_CATCHING] = gUnknown_8479168,
 };
 
-static const u8 *const gUnknown_84791A8[] =
+static const u8 *const sPokedudeTexts_Battle[] =
 {
-    gUnknown_81C5F69,
-    gUnknown_81C5FA7,
-    gUnknown_81C5FDC,
-    gUnknown_81C601C,
+    Pokedude_Text_SpeedierBattlerGoesFirst,
+    Pokedude_Text_MyRattataFasterThanPidgey,
+    Pokedude_Text_BattlersTakeTurnsAttacking,
+    Pokedude_Text_MyRattataWonGetsEXP,
 };
 
-static const u8 *const gUnknown_84791B8[] =
+static const u8 *const sPokedudeTexts_Status[] =
 {
-    gUnknown_81C60FA,
-    gUnknown_81C60FA,
-    gUnknown_81C615A,
-    gUnknown_81C6196,
-    gUnknown_81C61EA,
+    Pokedude_Text_UhOhRattataPoisoned,
+    Pokedude_Text_UhOhRattataPoisoned,
+    Pokedude_Text_HealStatusRightAway,
+    Pokedude_Text_UsingItemTakesTurn,
+    Pokedude_Text_YayWeManagedToWin,
 };
 
-static const u8 *const gUnknown_84791CC[] =
+static const u8 *const sPokedudeTexts_TypeMatchup[] =
 {
-    gUnknown_81C6202,
-    gUnknown_81C6301,
-    gUnknown_81C63A9,
-    gUnknown_81C63F9,
-    gUnknown_81C6446,
-    gUnknown_81C657A,
-    gUnknown_81C6637,
+    Pokedude_Text_WaterNotVeryEffectiveAgainstGrass,
+    Pokedude_Text_GrassEffectiveAgainstWater,
+    Pokedude_Text_LetsTryShiftingMons,
+    Pokedude_Text_ShiftingUsesTurn,
+    Pokedude_Text_ButterfreeDoubleResistsGrass,
+    Pokedude_Text_ButterfreeGoodAgainstOddish,
+    Pokedude_Text_YeahWeWon,
 };
 
-static const u8 *const gUnknown_84791E8[] =
+static const u8 *const sPokedudeTexts_Catching[] =
 {
-    gUnknown_81C6645,
-    gUnknown_81C6645,
-    gUnknown_81C66CF,
-    gUnknown_81C6787,
-    gUnknown_81C684B,
-    gUnknown_81C686C,
+    Pokedude_Text_WeakenMonBeforeCatching,
+    Pokedude_Text_WeakenMonBeforeCatching,
+    Pokedude_Text_BestIfTargetStatused,
+    Pokedude_Text_CantDoubleUpOnStatus,
+    Pokedude_Text_LetMeThrowBall,
+    Pokedude_Text_PickBestKindOfBall,
 };
 
 static const struct PokedudeBattlePartyInfo sParties_Battle[] =
@@ -556,10 +554,10 @@ static const struct PokedudeBattlePartyInfo sParties_Catching[] =
 
 static const struct PokedudeBattlePartyInfo *const sPokedudeBattlePartyPointers[] =
 {
-    sParties_Battle,
-    sParties_Status,
-    sParties_Matchups,
-    sParties_Catching,
+    [TTVSCR_BATTLE]   = sParties_Battle,
+    [TTVSCR_STATUS]   = sParties_Status,
+    [TTVSCR_MATCHUPS] = sParties_Matchups,
+    [TTVSCR_CATCHING] = sParties_Catching,
 };
 
 static void nullsub_99(void)
@@ -2597,7 +2595,7 @@ static void sub_8159BA8(void)
         break;
     case 2:
         gBattle_BG0_Y = 0;
-        BattleStringExpandPlaceholdersToDisplayedString(sub_8159EF0());
+        BattleStringExpandPlaceholdersToDisplayedString(GetPokedudeText());
         BattlePutTextOnWindow(gDisplayedStringBattle, 24);
         ++gUnknown_3005EE0[gActiveBattler][2];
         break;
@@ -2658,7 +2656,7 @@ static void sub_8159D04(void)
         }
         break;
     case 3:
-        BattleStringExpandPlaceholdersToDisplayedString(sub_8159EF0());
+        BattleStringExpandPlaceholdersToDisplayedString(GetPokedudeText());
         BattlePutTextOnWindow(gDisplayedStringBattle, 24);
         ++gUnknown_3005EE0[gActiveBattler][2];
         break;
@@ -2698,19 +2696,19 @@ static void sub_8159D04(void)
     }
 }
 
-static const u8 *sub_8159EF0(void)
+static const u8 *GetPokedudeText(void)
 {
     switch (gBattleStruct->field_96)
     {
-    case 0:
+    case TTVSCR_BATTLE:
     default:
-        return gUnknown_84791A8[gBattleStruct->field_97 - 1];
-    case 1:
-        return gUnknown_84791B8[gBattleStruct->field_97 - 1];
-    case 2:
-        return gUnknown_84791CC[gBattleStruct->field_97 - 1];
-    case 3:
-        return gUnknown_84791E8[gBattleStruct->field_97 - 1];
+        return sPokedudeTexts_Battle[gBattleStruct->field_97 - 1];
+    case TTVSCR_STATUS:
+        return sPokedudeTexts_Status[gBattleStruct->field_97 - 1];
+    case TTVSCR_MATCHUPS:
+        return sPokedudeTexts_TypeMatchup[gBattleStruct->field_97 - 1];
+    case TTVSCR_CATCHING:
+        return sPokedudeTexts_Catching[gBattleStruct->field_97 - 1];
     }
 }
 
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 4b5153c7c..28ed4091e 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -9,16 +9,12 @@
 #include "item_menu.h"
 #include "link.h"
 #include "main.h"
-#include "m4a.h"
 #include "palette.h"
 #include "pokeball.h"
 #include "pokemon.h"
-#include "reshow_battle_screen.h"
 #include "sound.h"
-#include "task.h"
 #include "text.h"
 #include "util.h"
-#include "window.h"
 #include "strings.h"
 #include "constants/songs.h"
 #include "constants/battle_anim.h"
diff --git a/src/battle_controllers.c b/src/battle_controllers.c
index ca2ef0b22..834b9e6b6 100644
--- a/src/battle_controllers.c
+++ b/src/battle_controllers.c
@@ -35,7 +35,7 @@ void HandleLinkBattleSetup(void)
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
     {
         if (gWirelessCommType)
-            sub_800B1F4();
+            SetWirelessCommType1();
         if (!gReceivedRemoteLinkPlayers)
             OpenLink();
         CreateTask(sub_8081A90, 0);
@@ -491,7 +491,7 @@ void sub_800DD28(void)
 
     if (gReceivedRemoteLinkPlayers && (gBattleTypeFlags & BATTLE_TYPE_20) && (gLinkPlayers[0].linkType == 0x2211))
     {
-        sub_80FBB4C();
+        LinkRfu_DestroyIdleTask();
         for (i = 0; i < GetLinkPlayerCount(); ++i)
         {
             if (GetBlockReceivedStatus() & gBitTable[i])
diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c
index 60cff27be..127b0903b 100644
--- a/src/battle_gfx_sfx_util.c
+++ b/src/battle_gfx_sfx_util.c
@@ -13,8 +13,6 @@
 #include "party_menu.h"
 #include "battle.h"
 #include "battle_main.h"
-#include "battle_controllers.h"
-#include "battle_ai_script_commands.h"
 #include "battle_anim.h"
 #include "battle_interface.h"
 #include "constants/battle_anim.h"
@@ -546,7 +544,7 @@ bool8 BattleLoadAllHealthBoxesGfx(u8 state)
 
 void LoadBattleBarGfx(u8 arg0)
 {
-    LZDecompressWram(gFile_graphics_interface_hp_numbers, gMonSpritesGfxPtr->barFontGfx);
+    LZDecompressWram(gInterfaceGfx_HPNumbers, gMonSpritesGfxPtr->barFontGfx);
 }
 
 bool8 BattleInitAllSprites(u8 *state, u8 *battlerId)
diff --git a/src/battle_interface.c b/src/battle_interface.c
index 56e9e0fad..e5145adc0 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -12,7 +12,6 @@
 #include "safari_zone.h"
 #include "sound.h"
 #include "string_util.h"
-#include "strings.h"
 #include "text.h"
 #include "window.h"
 #include "constants/songs.h"
diff --git a/src/battle_main.c b/src/battle_main.c
index 76f373f8f..bbfcf5cf9 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -8,13 +8,11 @@
 #include "battle_message.h"
 #include "battle_scripts.h"
 #include "battle_setup.h"
-#include "battle_tower.h"
 #include "battle_string_ids.h"
 #include "berry.h"
 #include "bg.h"
 #include "data.h"
 #include "decompress.h"
-#include "dma3.h"
 #include "event_data.h"
 #include "evolution_scene.h"
 #include "graphics.h"
@@ -40,14 +38,12 @@
 #include "sound.h"
 #include "sprite.h"
 #include "string_util.h"
-#include "strings.h"
 #include "task.h"
 #include "text.h"
 #include "trig.h"
 #include "vs_seeker.h"
 #include "util.h"
 #include "window.h"
-#include "cable_club.h"
 #include "constants/abilities.h"
 #include "constants/battle_move_effects.h"
 #include "constants/battle_setup.h"
@@ -645,17 +641,17 @@ void CB2_InitBattle(void)
             if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
             {
                 if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
-                    HelpSystem_SetSomeVariable2(0x19);
+                    SetHelpContext(HELPCONTEXT_TRAINER_BATTLE_DOUBLE);
                 else
-                    HelpSystem_SetSomeVariable2(0x18);
+                    SetHelpContext(HELPCONTEXT_TRAINER_BATTLE_SINGLE);
             }
             else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
             {
-                HelpSystem_SetSomeVariable2(0x1A);
+                SetHelpContext(HELPCONTEXT_SAFARI_BATTLE);
             }
             else
             {
-                HelpSystem_SetSomeVariable2(0x17);
+                SetHelpContext(HELPCONTEXT_WILD_BATTLE);
             }
         }
     }
@@ -979,7 +975,7 @@ static void CB2_HandleStartBattle(void)
             ResetBlockReceivedFlags();
             sub_8010414(2, playerMultiplayerId);
             SetAllPlayersBerryData();
-            taskId = CreateTask(sub_800F6FC, 0);
+            taskId = CreateTask(InitLinkBattleVsScreen, 0);
             gTasks[taskId].data[1] = 270;
             gTasks[taskId].data[2] = 90;
             gTasks[taskId].data[5] = 0;
@@ -1152,9 +1148,9 @@ static void CB2_PreInitMultiBattle(void)
         {
             ++gBattleCommunication[MULTIUSE_STATE];
             if (gWirelessCommType)
-                sub_800AB9C();
+                PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             else
-                sub_800AAC0();
+                Link_TryStartSend5FFF();
         }
         break;
     case 3:
@@ -1227,7 +1223,7 @@ static void CB2_HandleStartMultiBattle(void)
             SetAllPlayersBerryData();
             SetDeoxysStats();
             memcpy(gDecompressionBuffer, gPlayerParty, sizeof(struct Pokemon) * 3);
-            taskId = CreateTask(sub_800F6FC, 0);
+            taskId = CreateTask(InitLinkBattleVsScreen, 0);
             gTasks[taskId].data[1] = 270;
             gTasks[taskId].data[2] = 90;
             gTasks[taskId].data[5] = 0;
@@ -1785,7 +1781,7 @@ void sub_8011A1C(void)
     FreeAllSpritePalettes();
     gReservedSpritePaletteCount = 4;
     SetVBlankCallback(VBlankCB_Battle);
-    taskId = CreateTask(sub_800F6FC, 0);
+    taskId = CreateTask(InitLinkBattleVsScreen, 0);
     gTasks[taskId].data[1] = 270;
     gTasks[taskId].data[2] = 90;
     gTasks[taskId].data[5] = 1;
@@ -3717,7 +3713,7 @@ static void HandleEndTurn_BattleLost(void)
     }
     else
     {
-        if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && ScrSpecial_GetTrainerBattleMode() == TRAINER_BATTLE_EARLY_RIVAL)
+        if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && GetTrainerBattleMode() == TRAINER_BATTLE_EARLY_RIVAL)
         {
             if (GetRivalBattleFlags() & RIVAL_BATTLE_HEAL_AFTER)
                 gBattleCommunication[MULTISTRING_CHOOSER] = 1; // Dont do white out text
@@ -4164,7 +4160,6 @@ bool8 TryRunFromBattle(u8 battler)
 {
     bool8 effect = FALSE;
     u8 holdEffect;
-    u8 pyramidMultiplier;
     u8 speedVar;
 
     if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY)
diff --git a/src/battle_message.c b/src/battle_message.c
index 4f95ae364..7ca47e6fb 100644
--- a/src/battle_message.c
+++ b/src/battle_message.c
@@ -1271,9 +1271,9 @@ const u8 gUnknown_83FE860[] = _(" is");
 const u8 gUnknown_83FE864[] = _(" is");
 const u8 gText_BadEgg[] = _("Bad EGG");
 const u8 gUnknown_83FE870[] = _("ミツル");
-const u8 gUnknown_83FE874[] = _("{HIGHLIGHT 0}Win");
-const u8 gUnknown_83FE87B[] = _("{HIGHLIGHT 0}Loss");
-const u8 gUnknown_83FE883[] = _("{HIGHLIGHT 0}Draw");
+const u8 gText_Win[] = _("{HIGHLIGHT 0}Win");
+const u8 gText_Loss[] = _("{HIGHLIGHT 0}Loss");
+const u8 gText_Draw[] = _("{HIGHLIGHT 0}Draw");
 static const u8 sText_SpaceIs[] = _(" is");
 static const u8 sText_ApostropheS[] = _("'s");
 const u8 gUnknown_83FE892[] = _("a NORMAL move");
@@ -1294,9 +1294,9 @@ const u8 gUnknown_83FE94D[] = _("a PSYCHIC move");
 const u8 gUnknown_83FE95C[] = _("an ICE move");
 const u8 gUnknown_83FE968[] = _("a DRAGON move");
 const u8 gUnknown_83FE976[] = _("a DARK move");
-const u8 gUnknown_83FE982[] = _("TIME BOARD");
-const u8 gUnknown_83FE98D[] = _("CLEAR TIME");
-const u8 gUnknown_83FE998[] = _("{STR_VAR_1}MIN. {STR_VAR_2}.{STR_VAR_3}SEC.");
+const u8 gText_TimeBoard[] = _("TIME BOARD");
+const u8 gText_ClearTime[] = _("CLEAR TIME"); // Unused
+const u8 gText_XMinYZSec[] = _("{STR_VAR_1}MIN. {STR_VAR_2}.{STR_VAR_3}SEC.");
 const u8 gUnknown_83FE9A9[] = _("1F");
 const u8 gUnknown_83FE9AC[] = _("2F");
 const u8 gUnknown_83FE9AF[] = _("3F");
@@ -1306,7 +1306,7 @@ const u8 gUnknown_83FE9B8[] = _("6F");
 const u8 gUnknown_83FE9BB[] = _("7F");
 const u8 gUnknown_83FE9BE[] = _("8F");
 
-const u8 *const gUnknown_83FE9C4[] = {
+const u8 *const gTrainerTowerChallengeTypeTexts[NUM_TOWER_CHALLENGE_TYPES] = {
     gOtherText_Single,
     gOtherText_Double,
     gOtherText_Knockout,
@@ -1990,7 +1990,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
                 else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
                     toCpy = gTrainerClassNames[GetBattleTowerTrainerClassNameId()];
                 else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER)
-                    toCpy = gTrainerClassNames[sub_815DA10()];
+                    toCpy = gTrainerClassNames[GetTrainerTowerOpponentClass()];
                 else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER)
                     toCpy = gTrainerClassNames[GetEreaderTrainerClassId()];
                 else
@@ -2014,7 +2014,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
                 }
                 else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER)
                 {
-                    sub_815DA28(text);
+                    GetTrainerTowerOpponentName(text);
                     toCpy = text;
                 }
                 else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER)
@@ -2054,7 +2054,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
             case B_TXT_TRAINER1_LOSE_TEXT: // trainerA lose text
                 if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER)
                 {
-                    sub_815DC40(gStringVar4, 0);
+                    GetTrainerTowerOpponentLoseText(gStringVar4, 0);
                     toCpy = gStringVar4;
                 }
                 else
@@ -2065,7 +2065,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
             case B_TXT_TRAINER1_WIN_TEXT: // trainerA win text
                 if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER)
                 {
-                    sub_815DBF4(gStringVar4, 0);
+                    GetTrainerTowerOpponentWinText(gStringVar4, 0);
                     toCpy = gStringVar4;
                 }
                 else
@@ -2074,11 +2074,11 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
                 }
                 break;
             case B_TXT_TRAINER2_LOSE_TEXT:
-                sub_815DC40(gStringVar4, 1);
+                GetTrainerTowerOpponentLoseText(gStringVar4, 1);
                 toCpy = gStringVar4;
                 break;
             case B_TXT_TRAINER2_WIN_TEXT:
-                sub_815DBF4(gStringVar4, 1);
+                GetTrainerTowerOpponentWinText(gStringVar4, 1);
                 toCpy = gStringVar4;
                 break;
             case B_TXT_26: // ?
diff --git a/src/battle_records.c b/src/battle_records.c
index 07ff665d9..3196d9bad 100644
--- a/src/battle_records.c
+++ b/src/battle_records.c
@@ -88,7 +88,7 @@ static u8 *const sStringVars[3] = {
     gStringVar3
 };
 
-void Special_BattleRecords(void)
+void ShowBattleRecords(void)
 {
     SetVBlankCallback(NULL);
     SetMainCallback2(MainCB2_SetUp);
@@ -419,7 +419,7 @@ void ClearPlayerLinkBattleRecords(void)
 
 static void IncTrainerCardWinCount(s32 battlerId)
 {
-    u16 *wins = &gTrainerCards[battlerId].linkBattleWins;
+    u16 *wins = &gTrainerCards[battlerId].rse.linkBattleWins;
     (*wins)++;
     if (*wins > 9999)
         *wins = 9999;
@@ -427,7 +427,7 @@ static void IncTrainerCardWinCount(s32 battlerId)
 
 static void IncTrainerCardLossCount(s32 battlerId)
 {
-    u16 *losses = &gTrainerCards[battlerId].linkBattleLosses;
+    u16 *losses = &gTrainerCards[battlerId].rse.linkBattleLosses;
     (*losses)++;
     if (*losses > 9999)
         *losses = 9999;
@@ -453,7 +453,7 @@ void TryRecordLinkBattleOutcome(s32 battlerId)
     if (gSaveBlock1Ptr->location.mapGroup != MAP_GROUP(UNION_ROOM) || gSaveBlock1Ptr->location.mapNum != MAP_NUM(UNION_ROOM))
     {
         UpdateBattleOutcomeOnTrainerCards(battlerId);
-        AddOpponentLinkBattleRecord(&gSaveBlock2Ptr->linkBattleRecords, gTrainerCards[battlerId].playerName, gTrainerCards[battlerId].trainerId, gBattleOutcome, gLinkPlayers[battlerId].language);
+        AddOpponentLinkBattleRecord(&gSaveBlock2Ptr->linkBattleRecords, gTrainerCards[battlerId].rse.playerName, gTrainerCards[battlerId].rse.trainerId, gBattleOutcome, gLinkPlayers[battlerId].language);
     }
 }
 
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index 527e32bcc..de505827f 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -3,7 +3,6 @@
 #include "util.h"
 #include "pokemon.h"
 #include "random.h"
-#include "data.h"
 #include "text.h"
 #include "sound.h"
 #include "pokedex.h"
@@ -14,7 +13,6 @@
 #include "bg.h"
 #include "string_util.h"
 #include "pokemon_icon.h"
-#include "m4a.h"
 #include "mail.h"
 #include "event_data.h"
 #include "strings.h"
@@ -30,7 +28,6 @@
 #include "battle.h"
 #include "battle_message.h"
 #include "battle_anim.h"
-#include "battle_setup.h"
 #include "battle_ai_script_commands.h"
 #include "battle_scripts.h"
 #include "battle_string_ids.h"
@@ -48,7 +45,7 @@
 #include "constants/abilities.h"
 #include "constants/pokemon.h"
 #include "constants/trainers.h"
-#include "constants/map_types.h"
+#include "constants/maps.h"
 
 #define DEFENDER_IS_PROTECTED ((gProtectStructs[gBattlerTarget].protected) && (gBattleMoves[gCurrentMove].flags & FLAG_PROTECT_AFFECTED))
 
diff --git a/src/battle_setup.c b/src/battle_setup.c
index ae6aaf8be..82a73990b 100644
--- a/src/battle_setup.c
+++ b/src/battle_setup.c
@@ -13,7 +13,7 @@
 #include "strings.h"
 #include "string_util.h"
 #include "event_data.h"
-#include "event_object_80688E4.h"
+#include "event_object_movement.h"
 #include "metatile_behavior.h"
 #include "event_scripts.h"
 #include "fldeff.h"
@@ -22,10 +22,8 @@
 #include "field_player_avatar.h"
 #include "field_screen_effect.h"
 #include "field_message_box.h"
-#include "event_object_movement.h"
 #include "vs_seeker.h"
 #include "battle.h"
-#include "battle_setup.h"
 #include "battle_transition.h"
 #include "battle_controllers.h"
 #include "constants/battle_setup.h"
@@ -37,7 +35,6 @@
 #include "constants/pokemon.h"
 #include "constants/trainers.h"
 #include "constants/trainer_classes.h"
-#include "constants/map_types.h"
 
 enum
 {
@@ -224,7 +221,7 @@ static bool8 CheckSilphScopeInPokemonTower(u16 mapGroup, u16 mapNum)
         return FALSE;
 }
 
-void BattleSetup_StartWildBattle(void)
+void StartWildBattle(void)
 {
     if (GetSafariZoneFlag())
         DoSafariBattle();
@@ -246,7 +243,7 @@ static void DoStandardWildBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void BattleSetup_StartRoamerBattle(void)
+void StartRoamerBattle(void)
 {
     ScriptContext2_Enable();
     FreezeObjectEvents();
@@ -288,7 +285,7 @@ static void DoTrainerBattle(void)
     IncrementGameStat(GAME_STAT_TRAINER_BATTLES);
 }
 
-void ScrSpecial_StartOldManTutorialBattle(void)
+void StartOldManTutorialBattle(void)
 {
     CreateMaleMon(&gEnemyParty[0], SPECIES_WEEDLE, 5);
     ScriptContext2_Enable();
@@ -297,7 +294,7 @@ void ScrSpecial_StartOldManTutorialBattle(void)
     CreateBattleStartTask(B_TRANSITION_SLICED_SCREEN, 0);
 }
 
-void BattleSetup_StartScriptedWildBattle(void)
+void StartScriptedWildBattle(void)
 {
     ScriptContext2_Enable();
     gMain.savedCallback = CB2_EndScriptedWildBattle;
@@ -307,7 +304,7 @@ void BattleSetup_StartScriptedWildBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void ScrSpecial_StartMarowakBattle(void)
+void StartMarowakBattle(void)
 {
     ScriptContext2_Enable();
     gMain.savedCallback = CB2_EndMarowakBattle;
@@ -326,7 +323,7 @@ void ScrSpecial_StartMarowakBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void ScrSpecial_StartSouthernIslandBattle(void)
+void StartSouthernIslandBattle(void)
 {
     ScriptContext2_Enable();
     gMain.savedCallback = CB2_EndScriptedWildBattle;
@@ -336,7 +333,7 @@ void ScrSpecial_StartSouthernIslandBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void Special_StartLegendaryBattle(void)
+void StartLegendaryBattle(void)
 {
     u16 species;
     
@@ -367,7 +364,7 @@ void Special_StartLegendaryBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void Special_StartGroudonKyogreBattle(void)
+void StartGroudonKyogreBattle(void)
 {
     ScriptContext2_Enable();
     gMain.savedCallback = CB2_EndScriptedWildBattle;
@@ -380,7 +377,7 @@ void Special_StartGroudonKyogreBattle(void)
     IncrementGameStat(GAME_STAT_WILD_BATTLES);
 }
 
-void Special_StartRegiBattle(void)
+void StartRegiBattle(void)
 {
     ScriptContext2_Enable();
     gMain.savedCallback = CB2_EndScriptedWildBattle;
@@ -781,7 +778,7 @@ const u8 *BattleSetup_ConfigureTrainerBattle(const u8 *data)
     {
     case TRAINER_BATTLE_SINGLE_NO_INTRO_TEXT:
         TrainerBattleLoadArgs(sOrdinaryNoIntroBattleParams, data);
-        return EventScript_DoTrainerBattle;
+        return EventScript_DoNoIntroTrainerBattle;
     case TRAINER_BATTLE_DOUBLE:
         TrainerBattleLoadArgs(sDoubleBattleParams, data);
         SetMapVarsToTrainer();
@@ -810,7 +807,7 @@ const u8 *BattleSetup_ConfigureTrainerBattle(const u8 *data)
         return EventScript_TryDoRematchBattle;
     case TRAINER_BATTLE_EARLY_RIVAL:
         TrainerBattleLoadArgs(sEarlyRivalBattleParams, data);
-        return EventScript_DoTrainerBattle;
+        return EventScript_DoNoIntroTrainerBattle;
     default:
         TrainerBattleLoadArgs(sOrdinaryBattleParams, data);
         SetMapVarsToTrainer();
@@ -823,7 +820,7 @@ void ConfigureAndSetUpOneTrainerBattle(u8 trainerEventObjId, const u8 *trainerSc
     gSelectedObjectEvent = trainerEventObjId;
     gSpecialVar_LastTalked = gObjectEvents[trainerEventObjId].localId;
     BattleSetup_ConfigureTrainerBattle(trainerScript + 1);
-    ScriptContext1_SetupScript(gUnknown_81A4EB4);
+    ScriptContext1_SetupScript(EventScript_DoTrainerBattleFromApproach);
     ScriptContext2_Enable();
 }
 
@@ -841,7 +838,7 @@ void SetUpTrainerMovement(void)
     SetTrainerMovementType(objectEvent, GetTrainerFacingDirectionMovementType(objectEvent->facingDirection));
 }
 
-u8 ScrSpecial_GetTrainerBattleMode(void)
+u8 GetTrainerBattleMode(void)
 {
     return sTrainerBattleMode;
 }
@@ -851,7 +848,7 @@ u16 GetRivalBattleFlags(void)
     return sRivalBattleFlags;
 }
 
-u16 ScrSpecial_HasTrainerBeenFought(void)
+u16 Script_HasTrainerBeenFought(void)
 {
     return FlagGet(GetTrainerAFlag());
 }
@@ -882,10 +879,10 @@ void ClearTrainerFlag(u16 trainerId)
     FlagClear(FLAG_TRAINER_FLAG_START + trainerId);
 }
 
-void BattleSetup_StartTrainerBattle(void)
+void StartTrainerBattle(void)
 {
     gBattleTypeFlags = BATTLE_TYPE_TRAINER;
-    if (ScrSpecial_GetTrainerBattleMode() == TRAINER_BATTLE_EARLY_RIVAL && GetRivalBattleFlags() & RIVAL_BATTLE_TUTORIAL)
+    if (GetTrainerBattleMode() == TRAINER_BATTLE_EARLY_RIVAL && GetRivalBattleFlags() & RIVAL_BATTLE_TUTORIAL)
         gBattleTypeFlags |= BATTLE_TYPE_FIRST_BATTLE;
     gMain.savedCallback = CB2_EndTrainerBattle;
     DoTrainerBattle();
@@ -959,7 +956,7 @@ static void CB2_EndRematchBattle(void)
     }
 }
 
-void ScrSpecial_StartTrainerEyeRematch(void)
+void StartRematchBattle(void)
 {
     gBattleTypeFlags = BATTLE_TYPE_TRAINER;
     gMain.savedCallback = CB2_EndRematchBattle;
@@ -967,7 +964,7 @@ void ScrSpecial_StartTrainerEyeRematch(void)
     ScriptContext1_Stop();
 }
 
-void ScrSpecial_ShowTrainerIntroSpeech(void)
+void ShowTrainerIntroSpeech(void)
 {
     ShowFieldMessage(GetIntroSpeechOfApproachingTrainer());
 }
@@ -988,7 +985,7 @@ const u8 *BattleSetup_GetTrainerPostBattleScript(void)
         return Test_EventScript_Sign;
 }
 
-void ScrSpecial_ShowTrainerNonBattlingSpeech(void)
+void ShowTrainerCantBattleSpeech(void)
 {
     ShowFieldMessage(GetTrainerCantBattleSpeech());
 }
diff --git a/src/battle_tower.c b/src/battle_tower.c
index cecc05e29..818c909aa 100644
--- a/src/battle_tower.c
+++ b/src/battle_tower.c
@@ -24,7 +24,7 @@
 #include "constants/moves.h"
 #include "constants/pokemon.h"
 #include "constants/vars.h"
-#include "constants/object_events.h"
+#include "constants/event_objects.h"
 
 static EWRAM_DATA u16 sSpecialVar_0x8004_Copy = 0;
 
@@ -177,7 +177,7 @@ static const u16 sLongStreakPrizes[] = {
     ITEM_CHOICE_BAND
 };
 
-void ScrSpecial_BattleTowerMapScript2(void)
+void BattleTowerMapScript2(void)
 {
     u8 count = 0;
     s32 levelType;
@@ -389,7 +389,7 @@ void ChooseNextBattleTowerTrainer(void)
 
 static void SetBattleTowerTrainerGfxId(u8 trainerClass)
 {
-    VarSet(VAR_OBJ_GFX_ID_0, OBJECT_EVENT_GFX_YOUNGSTER);
+    VarSet(VAR_OBJ_GFX_ID_0, OBJ_EVENT_GFX_YOUNGSTER);
 }
 
 void SetEReaderTrainerGfxId(void)
@@ -825,7 +825,7 @@ void CheckPartyBattleTowerBanlist(void)
     }
 }
 
-static void PrintBattleTowerTrainerMessage(const u16 *greeting)
+static void BufferBattleTowerTrainerMessage(const u16 *greeting)
 {
     s32 i;
     if (EC_DoesEasyChatStringFitOnLine(greeting, 3, 2, 18))
@@ -847,11 +847,11 @@ static void PrintBattleTowerTrainerMessage(const u16 *greeting)
 void PrintBattleTowerTrainerGreeting(void)
 {
     if (gSaveBlock2Ptr->battleTower.battleTowerTrainerId == BATTLE_TOWER_EREADER_TRAINER_ID)
-        PrintBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.greeting);
+        BufferBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.greeting);
     else if (gSaveBlock2Ptr->battleTower.battleTowerTrainerId < BATTLE_TOWER_RECORD_MIXING_TRAINER_BASE_ID)
-        PrintBattleTowerTrainerMessage(gBattleTowerTrainers[gSaveBlock2Ptr->battleTower.battleTowerTrainerId].greeting);
+        BufferBattleTowerTrainerMessage(gBattleTowerTrainers[gSaveBlock2Ptr->battleTower.battleTowerTrainerId].greeting);
     else
-        PrintBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.records[gSaveBlock2Ptr->battleTower.battleTowerTrainerId - BATTLE_TOWER_RECORD_MIXING_TRAINER_BASE_ID].greeting);
+        BufferBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.records[gSaveBlock2Ptr->battleTower.battleTowerTrainerId - BATTLE_TOWER_RECORD_MIXING_TRAINER_BASE_ID].greeting);
 }
 
 static void CB2_FinishEReaderBattle(void)
@@ -1395,9 +1395,9 @@ void ClearEReaderTrainer(struct BattleTowerEReaderTrainer *ereaderTrainer)
         ((u32 *)ereaderTrainer)[i] = 0;
 }
 
-void PrintEReaderTrainerGreeting(void)
+void BufferEReaderTrainerGreeting(void)
 {
-    PrintBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.greeting);
+    BufferBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.greeting);
 }
 
 static void PrintEReaderTrainerFarewellMessage(void)
@@ -1405,9 +1405,9 @@ static void PrintEReaderTrainerFarewellMessage(void)
     if (gBattleOutcome == B_OUTCOME_DREW)
         gStringVar4[0] = EOS;
     else if (gBattleOutcome == B_OUTCOME_WON)
-        PrintBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.farewellPlayerWon);
+        BufferBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.farewellPlayerWon);
     else
-        PrintBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.farewellPlayerLost);
+        BufferBattleTowerTrainerMessage(gSaveBlock2Ptr->battleTower.ereaderTrainer.farewellPlayerLost);
 }
 
 void Dummy_TryEnableBravoTrainerBattleTower(void)
diff --git a/src/battle_transition.c b/src/battle_transition.c
index 463a3d930..b33d72f15 100644
--- a/src/battle_transition.c
+++ b/src/battle_transition.c
@@ -644,7 +644,7 @@ static bool8 BT_Phase1Blink(struct Task *task)
 
 static bool8 BT_WaitForPhase1(struct Task *task)
 {
-    if (FindTaskIdByFunc(sBT_Phase1Tasks[task->tTransitionId]) == TASK_NONE)
+    if (FindTaskIdByFunc(sBT_Phase1Tasks[task->tTransitionId]) == TAIL_SENTINEL)
     {
         ++task->tState;
         return TRUE;
@@ -665,7 +665,7 @@ static bool8 BT_Phase2LaunchAnimTask(struct Task *task)
 static bool8 BT_WaitForPhase2(struct Task *task)
 {
     task->tTransitionDone = FALSE;
-    if (FindTaskIdByFunc(sBT_Phase2Tasks[task->tTransitionId]) == TASK_NONE)
+    if (FindTaskIdByFunc(sBT_Phase2Tasks[task->tTransitionId]) == TAIL_SENTINEL)
         task->tTransitionDone = TRUE;
     return FALSE;
 }
@@ -3432,7 +3432,7 @@ static void BT_CreatePhase1SubTask(s16 fadeOutDelay, s16 fadeInDelay, s16 blinkT
 
 static bool8 BT_IsPhase1Done(void)
 {
-    if (FindTaskIdByFunc(BT_Phase1SubTask) == TASK_NONE)
+    if (FindTaskIdByFunc(BT_Phase1SubTask) == TAIL_SENTINEL)
         return TRUE;
     else
         return FALSE;
diff --git a/src/battle_util2.c b/src/battle_util2.c
index a3a748767..6de4941cb 100644
--- a/src/battle_util2.c
+++ b/src/battle_util2.c
@@ -5,7 +5,6 @@
 #include "pokemon.h"
 #include "malloc.h"
 #include "trainer_tower.h"
-#include "battle_util2.h"
 
 void AllocateBattleResources(void)
 {
diff --git a/src/berry_crush.c b/src/berry_crush.c
new file mode 100644
index 000000000..e59cad21a
--- /dev/null
+++ b/src/berry_crush.c
@@ -0,0 +1,228 @@
+#include "global.h"
+#include "gflib.h"
+#include "berry_crush.h"
+#include "berry_pouch.h"
+#include "berry_powder.h"
+#include "item.h"
+#include "item_menu.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "math_util.h"
+#include "overworld.h"
+#include "task.h"
+#include "constants/songs.h"
+#include "constants/items.h"
+
+static EWRAM_DATA struct BerryCrushGame *gUnknown_203F3DC = NULL;
+
+static void sub_814B860(void);
+static void sub_814BA6C(void);
+static void sub_814BA80(void);
+static void sub_814BA98(u8 taskId);
+
+struct BerryCrushGame *sub_814B6F0(void)
+{
+    return gUnknown_203F3DC;
+}
+
+u32 sub_814B6FC(MainCallback callback)
+{
+    if (!gUnknown_203F3DC)
+        return 2;
+
+    if (!callback)
+        callback = gUnknown_203F3DC->unk0;
+
+    DestroyTask(gUnknown_203F3DC->unkA);
+    FREE_AND_SET_NULL(gUnknown_203F3DC);
+    SetMainCallback2(callback);
+    if (callback == CB2_ReturnToField)
+    {
+        PlayNewMapMusic(MUS_POKECEN);
+        SetMainCallback1(CB1_Overworld);
+    }
+
+    return 0;
+}
+
+void StartBerryCrush(MainCallback callback)
+{
+    u8 playerCount = 0;
+    u8 multiplayerId;
+
+    if (!gReceivedRemoteLinkPlayers || gWirelessCommType == 0)
+    {
+        SetMainCallback2(callback);
+        Rfu.linkman_param[0] = 0;
+        Rfu.linkman_param[1] = 0;
+        Rfu.errorState = 1;
+        return;
+    }
+
+    playerCount = GetLinkPlayerCount();
+    multiplayerId = GetMultiplayerId();
+    if (playerCount < 2 || multiplayerId >= playerCount)
+    {
+        SetMainCallback2(callback);
+        Rfu.linkman_param[0] = 0;
+        Rfu.linkman_param[1] = 0;
+        Rfu.errorState = 1;
+        return;
+    }
+
+    gUnknown_203F3DC = AllocZeroed(sizeof(*gUnknown_203F3DC));
+    if (!gUnknown_203F3DC)
+    {
+        SetMainCallback2(callback);
+        Rfu.linkman_param[0] = 0;
+        Rfu.linkman_param[1] = 0;
+        Rfu.errorState = 1;
+        return;
+    }
+
+    gUnknown_203F3DC->unk0 = callback;
+    gUnknown_203F3DC->unk8 = multiplayerId;
+    gUnknown_203F3DC->unk9 = playerCount;
+    sub_814BABC(gUnknown_203F3DC);
+    gUnknown_203F3DC->unk12 = 1;
+    gUnknown_203F3DC->unkE = 1;
+    gUnknown_203F3DC->unkF = 6;
+    sub_814D564(gUnknown_203F3DC->unk36, 1, -1, 0, 16, 0, 0);
+    sub_814BB4C(4, 1, gUnknown_203F3DC->unk36);
+    SetMainCallback2(sub_814BA80);
+    gUnknown_203F3DC->unkA = CreateTask(sub_814BA98, 8);
+}
+
+static void sub_814B860(void)
+{
+    if (gSpecialVar_ItemId < FIRST_BERRY_INDEX || gSpecialVar_ItemId > LAST_BERRY_INDEX + 1)
+        gSpecialVar_ItemId = ITEM_CHERI_BERRY;
+    else
+        RemoveBagItem(gSpecialVar_ItemId, 1);
+
+    gUnknown_203F3DC->unk68.as_four_players.others[gUnknown_203F3DC->unk8].unk0 = gSpecialVar_ItemId - FIRST_BERRY_INDEX;
+    gUnknown_203F3DC->unkE = 1;
+    gUnknown_203F3DC->unkF = 9;
+    sub_814D564(gUnknown_203F3DC->unk36, 0, -1, 0, 16, 0, 0);
+    sub_814BB4C(4, 1, gUnknown_203F3DC->unk36);
+    gUnknown_203F3DC->unkA = CreateTask(sub_814BA98, 8);
+    SetMainCallback2(sub_814BA80);
+}
+
+void sub_814B8F0(void)
+{
+    DestroyTask(gUnknown_203F3DC->unkA);
+    InitBerryPouch(BERRYPOUCH_FROMBERRYCRUSH, sub_814B860, FALSE);
+}
+
+void sub_814B914(void)
+{
+    SetVBlankCallback(sub_814BA6C);
+}
+
+void sub_814B924(void)
+{
+    SetVBlankCallback(NULL);
+}
+
+void sub_814B930(void)
+{
+    u32 var0, var1;
+
+    var0 = gUnknown_203F3DC->unk68.as_four_players.unk00.unk04;
+    var0 <<= 8;
+    var0 = sub_80D8B68(var0, 60 << 8);
+    var1 = gUnknown_203F3DC->unk68.as_four_players.unk00.unk0A;
+    var1 <<= 8;
+    var1 = sub_80D8B68(var1, var0) & 0xFFFF;
+    gUnknown_203F3DC->unk16 = var1;
+    switch (gUnknown_203F3DC->unk9)
+    {
+    case 2:
+        if (gUnknown_203F3DC->unk16 > gSaveBlock2Ptr->berryCrush.berryCrushResults[0])
+        {
+            gUnknown_203F3DC->unk25_1 = 1;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[0] = gUnknown_203F3DC->unk16;
+        }
+        break;
+    case 3:
+        if (gUnknown_203F3DC->unk16 > gSaveBlock2Ptr->berryCrush.berryCrushResults[1])
+        {
+            gUnknown_203F3DC->unk25_1 = 1;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[1] = gUnknown_203F3DC->unk16;
+        }
+        break;
+    case 4:
+        if (gUnknown_203F3DC->unk16 > gSaveBlock2Ptr->berryCrush.berryCrushResults[2])
+        {
+            gUnknown_203F3DC->unk25_1 = 1;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[2] = gUnknown_203F3DC->unk16;
+        }
+        break;
+    case 5:
+        if (gUnknown_203F3DC->unk16 > gSaveBlock2Ptr->berryCrush.berryCrushResults[3])
+        {
+            gUnknown_203F3DC->unk25_1 = 1;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[3] = gUnknown_203F3DC->unk16;
+        }
+        break;
+    }
+
+    gUnknown_203F3DC->unk1C = gUnknown_203F3DC->unk68.as_four_players.unk00.unk00;
+    if (GiveBerryPowder(gUnknown_203F3DC->unk1C))
+        return;
+
+    gUnknown_203F3DC->unk25_0 = 1;
+}
+
+static void sub_814BA6C(void)
+{
+    TransferPlttBuffer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+}
+
+static void sub_814BA80(void)
+{
+    RunTasks();
+    RunTextPrinters();
+    AnimateSprites();
+    BuildOamBuffer();
+}
+
+static void sub_814BA98(u8 taskId)
+{
+    if (gUnknown_203F3DC->unk4)
+        gUnknown_203F3DC->unk4(gUnknown_203F3DC, gUnknown_203F3DC->unk36);
+
+    sub_814D9CC(gUnknown_203F3DC);
+}
+
+void sub_814BABC(struct BerryCrushGame *arg0)
+{
+    u8 i;
+
+    for (i = 0; i < arg0->unk9; i++)
+    {
+        StringCopy(PLAYER_UNK14(arg0, i), gLinkPlayers[i].name);
+        arg0->unk68.as_five_players.unk1C[i].unk14[PLAYER_NAME_LENGTH] = EOS;
+    }
+    for (; i < 5; i++)
+    {
+        memset(PLAYER_UNK14(arg0, i), 1, PLAYER_NAME_LENGTH);
+        arg0->unk68.as_five_players.unk1C[i].unk14[PLAYER_NAME_LENGTH] = EOS;
+    }
+
+    switch (gSaveBlock2Ptr->optionsTextSpeed)
+    {
+    case OPTIONS_TEXT_SPEED_SLOW:
+        arg0->unkB = 8;
+        break;
+    case OPTIONS_TEXT_SPEED_MID:
+        arg0->unkB = 4;
+        break;
+    case OPTIONS_TEXT_SPEED_FAST:
+        arg0->unkB = 1;
+        break;
+    }
+}
diff --git a/src/berry_crush_2.c b/src/berry_crush_2.c
new file mode 100644
index 000000000..e76f33988
--- /dev/null
+++ b/src/berry_crush_2.c
@@ -0,0 +1,1480 @@
+#include "global.h"
+#include "gflib.h"
+#include "berry.h"
+#include "berry_crush.h"
+#include "berry_powder.h"
+#include "item.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "math_util.h"
+#include "menu.h"
+#include "minigame_countdown.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+#include "random.h"
+#include "save.h"
+#include "strings.h"
+#include "constants/songs.h"
+
+static u32 sub_814BBB8(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BC10(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BC74(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BD7C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BD9C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BDBC(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BE0C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BE64(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BE7C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814BFD0(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814C118(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814C24C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814C850(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814C8F8(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814C990(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814CB20(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814CC0C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814CFA8(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D094(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D188(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D240(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D31C(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D3A4(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D468(struct BerryCrushGame * berryCrushGame, u8 *params);
+static u32 sub_814D4C8(struct BerryCrushGame * berryCrushGame, u8 *params);
+void sub_814D4D8(struct BerryCrushGame * r4);
+void sub_814D5A4(u8 *r0, u32 r1, u32 r2, u32 r3, u32 r5);
+
+static const u8 gUnknown_846E2E0[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
+static const u8 gUnknown_846E2E8[] = {0x00, 0x01, 0x02, 0x03, 0x05, 0x00, 0x00, 0x00};
+
+static const s8 gUnknown_846E2F0[][7] = {
+    {0x04, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00},
+    {0x04, 0x02, 0x00, 0xff, 0x00, 0x00, 0x00},
+    {0x04, 0x02, 0x00, 0xfe, 0x00, 0x00, 0x00},
+    {0x06, 0x03, 0x01, 0xff, 0xfd, 0xff, 0x00},
+    {0x06, 0x04, 0x01, 0xfe, 0xfc, 0xfe, 0x00},
+};
+
+ALIGNED(4) const u8 gUnknown_846E314[][4] = {
+    {0x03, 0x02, 0x01, 0x00},
+    {0x03, 0x03, 0x01, 0x00},
+    {0x03, 0x03, 0x02, 0x00},
+    {0x03, 0x04, 0x02, 0x00},
+    {0x03, 0x05, 0x03, 0x00}
+};
+
+static const u8 *const gUnknown_846E328[] = {
+    gUnknown_841CE3C,
+    gUnknown_841CE78,
+    gUnknown_841CEA8,
+    gUnknown_841CF14,
+    gUnknown_841CF50,
+    gUnknown_841CF70,
+    gUnknown_841CFA0,
+    gUnknown_841CFD4,
+    gUnknown_841D008
+};
+
+static u32 (*const gUnknown_846E34C[])(struct BerryCrushGame * berryCrushGame, u8 *params) = {
+    NULL,
+    sub_814BBB8,
+    sub_814BC10,
+    sub_814BC74,
+    sub_814BD7C,
+    sub_814BD9C,
+    sub_814BDBC,
+    sub_814BE0C,
+    sub_814BE64,
+    sub_814BE7C,
+    sub_814BFD0,
+    sub_814C118,
+    sub_814C24C,
+    sub_814C850,
+    sub_814C8F8,
+    sub_814C990,
+    sub_814CB20,
+    sub_814CC0C,
+    sub_814CFA8,
+    sub_814D094,
+    sub_814D188,
+    sub_814D240,
+    sub_814D31C,
+    sub_814D3A4,
+    sub_814D468,
+    sub_814D4C8
+};
+
+static const u8 gUnknown_846E3B4[][4] = {
+    {0x02, 0x04, 0x06, 0x07},
+    {0x03, 0x05, 0x08, 0x0b},
+    {0x03, 0x07, 0x0b, 0x0f},
+    {0x04, 0x08, 0x0c, 0x11}
+};
+
+static const u8 gUnknown_846E3C4[] = {0x05, 0x07, 0x09, 0x0c};
+
+static const u8 gUnknown_846E3C8[] = {0x03, 0x07, 0x0F, 0x1F};
+
+void sub_814BB4C(u16 r5, u8 r4, u8 *r7)
+{
+    struct BerryCrushGame * r6 = sub_814B6F0();
+
+    if (r5 > 25)
+        r5 = 0;
+    switch (r4)
+    {
+    case 0:
+        if (r5 != 0)
+            gUnknown_846E34C[r5](r6, r7);
+        if (r6->unkE > 25)
+            r6->unkE = r4;
+        r6->unk4 = gUnknown_846E34C[r6->unkE];
+        break;
+    case 1:
+        r6->unk4 = gUnknown_846E34C[r5];
+        break;
+    }
+}
+
+static u32 sub_814BBB8(struct BerryCrushGame * r6, u8 *r1)
+{
+    u16 r4;
+    u32 r0;
+#ifndef NONMATCHING // fake match, nobody can write such code
+    register u32 r2 asm("r2");
+    register u32 r3 asm("r3");
+
+    r2 = r1[0];
+    r3 = r1[1];
+    r3 <<= 8;
+    r2 |= r3;
+    r3 = r1[2];
+    r3 <<= 16;
+    r2 |= r3;
+    r3 = r1[3];
+    r3 <<= 24;
+    r0 = r2;
+    r0 |= r3;
+#else
+    u32 r2;
+
+    r0 = T1_READ_32(r1);
+#endif
+    r2 = r1[9];
+    r1[0] = r2;
+    r4 = r1[8] << 8;
+    r2 = r1[7];
+    r4 |= r2;
+    gPaletteFade.bufferTransferDisabled = FALSE;
+    BeginNormalPaletteFade(r0, r1[4], r1[5], r1[6], r4);
+    UpdatePaletteFade();
+    r6->unkE = 2;
+    return 0;
+}
+
+static u32 sub_814BC10(struct BerryCrushGame * r4, u8 *r5)
+{
+    switch (r4->unkC)
+    {
+    case 0:
+        if (UpdatePaletteFade())
+            return 0;
+        if(r5[0] != 0)
+            ++r4->unkC;
+        else
+            r4->unkC = 3;
+        return 0;
+    case 1:
+        LinkRfu_SetRfuFuncToSend6600();
+        ++r4->unkC;
+        return 0;
+    case 2:
+        if (IsLinkTaskFinished())
+        {
+            ++r4->unkC;
+            return 0;
+        }
+        return 0;
+    case 3:
+        sub_814BB4C(r4->unkF, 1, NULL);
+        r4->unkC = 0;
+        return 0;
+    default:
+        ++r4->unkC;
+        return 0;
+    }
+}
+
+static u32 sub_814BC74(struct BerryCrushGame * r7, u8 *r5)
+{
+    u16 r4 = r5[3];
+
+    r4 <<= 8;
+    r4 |= r5[2];
+    switch (r7->unkC)
+    {
+    case 0:
+        DrawDialogueFrame(0, 0);
+        if (r5[1] & 2)
+        {
+            StringExpandPlaceholders(gStringVar4, gUnknown_846E328[r5[0]]);
+            AddTextPrinterParameterized2(0, 2, gStringVar4, r7->unkB, 0, 2, 1, 3);
+        }
+        else
+        {
+            AddTextPrinterParameterized2(0, 2, gUnknown_846E328[r5[0]], r7->unkB, 0, 2, 1, 3);
+        }
+        CopyWindowToVram(0, 3);
+        break;
+    case 1:
+        if (!IsTextPrinterActive(0))
+        {
+            if (r4 == 0)
+                ++r7->unkC;
+            break;
+        }
+        return 0;
+    case 2:
+        if (!(r4 & gMain.newKeys))
+            return 0;
+        break;
+    case 3:
+        if (r5[1] & 1)
+            ClearDialogWindowAndFrame(0, TRUE);
+        sub_814BB4C(r7->unkE, 1, NULL);
+        r7->unkC = r5[4];
+        return 0;
+    }
+    ++r7->unkC;
+    return 0;
+}
+
+static u32 sub_814BD7C(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    if (sub_814D5C8() != 0)
+        sub_814BB4C(r4->unkE, 0, r4->unk36);
+    return 0;
+}
+
+static u32 sub_814BD9C(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    if (sub_814D888() != 0)
+        sub_814BB4C(r4->unkE, 0, r4->unk36);
+    return 0;
+}
+
+static u32 sub_814BDBC(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    switch (r4->unkC)
+    {
+    case 0:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+        {
+            PlayNewMapMusic(MUS_SLOT);
+            sub_814BB4C(7, 1, NULL);
+            r4->unk12 = 3;
+            r4->unkC = 0;
+        }
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+static u32 sub_814BE0C(struct BerryCrushGame * r4, u8 *r5)
+{
+    switch (r4->unkC)
+    {
+    default:
+        ++r4->unkC;
+        break;
+    case 0:
+        sub_814D4D8(r4);
+        sub_814D5A4(r5, 0, 1, 0, 1);
+        r4->unkE = 7;
+        sub_814BB4C(3, 1, NULL);
+        break;
+    case 1:
+        r4->unkE = 8;
+        sub_814BB4C(5, 1, NULL);
+        r4->unkC = 2;
+        break;
+    }
+    return 0;
+}
+
+static u32 sub_814BE64(struct BerryCrushGame * r0, UNUSED u8 *r1)
+{
+    r0->unk4 = NULL;
+    SetMainCallback2(sub_814B8F0);
+    return 0;
+}
+
+static u32 sub_814BE7C(struct BerryCrushGame * r5, u8 *r2)
+{
+    u8 r3;
+
+    switch (r5->unkC)
+    {
+    case 0:
+        sub_814D5A4(r2, 1, 0, 0, 1);
+        r5->unkE = 9;
+        sub_814BB4C(3, 1, NULL);
+        return 0;
+    case 1:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 2:
+        if (!IsLinkTaskFinished())
+            return 0;
+        memset(r5->unk40.unk2, 0, sizeof(r5->unk40.unk2));
+        r5->unk40.unk2[0] = r5->unk68.as_four_players.others[r5->unk8].unk0;
+        SendBlock(0, r5->unk40.unk2, 2);
+        break;
+    case 3:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r5->unk10 = 0;
+        break;
+    case 4:
+        if (GetBlockReceivedStatus() != gUnknown_846E3C8[r5->unk9 - 2])
+            return 0;
+        for (r3 = 0; r3 < r5->unk9; ++r3)
+        {
+            r5->unk68.as_four_players.others[r3].unk0 = gBlockRecvBuffer[r3][0];
+            if (r5->unk68.as_four_players.others[r3].unk0 > 0xB0)
+                r5->unk68.as_four_players.others[r3].unk0 = 0;
+            r5->unk18 += gUnknown_83DFC9C[r5->unk68.as_four_players.others[r3].unk0].unk0;
+            r5->unk1C += gUnknown_83DFC9C[r5->unk68.as_four_players.others[r3].unk0].unk1;
+        }
+        r5->unk10 = 0;
+        ResetBlockReceivedFlags();
+        r5->unk20 = sub_80D8B68(r5->unk18 << 8, 0x2000);
+        break;
+    case 5:
+        ClearDialogWindowAndFrame(0, 1);
+        sub_814BB4C(10, 1, NULL);
+        r5->unk12 = 4;
+        r5->unkC = 0;
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814BFD0(struct BerryCrushGame * r4,  UNUSED u8 *r1)
+{
+    switch (r4->unkC)
+    {
+    case 0:
+        sub_814DA24(r4, &r4->unk138);
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r4->unk138.unk0 = 0;
+        r4->unk138.unk1 = 0;
+        r4->unk138.unk2 = 0;
+        r4->unk138.unk3 = 0;
+        break;
+    case 2:
+        r4->unk138.unk38[r4->unk138.unk0]->callback = sub_814DB84;
+        r4->unk138.unk38[r4->unk138.unk0]->affineAnimPaused = FALSE;
+        PlaySE(SE_NAGERU);
+        break;
+    case 3:
+        if (r4->unk138.unk38[r4->unk138.unk0]->callback == sub_814DB84)
+            return 0;
+        r4->unk138.unk38[r4->unk138.unk0] = NULL;
+        ++r4->unk138.unk0;
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 4:
+        if (!IsLinkTaskFinished())
+            return 0;
+        if (r4->unk138.unk0 < r4->unk9)
+        {
+            r4->unkC = 2;
+            return 0;
+        }
+        r4->unk138.unk0 = 0;
+        break;
+    case 5:
+        sub_814DC24(r4, &r4->unk138);
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 6:
+        if (!IsLinkTaskFinished())
+            return 0;
+        PlaySE(SE_RU_HYUU);
+        sub_814BB4C(11, 1, NULL);
+        r4->unk12 = 5;
+        r4->unkC = 0;
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+static u32 sub_814C118(struct BerryCrushGame * r4,  UNUSED u8 *r1)
+{
+    switch (r4->unkC)
+    {
+    case 0:
+        r4->unk2A += 4;
+        if (r4->unk2A < 0)
+            return 0;
+        r4->unk2A = 0;
+        r4->unk138.unk1 = 4;
+        r4->unk138.unk0 = 0;
+        r4->unk138.unk2 = gUnknown_846E2F0[r4->unk138.unk1][0];
+        PlaySE(SE_W070);
+        break;
+    case 1:
+        r4->unk2C = gUnknown_846E2F0[r4->unk138.unk1][r4->unk138.unk0];
+        SetGpuReg(REG_OFFSET_BG0VOFS, -r4->unk2C);
+        SetGpuReg(REG_OFFSET_BG2VOFS, -r4->unk2C);
+        SetGpuReg(REG_OFFSET_BG3VOFS, -r4->unk2C);
+        ++r4->unk138.unk0;
+        if (r4->unk138.unk0 < r4->unk138.unk2)
+            return 0;
+        if (r4->unk138.unk1 == 0)
+            break;
+        --r4->unk138.unk1;
+        r4->unk138.unk2 = gUnknown_846E2F0[r4->unk138.unk1][0];
+        r4->unk138.unk0 = 0;
+        return 0;
+    case 2:
+        r4->unk2C = 0;
+        SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 3:
+        if (!IsLinkTaskFinished())
+            return 0;
+        sub_814BB4C(12, 1, NULL);
+        r4->unk12 = 6;
+        r4->unkC = 0;
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+static u32 sub_814C24C(struct BerryCrushGame * r4,  UNUSED u8 *r1)
+{
+    switch (r4-> unkC)
+    {
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        StartMinigameCountdown(0x1000, 0x1000, 120, 80, 0);
+        break;
+    case 2:
+        if (IsMinigameCountdownRunning())
+            return 0;
+        // fallthrough
+    case 0:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 3:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r4->unk138.unk0 = 0;
+        r4->unk138.unk1 = 0;
+        r4->unk138.unk2 = 0;
+        r4->unk138.unk3 = 0;
+        r4->unk10 = 0;
+        if (r4->unk8 == 0)
+            sub_814BB4C(13, 1, NULL);
+        else
+            sub_814BB4C(14, 1, NULL);
+        r4->unk12 = 7;
+        r4->unkC = 0;
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+void sub_814C2FC(struct BerryCrushGame * r4)
+{
+    u8 r8 = 0;
+    u16 r3;
+    u16 *r2;
+    u8 r7 = 0;
+    s32 r2_ = 0;
+    s32 r0;
+
+    for (r7 = 0; r7 < r4->unk9; ++r7)
+    {
+        r2 = gRecvCmds[r7];
+        if ((r2[0] & 0xFF00) == 0x2F00
+            && r2[1] == 2)
+        {
+            if ((u8)r2[2] & 4)
+            {
+                r4->unk5C.unk02_3 |= gUnknown_846E2E0[r7];
+                r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][5] = 1;
+                ++r4->unk68.as_four_players.others[r7].unk4.as_hwords[3];
+                ++r8;
+                r3 = r4->unk28 - r4->unk68.as_four_players.others[r7].unk2;
+                if (r3 >= r4->unk68.as_four_players.others[r7].unk4.as_hwords[1] - 1
+                    && r3 <= r4->unk68.as_four_players.others[r7].unk4.as_hwords[1] + 1)
+                {
+                    ++r4->unk68.as_four_players.others[r7].unk4.as_hwords[0];
+                    r4->unk68.as_four_players.others[r7].unk4.as_hwords[1] = r3;
+                    if (r4->unk68.as_four_players.others[r7].unk4.as_hwords[0] > r4->unk68.as_four_players.others[r7].unk4.as_hwords[2])
+                        r4->unk68.as_four_players.others[r7].unk4.as_hwords[2] = r4->unk68.as_four_players.others[r7].unk4.as_hwords[0];
+                }
+                else
+                {
+                    r4->unk68.as_four_players.others[r7].unk4.as_hwords[0] = 0;
+                    r4->unk68.as_four_players.others[r7].unk4.as_hwords[1] = r3;
+                }
+                r4->unk68.as_four_players.others[r7].unk2 = r4->unk28;
+                if (++r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][4] > 2)
+                    r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][4] = 0;
+            }
+            else
+            {
+                r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][5] = 0;
+            }
+        }
+    }
+    if (r8 > 1)
+    {
+        for (r7 = 0; r7 < r4->unk9; ++r7)
+        {
+            if (r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][5] != 0)
+            {
+                r4->unk68.as_four_players.others[r7].unk4.as_2d_bytes[1][5] |= 2;
+                ++r4->unk68.as_four_players.others[r7].unk4.as_hwords[4];
+            }
+        }
+    }
+    if (r8 != 0)
+    {
+        r4->unk2E += r8;
+        r8 += gUnknown_846E2E8[r8 - 1];
+        r4->unk34 += r8;
+        r4->unk1A += r8;
+        r0 = r4->unk18;
+        r2_ = r4->unk1A;
+        if (r0 - r2_ > 0)
+        {
+            r2_ <<= 8;
+            r2_ = sub_80D8B68(r2_, r4->unk20);
+            r2_ >>= 8;
+            r4->unk24 = r2_;
+        }
+        else
+        {
+            r4->unk24 = 32;
+            r4->unk5C.unk02_0 = 1;
+        }
+    }
+}
+
+void sub_814C4B8(struct BerryCrushGame * r3)
+{
+    u8 r6 = 0;
+    u16 r1 = 0;
+    u8 r4 = 0;
+
+    for (r4 = 0; r4 < r3->unk9; ++r4)
+    {
+        if (r3->unk68.as_four_players.others[r4].unk4.as_2d_bytes[1][5] != 0)
+        {
+            ++r6;
+            r1 = r3->unk68.as_four_players.others[r4].unk4.as_2d_bytes[1][4] + 1;
+            if (r3->unk68.as_four_players.others[r4].unk4.as_2d_bytes[1][5] & 2)
+                r1 |= 4;
+            r1 <<= 3 * r4;
+            r3->unk5C.unk08 |= r1;
+        }
+    }
+    r3->unk5C.unk04 = r3->unk24;
+    if (r6 == 0)
+    {
+        if (r3->unk138.unk3 != 0)
+            ++r3->unk138.unk0;
+        else
+            goto SET_UNK5F_0;
+    }
+    else
+    {
+        if (r3->unk138.unk3 != 0)
+        {
+            if (r6 != r3->unk138.unk1)
+            {
+                r3->unk138.unk1 = r6 - 1;
+                r3->unk138.unk2 = gUnknown_846E314[r6 - 1][0];
+            }
+            else
+            {
+                ++r3->unk138.unk0;
+            }
+        }
+        else
+        {
+            r3->unk138.unk0 = 0;
+            r3->unk138.unk1 = r6 - 1;
+            r3->unk138.unk2 = gUnknown_846E314[r6 - 1][0];
+            r3->unk138.unk3 = 1;
+        }
+    }
+    if (r3->unk138.unk3 != 0)
+    {
+        if (r3->unk138.unk0 >= r3->unk138.unk2)
+        {
+            r3->unk138.unk0 = 0;
+            r3->unk138.unk1 = 0;
+            r3->unk138.unk2 = 0;
+            r3->unk138.unk3 = 0;
+            r1 = 0;
+        }
+        else
+        {
+            r1 = gUnknown_846E314[r3->unk138.unk1][r3->unk138.unk0 + 1];
+        }
+        r3->unk5C.unk03 = r1;
+    }
+    else
+    {
+        SET_UNK5F_0:
+        r3->unk5C.unk03 = 0;
+    }
+    r3->unk5C.unk06 = r3->unk26;
+}
+
+void sub_814C618(struct BerryCrushGame * r5)
+{
+    if (gMain.newKeys & A_BUTTON)
+        r5->unk5C.unk02_2 = 1;
+    if (gMain.heldKeys & A_BUTTON)
+    {
+        if (r5->unk68.as_four_players.others[r5->unk8].unk4.as_hwords[5] < r5->unk28)
+            ++r5->unk68.as_four_players.others[r5->unk8].unk4.as_hwords[5];
+    }
+    if (r5->unk8 != 0 && r5->unk5C.unk02_2 == 0)
+        return;
+    r5->unk5C.unk00 = 2;
+    if (r5->unk28 % 30 == 0)
+    {
+        if (r5->unk2E > gUnknown_846E3C4[r5->unk9 - 2])
+        {
+            ++r5->unk30;
+            r5->unk25_4 = 1;
+        }
+        else
+        {
+            r5->unk25_4 = 0;
+        }
+        r5->unk2E = 0;
+        ++r5->unk32;
+    }
+    if (r5->unk28 % 15 == 0)
+    {
+        if (r5->unk34 < gUnknown_846E3B4[r5->unk9 - 2][0])
+            r5->unk25_5 = 0;
+        else if (r5->unk34 < gUnknown_846E3B4[r5->unk9 - 2][1])
+            r5->unk25_5 = 1;
+        else if (r5->unk34 < gUnknown_846E3B4[r5->unk9 - 2][2])
+            r5->unk34 = 2; // typo since r5->unk34 will be reset?
+        else if (r5->unk34 < gUnknown_846E3B4[r5->unk9 - 2][3])
+            r5->unk34 = 3; // typo since r5->unk34 will be reset?
+        else
+            r5->unk25_5 = 4;
+        r5->unk34 = 0;
+    }
+    else
+    {
+        ++r5->unk10;
+        if (r5->unk10 > 60)
+        {
+            if (r5->unk10 > 70)
+            {
+                sub_80FBA44();
+                r5->unk10 = 0;
+            }
+            else if (r5->unk5C.unk02_3 == 0)
+            {
+                sub_80FBA44();
+                r5->unk10 = 0;
+            }
+        }
+
+    }
+    if (r5->unk28 >= 36000)
+        r5->unk5C.unk02_0 = 1;
+    r5->unk5C.unk02_1 = r5->unk25_4;
+    r5->unk5C.unk0A = r5->unk25_5;
+    memcpy(r5->unk40.unk2, &r5->unk5C, sizeof(r5->unk40.unk2));
+    RfuPrepareSend0x2f00(r5->unk40.unk2);
+}
+
+void sub_814C7BC(struct BerryCrushGame * r5)
+{
+    struct BerryCrushGame_4E * r4_;
+#ifndef NONMATCHING
+    register u32 r4 asm("r4");
+    register u32 r0 asm("r0");
+
+    for (r4 = 0; r4 < r5->unk9; r4 = (u8)r0)
+    {
+        r5->unk68.as_four_players.others[r4].unk4.as_2d_bytes[1][5] = 0;
+        r0 = r4 + 1;
+    }
+#else
+    u8 r4;
+
+    for (r4 = 0; r4 < r5->unk9; ++r4)
+        r5->unk68.as_four_players.others[r4].unk4.as_2d_bytes[1][5] = 0;
+#endif
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00
+        || gRecvCmds[0][1] != 2)
+    {
+        r5->unk25_2 = 0;
+    }
+    else
+    {
+        r4_ = &r5->unk40.unkE;
+        memcpy(r4_, gRecvCmds, sizeof(struct BerryCrushGame_4E));
+        r5->unk2A = r4_->unk6;
+        r5->unk2C = r4_->unk5;
+        r5->unk28 = r4_->unk8;
+        sub_814DC5C(r5, &r5->unk138);
+        if (r4_->unk4_0)
+            r5->unk25_3 = 1;
+    }
+}
+
+static u32 sub_814C850(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    memset(&r4->unk5C, 0, sizeof(r4->unk5C));
+    memset(&r4->unk40.unkE, 0, sizeof(r4->unk40.unkE));
+    sub_814C7BC(r4);
+    SetGpuReg(REG_OFFSET_BG0VOFS, -r4->unk2C);
+    SetGpuReg(REG_OFFSET_BG2VOFS, -r4->unk2C);
+    SetGpuReg(REG_OFFSET_BG3VOFS, -r4->unk2C);
+    if (r4->unk25_3)
+    {
+        if (r4->unk28 >= 36000)
+        {
+            r4->unk28 = 36000;
+            sub_814BB4C(16, 1, NULL);
+        }
+        else
+        {
+            sub_814BB4C(15, 1, NULL);
+        }
+        r4->unk10 = 0;
+        r4->unkC = 0;
+        return 0;
+    }
+    else
+    {
+        ++r4->unk26;
+        sub_814C2FC(r4);
+        sub_814C4B8(r4);
+        sub_814C618(r4);
+        return 0;
+    }
+}
+
+static u32 sub_814C8F8(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    memset(&r4->unk5C, 0, sizeof(r4->unk5C));
+    memset(&r4->unk40.unkE, 0, sizeof(r4->unk40.unkE));
+    sub_814C7BC(r4);
+    SetGpuReg(REG_OFFSET_BG0VOFS, -r4->unk2C);
+    SetGpuReg(REG_OFFSET_BG2VOFS, -r4->unk2C);
+    SetGpuReg(REG_OFFSET_BG3VOFS, -r4->unk2C);
+    if (r4->unk25_3)
+    {
+        if (r4->unk28 >= 36000)
+        {
+            r4->unk28 = 36000;
+            sub_814BB4C(16, 1, NULL);
+        }
+        else
+        {
+            sub_814BB4C(15, 1, NULL);
+        }
+        r4->unk10 = 0;
+        r4->unkC = 0;
+        return 0;
+    }
+    else
+    {
+        sub_814C618(r4);
+        return 0;
+    }
+}
+
+static u32 sub_814C990(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    switch (r4->unkC)
+    {
+    case 0:
+        r4->unk12 = 8;
+        PlaySE(SE_W070);
+        BlendPalettes(0xFFFFFFFF, 8, RGB(31, 31, 0));
+        r4->unk138.unk0 = 2;
+        break;
+    case 1:
+        if (--r4->unk138.unk0 != 255)
+            return 0;
+        BlendPalettes(0xFFFFFFFF, 0, RGB(31, 31, 0));
+        r4->unk138.unk1 = 4;
+        r4->unk138.unk0 = 0;
+        r4->unk138.unk2 = gUnknown_846E2F0[r4->unk138.unk1][0];
+        break;
+    case 2:
+        r4->unk2C = gUnknown_846E2F0[r4->unk138.unk1][r4->unk138.unk0];
+        SetGpuReg(REG_OFFSET_BG0VOFS, -r4->unk2C);
+        SetGpuReg(REG_OFFSET_BG2VOFS, -r4->unk2C);
+        SetGpuReg(REG_OFFSET_BG3VOFS, -r4->unk2C);
+        if (++r4->unk138.unk0 < r4->unk138.unk2)
+            return 0;
+        if (r4->unk138.unk1 != 0)
+        {
+            --r4->unk138.unk1;
+            r4->unk138.unk2 = gUnknown_846E2F0[r4->unk138.unk1][0];
+            r4->unk138.unk0 = 0;
+            return 0;
+        }
+        break;
+    case 3:
+        r4->unk2C = 0;
+        SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+        break;
+    case 4:
+        if (!sub_814DE50(r4, &r4->unk138))
+            return 0;
+        LinkRfu_SetRfuFuncToSend6600();
+        r4->unk10 = 0;
+        break;
+    case 5:
+        if (!IsLinkTaskFinished())
+            return 0;
+        sub_814BB4C(17, 1, NULL);
+        r4->unk10 = 0;
+        r4->unkC = 0;
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+static u32 sub_814CB20(struct BerryCrushGame * r5, u8 *r6)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        r5->unk12 = 9;
+        PlaySE(SE_HAZURE);
+        BlendPalettes(0xFFFFFFFF, 8, RGB(31, 0, 0));
+        r5->unk138.unk0 = 4;
+        break;
+    case 1:
+        if (--r5->unk138.unk0 != 255)
+            return 0;
+        BlendPalettes(0xFFFFFFFF, 0, RGB(31, 0, 0));
+        r5->unk138.unk0 = 0;
+        break;
+    case 2:
+        if (!sub_814DE50(r5, &r5->unk138))
+            return 0;
+        LinkRfu_SetRfuFuncToSend6600();
+        r5->unk10 = 0;
+        SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+        SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+        break;
+    case 3:
+        if (!IsLinkTaskFinished())
+            return 0;
+        ConvertIntToDecimalStringN(gStringVar1, r5->unk1C, STR_CONV_MODE_LEFT_ALIGN, 6);
+        sub_814D5A4(r6, 7, 1, 0, 0);
+        r5->unkE = 19;
+        sub_814BB4C(3, 1, NULL);
+        r5->unk10 = 0;
+        r5->unkC = 0;
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814CC0C(struct BerryCrushGame * r7, UNUSED u8 *r1)
+{
+    u8 r8, r4_;
+    s32 r2;
+    s32 r4;
+    u8 r6; // ???
+
+    switch (r7->unkC)
+    {
+    case 0:
+        memset(r7->unk40.unk2, 0, 2 * sizeof(u16));
+        if (r7->unk68.as_four_players.others[r7->unk8].unk4.as_hwords[5] > r7->unk28)
+            r7->unk68.as_four_players.others[r7->unk8].unk4.as_hwords[5] = r7->unk28;
+        r7->unk40.unk2[0] = r7->unk68.as_four_players.others[r7->unk8].unk4.as_hwords[5];
+        SendBlock(0, r7->unk40.unk2, 2);
+        break;
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r7->unk10 = 0;
+        break;
+    case 2:
+        if (GetBlockReceivedStatus() != gUnknown_846E3C8[r7->unk9 - 2])
+            return 0;
+        for (r8 = 0; r8 < r7->unk9; ++r8)
+            r7->unk68.as_four_players.others[r8].unk4.as_hwords[5] = gBlockRecvBuffer[r8][0];
+        r7->unk10 = 0;
+        r7->unk40.unk2[0] = 0;
+        ResetBlockReceivedFlags();
+        if (r7->unk8 == 0)
+            r7->unkC = 3;
+        else
+            r7->unkC = 6;
+        return 0;
+    case 3:
+        memset(
+            &r7->unk68,
+            0,
+            sizeof(struct BerryCrushGame_68_x_SubStruct)
+        );
+        r7->unk68.as_four_players.unk00.unk04 = r7->unk28;
+        r7->unk68.as_four_players.unk00.unk06 = r7->unk18 / (r7->unk28 / 60);
+        r2 = sub_80D8AE0(r7->unk30 << 8, 0x3200);
+        r2 = sub_80D8B68(r2, r7->unk32 << 8) + 0x3200;
+        r2 >>= 8;
+        r7->unk68.as_four_players.unk00.unk08 = r2 & 0x7F;
+        r2 <<= 8;
+        r2 = sub_80D8B68(r2, 0x6400);
+        r4 = (r7->unk1C * r7->unk9) << 8;
+        r4 = sub_80D8AE0(r4, r2);
+        r7->unk68.as_four_players.unk00.unk00 = r4 >> 8;
+        r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[0][7] = Random() % 3;
+        for (r6 = 0, r8 = 0; r8 < r7->unk9; ++r8)
+        {
+            r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[0][r8] = r8;
+            r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[1][r8] = r8;
+            r7->unk68.as_four_players.unk00.unk0C[0][r8] = r7->unk68.as_four_players.others[r8].unk4.as_hwords[3];
+            r7->unk68.as_four_players.unk00.unk0A += r7->unk68.as_four_players.unk00.unk0C[0][r8];
+            switch (r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[0][7])
+            {
+            case 0:
+                if (r7->unk68.as_four_players.others[r8].unk4.as_hwords[3] != 0)
+                {
+                    r2 = r7->unk68.as_four_players.others[r8].unk4.as_hwords[2];
+                    r2 <<= 8;
+                    r2 = sub_80D8AE0(r2, 0x6400);
+                    r4 = r7->unk68.as_four_players.others[r8].unk4.as_hwords[3];
+                    r4 <<= 8;
+                    r4 = sub_80D8B68(r2, r4);
+                }
+                else
+                {
+                    r4 = 0;
+                }
+                break;
+            case 1:
+                if (r7->unk68.as_four_players.others[r8].unk4.as_hwords[3] != 0)
+                {
+                    r2 = r7->unk68.as_four_players.others[r8].unk4.as_hwords[4];
+                    r2 <<= 8;
+                    r2 = sub_80D8AE0(r2, 0x6400);
+                    r4 = r7->unk68.as_four_players.others[r8].unk4.as_hwords[3];
+                    r4 <<= 8;
+                    r4 = sub_80D8B68(r2, r4);
+                }
+                else
+                {
+                    r4 = 0;
+                }
+                break;
+            case 2:
+                if (r7->unk68.as_four_players.others[r8].unk4.as_hwords[3] == 0)
+                {
+                    r4 = 0;
+                }
+                else if (r7->unk68.as_four_players.others[r8].unk4.as_hwords[5] >= r7->unk28)
+                {
+                    r4 = 0x6400;
+                }
+                else
+                {
+                    r2 = r7->unk68.as_four_players.others[r8].unk4.as_hwords[5];
+                    r2 <<= 8;
+                    r2 = sub_80D8AE0(r2, 0x6400);
+                    r4 = r7->unk28;
+                    r4 <<= 8;
+                    r4 = sub_80D8B68(r2, r4);
+                }
+                break;
+            }
+            r4 >>= 4;
+            r7->unk68.as_four_players.unk00.unk0C[1][r8] = r4;
+        }
+        break;
+    case 4:
+        for (r6 = 0, r8 = 0; r8 < r7->unk9 - 1; ++r8)
+        {
+            for (r4_ = r7->unk9 - 1; r4_ > r8; --r4_)
+            {
+                u16 r0;
+                u8 r3;
+                u16 *sp00 = r7->unk68.as_four_players.unk00.unk0C[0];
+                u8 *sp04 = r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[0];
+                u8 *r10 = r7->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[1];
+                u16 *r9 = r7->unk68.as_four_players.unk00.unk0C[1];
+                s32 r12 = r4_ - 1;
+                u16 *p1 = sp00 + r12; // these have to be here
+                u16 *p2 = sp00 + r4_; // to swap operands. macro?
+
+                if (*p1 < *p2)
+                {
+                    r0 = sp00[r4_];
+                    sp00[r4_] = sp00[r12];
+                    sp00[r12] = r0;
+                    r3 = sp04[r4_];
+                    sp04[r4_] = sp04[r12];
+                    sp04[r12] = r3;
+                }
+                p1 = r9 + r12;
+                p2 = r9 + r4_;
+                if (*p1 < *p2)
+                {
+                    r0 = r9[r4_];
+                    r9[r4_] = r9[r12];
+                    r9[r12] = r0;
+                    r3 = r10[r4_];
+                    r10[r4_] = r10[r12];
+                    r10[r12] = r3;
+                }
+            }
+        }
+        SendBlock(
+            0,
+            &r7->unk68,
+            sizeof(struct BerryCrushGame_68_x_SubStruct)
+        );
+        break;
+    case 5:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r7->unk10 = 0;
+        break;
+    case 6:
+        if (GetBlockReceivedStatus() != 1)
+            return 0;
+        memset(
+            &r7->unk68,
+            0,
+            sizeof(struct BerryCrushGame_68_x_SubStruct)
+        );
+        memcpy(
+            &r7->unk68,
+            gBlockRecvBuffer,
+            sizeof(struct BerryCrushGame_68_x_SubStruct)
+        );
+        ResetBlockReceivedFlags();
+        r7->unk10 = 0;
+        break;
+    case 7:
+        sub_814B930();
+        sub_814BB4C(18, 1, NULL);
+        r7->unk12 = 11;
+        r7->unkC = 0;
+        r7->unk24 = 0;
+        return 0;
+    }
+    ++r7->unkC;
+    return 0;
+}
+
+static u32 sub_814CFA8(struct BerryCrushGame * r5, u8 *r6)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        if (!sub_814E644(r5, &r5->unk138))
+            return 0;
+        break;
+    case 1:
+        CopyBgTilemapBufferToVram(0);
+        r5->unk138.unk0 = 30;
+        break;
+    case 2:
+        if (r5->unk138.unk0 != 0)
+        {
+            --r5->unk138.unk0;
+            return 0;
+        }
+        if (!(gMain.newKeys & A_BUTTON))
+            return 0;
+        PlaySE(SE_SELECT);
+        sub_814E80C(r5);
+        break;
+    case 3:
+        if (r5->unk12 <= 12)
+        {
+            ++r5->unk12;
+            r5->unkC = 0;
+            return 0;
+        }
+        break;
+    case 4:
+        ConvertIntToDecimalStringN(gStringVar1, r5->unk1C, STR_CONV_MODE_LEFT_ALIGN, 6);
+        ConvertIntToDecimalStringN(gStringVar2, GetBerryPowder(), STR_CONV_MODE_LEFT_ALIGN, 6);
+        sub_814D5A4(r6, 2, 3, 0, 0);
+        r5->unkE = 19;
+        sub_814BB4C(3, 1, NULL);
+        r5->unkC = 0;
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D094(struct BerryCrushGame * r5, u8 *r4)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        if (r5->unk28 >= 36000)
+            sub_814EB04(&r5->unk138);
+        sub_814D5A4(r4, 8, 0, 0, 1);
+        r5->unkE = 19;
+        sub_814BB4C(3, 1, NULL);
+        r5->unkC = 0;
+        return 0;
+    case 1:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 2:
+        if (!IsLinkTaskFinished())
+            return 0;
+        DrawDialogueFrame(0, 0);
+        AddTextPrinterParameterized2(0, 2, gText_SavingDontTurnOffThePower2, 0, 0, 2, 1, 3);
+        CopyWindowToVram(0, 3);
+        CreateTask(sub_80DA634, 0);
+        break;
+    case 3:
+        if (FuncIsActiveTask(sub_80DA634))
+            return 0;
+        break;
+    case 4:
+        sub_814BB4C(20, 1, NULL);
+        r5->unk12 = 15;
+        r5->unkC = 0;
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D188(struct BerryCrushGame * r5, u8 *r6)
+{
+    s32 r4;
+#ifndef NONMATCHING
+    register s32 r0 asm("r0");
+#else
+    s32 r0;
+#endif
+
+    switch (r5->unkC)
+    {
+    case 0:
+        sub_814D5A4(r6, 4, 0, 0, 1);
+        r5->unkE = 20;
+        sub_814BB4C(3, 1, NULL);
+        r0 = 0;
+        r5->unkC = r0; // dunno what it's doing because it's already in case 0
+        return 0;
+    case 1:
+        DisplayYesNoMenuDefaultYes();
+        break;
+    case 2:
+        if ((r4 = Menu_ProcessInputNoWrapClearOnChoose()) != -2)
+        {
+            memset(r5->unk40.unk2, 0, sizeof(r5->unk40.unk2));
+            if (r4 == 0)
+            {
+                if (CheckHasAtLeastOneBerry())
+                    r5->unk14 = 0;
+                else
+                    r5->unk14 = 3;
+            }
+            else
+            {
+                r5->unk14 = 1;
+            }
+            ClearDialogWindowAndFrame(0, 1);
+            sub_814D5A4(r6, 8, 0, 0, 0);
+            r5->unkE = 21;
+            sub_814BB4C(3, 1, NULL);
+            r5->unkC = 0;
+        }
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D240(struct BerryCrushGame * r4, UNUSED u8 *r1)
+{
+    u8 r5 = 0;
+
+    switch (r4->unkC)
+    {
+    case 0:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r4->unk40.unk2[0] = r4->unk14;
+        r4->unk40.unkE.unk0 = 0;
+        SendBlock(0, r4->unk40.unk2, sizeof(u16));
+        break;
+    case 2:
+        if (!IsLinkTaskFinished())
+            return 0;
+        r4->unk10 = 0;
+        break;
+    case 3:
+        if (GetBlockReceivedStatus() != gUnknown_846E3C8[r4->unk9 - 2])
+            return 0;
+        for (; r5 < r4->unk9; ++r5)
+            r4->unk40.unkE.unk0 += gBlockRecvBuffer[r5][0];
+        if (r4->unk40.unkE.unk0 != 0)
+            sub_814BB4C(23, 1, NULL);
+        else
+            sub_814BB4C(22, 1, NULL);
+        ResetBlockReceivedFlags();
+        r4->unk40.unk2[0] = 0;
+        r4->unk40.unkE.unk0 = 0;
+        r4->unk10 = 0;
+        r4->unkC = 0;
+        return 0;
+    }
+    ++r4->unkC;
+    return 0;
+}
+
+static u32 sub_814D31C(struct BerryCrushGame * r5, UNUSED u8 *r1)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFFFFFF, 1, 0, 0x10, RGB_BLACK);
+        UpdatePaletteFade();
+        break;
+    case 1:
+        if (UpdatePaletteFade())
+            return 0;
+        break;
+    case 2:
+        ClearDialogWindowAndFrame(0, 1);
+        sub_814DA04(r5);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK);
+        UpdatePaletteFade();
+        break;
+    case 3:
+        if (UpdatePaletteFade())
+            return 0;
+        sub_814BB4C(7, 1, NULL);
+        r5->unk12 = 3;
+        r5->unkC = 0;
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D3A4(struct BerryCrushGame * r5, UNUSED u8 *r1)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        DrawDialogueFrame(0, 0);
+        if (r5->unk14 == 3)
+            AddTextPrinterParameterized2(0, 2, gUnknown_846E328[5], r5->unkB, 0, 2, 1, 3);
+        else
+            AddTextPrinterParameterized2(0, 2, gUnknown_846E328[6], r5->unkB, 0, 2, 1, 3);
+        CopyWindowToVram(0, 3);
+        break;
+    case 1:
+        if (IsTextPrinterActive(0))
+            return 0;
+        r5->unk138.unk0 = 120;
+        break;
+    case 2:
+        if (r5->unk138.unk0 != 0)
+            --r5->unk138.unk0;
+        else
+        {
+            sub_814BB4C(24, 1, NULL);
+            r5->unkC = 0;
+        }
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D468(struct BerryCrushGame * r5, UNUSED u8 *r1)
+{
+    switch (r5->unkC)
+    {
+    case 0:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        Link_TryStartSend5FFF();
+        break;
+    case 2:
+        if (gReceivedRemoteLinkPlayers != 0)
+            return 0;
+        r5->unkE = 25;
+        sub_814BB4C(5, 1, NULL);
+        r5->unkC = 2; // ???
+        return 0;
+    }
+    ++r5->unkC;
+    return 0;
+}
+
+static u32 sub_814D4C8(UNUSED struct BerryCrushGame * r0, UNUSED u8 *r1)
+{
+    sub_814B6FC(NULL);
+    return 0;
+}
+
+void sub_814D4D8(struct BerryCrushGame * r4)
+{
+    u8 r5 = 0;
+
+    IncrementGameStat(GAME_STAT_BERRY_CRUSH_POINTS);
+    r4->unkD = 0;
+    r4->unk10 = 0;
+    r4->unk12 = 2;
+    r4->unk14 = 0;
+    r4->unk1C = 0;
+    r4->unk18 = 0;
+    r4->unk1A = 0;
+    r4->unk20 = 0;
+    r4->unk24 = 0;
+    r4->unk25_0 = 0;
+    r4->unk25_1 = 0;
+    r4->unk25_2 = 0;
+    r4->unk25_3 = 0;
+    r4->unk25_4 = 0;
+    r4->unk25_5 = 0;
+    r4->unk26 = 0;
+    r4->unk28 = 0;
+    r4->unk2E = 0;
+    r4->unk32 = -1;
+    r4->unk30 = 0;
+    r4->unk34 = 0;
+    for (; r5 < 5; ++r5) // why is it 5 instead of 4? fillerBC isn't sufficient for one player
+    {
+        r4->unk68.as_four_players.others[r5].unk0 = -1;
+        r4->unk68.as_four_players.others[r5].unk2 = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[0] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[1] = 1;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[2] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[3] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[4] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_hwords[5] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_2d_bytes[1][4] = 0;
+        r4->unk68.as_four_players.others[r5].unk4.as_2d_bytes[1][5] = 0;
+    }
+}
+
+#ifdef NONMATCHING
+void sub_814D564(u8 *r0, u32 r1, s32 r2, u32 r3, u32 r5, u32 r6, u32 r4)
+{
+    u8 sp[8];
+    u8 *p;
+
+    1[(u32 *)sp] = r2;
+    0[(u16 *)sp] = r4;
+    p = &sp[4];
+    r0[0] = p[0];
+    r0[1] = p[1];
+    r0[2] = p[2];
+    r0[3] = p[3];
+    r0[4] = r3;
+    r0[5] = r5;
+    r0[6] = r6;
+    r0[7] = sp[0];
+    r0[8] = sp[1];
+    r0[9] = r1;
+}
+#else
+NAKED
+void sub_814D564(u8 *r0, u32 r1, s32 r2, u32 r3, u32 r5, u32 r6, u32 r4)
+{
+    asm_unified("\n\
+        push {r4-r6,lr}\n\
+        sub sp, 0x8\n\
+        str r2, [sp, 0x4]\n\
+        ldr r5, [sp, 0x18]\n\
+        ldr r6, [sp, 0x1C]\n\
+        ldr r4, [sp, 0x20]\n\
+        mov r2, sp\n\
+        strh r4, [r2]\n\
+        add r4, sp, 0x4\n\
+        ldrb r2, [r4]\n\
+        strb r2, [r0]\n\
+        ldrb r2, [r4, 0x1]\n\
+        strb r2, [r0, 0x1]\n\
+        ldrb r2, [r4, 0x2]\n\
+        strb r2, [r0, 0x2]\n\
+        ldrb r2, [r4, 0x3]\n\
+        strb r2, [r0, 0x3]\n\
+        strb r3, [r0, 0x4]\n\
+        strb r5, [r0, 0x5]\n\
+        strb r6, [r0, 0x6]\n\
+        mov r2, sp\n\
+        ldrb r2, [r2]\n\
+        strb r2, [r0, 0x7]\n\
+        mov r2, sp\n\
+        ldrb r2, [r2, 0x1]\n\
+        strb r2, [r0, 0x8]\n\
+        strb r1, [r0, 0x9]\n\
+        add sp, 0x8\n\
+        pop {r4-r6}\n\
+        pop {r0}\n\
+        bx r0");
+}
+#endif
+
+void sub_814D5A4(u8 *r0, u32 r1, u32 r2, u32 r3, u32 r5)
+{
+    u8 sp[4];
+
+    0[(u16 *)sp] = r3;
+    r0[0] = r1;
+    r0[1] = r2;
+    r0[2] = sp[0];
+    r0[3] = sp[1];
+    r0[4] = r5;
+}
diff --git a/src/berry_crush_3.c b/src/berry_crush_3.c
new file mode 100644
index 000000000..13f392fb4
--- /dev/null
+++ b/src/berry_crush_3.c
@@ -0,0 +1,1386 @@
+#include "global.h"
+#include "gflib.h"
+#include "battle_anim.h"
+#include "berry.h"
+#include "berry_crush.h"
+#include "decompress.h"
+#include "digit_obj_util.h"
+#include "dynamic_placeholder_text_util.h"
+#include "graphics.h"
+#include "item_menu_icons.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "math_util.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "scanline_effect.h"
+#include "script.h"
+#include "strings.h"
+#include "text_window.h"
+#include "trig.h"
+#include "constants/items.h"
+#include "constants/songs.h"
+
+static void sub_814DEC0(struct BerryCrushGame_138 * arg0, u16 arg1);
+static void sub_814DF44(u8 windowId, u8 left, u8 colorId, const u8 *string);
+static void sub_814DFA4(struct BerryCrushGame * sp0C, u8 sp10, u8 sp14, u8 r3);
+static void sub_814E32C(struct BerryCrushGame * r8);
+static void Task_ShowBerryCrushRankings(u8 r4);
+static void sub_814EAD4(struct BerryCrushGame_138 * r4, u16 r1);
+static void sub_814EB38(struct BerryCrushGame * r5);
+static void sub_814EBB0(struct BerryCrushGame * r6);
+static void sub_814EC80(struct BerryCrushGame * r6);
+static void sub_814ECE0(struct BerryCrushGame * r6);
+static void sub_814EF10(struct BerryCrushGame * r5);
+static void sub_814EFD0(struct Sprite * sprite);
+static void sub_814EFFC(struct Sprite * sprite);
+static void sub_814F044(struct Sprite * sprite);
+static void sub_814F0D8(struct Sprite * sprite);
+
+static const struct BgTemplate gUnknown_846E3CC[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 15,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x0000
+    }, {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 13,
+        .screenSize = 2,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0x0000
+    }, {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 12,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0x0000
+    }, {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 11,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x0000
+    }
+};
+
+static const u8 sBerryCrushTextColorTable[][3] = {
+    {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_DARK_GREY,
+        TEXT_COLOR_LIGHT_GREY
+    }, {
+        TEXT_COLOR_TRANSPARENT,
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_DARK_GREY
+    }, {
+        TEXT_COLOR_TRANSPARENT,
+        TEXT_COLOR_LIGHT_GREY,
+        TEXT_COLOR_RED
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_BLUE,
+        TEXT_COLOR_LIGHT_BLUE
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_GREEN,
+        TEXT_COLOR_LIGHT_GREEN
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_RED,
+        TEXT_COLOR_LIGHT_RED
+    }
+};
+
+static const struct WindowTemplate gUnknown_846E3F0 = {
+    .bg = 0,
+    .tilemapLeft = 3,
+    .tilemapTop = 4,
+    .width = 24,
+    .height = 13,
+    .paletteNum = 0xF,
+    .baseBlock = 0x001
+};
+
+static const struct WindowTemplate gUnknown_846E3F8[] = {
+    {
+        .bg = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 0,
+        .width = 9,
+        .height = 2,
+        .paletteNum = 0x8,
+        .baseBlock = 0x3ed
+    }, {
+        .bg = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 3,
+        .width = 9,
+        .height = 2,
+        .paletteNum = 0x8,
+        .baseBlock = 0x3db
+    }, {
+        .bg = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 6,
+        .width = 9,
+        .height = 2,
+        .paletteNum = 0x8,
+        .baseBlock = 0x3c9
+    }, {
+        .bg = 0,
+        .tilemapLeft = 21,
+        .tilemapTop = 3,
+        .width = 9,
+        .height = 2,
+        .paletteNum = 0x8,
+        .baseBlock = 0x3b7
+    }, {
+        .bg = 0,
+        .tilemapLeft = 21,
+        .tilemapTop = 6,
+        .width = 9,
+        .height = 2,
+        .paletteNum = 0x8,
+        .baseBlock = 0x3a5
+    }, DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate gUnknown_846E428[] = {
+    {
+        .bg = 0,
+        .tilemapLeft = 4,
+        .tilemapTop = 2,
+        .width = 22,
+        .height = 16,
+        .paletteNum = 0xF,
+	    .baseBlock = 0x001
+    }, {
+        .bg = 0,
+        .tilemapLeft = 4,
+        .tilemapTop = 2,
+        .width = 22,
+        .height = 16,
+        .paletteNum = 0xF,
+	    .baseBlock = 0x001
+    }, {
+        .bg = 0,
+        .tilemapLeft = 3,
+        .tilemapTop = 2,
+        .width = 24,
+        .height = 16,
+        .paletteNum = 0xF,
+	    .baseBlock = 0x001
+    }, DUMMY_WIN_TEMPLATE
+};
+
+static const u8 gUnknown_846E448[][4] = {
+    {  6,  8,  9, 11 },
+    { 12, 14, 15, 16}
+};
+
+static const u32 gUnknown_846E450[] = {
+    50000000, 
+    25000000, 
+    12500000, 
+     6250000, 
+     3125000, 
+     1562500, 
+      781250, 
+      390625
+};
+
+static const u16 gUnknown_846E470[] = INCBIN_U16("graphics/link_games/unk_846E4D0.gbapal");
+static const u16 gUnknown_846E490[] = INCBIN_U16("graphics/link_games/unk_846E7FC.gbapal");
+static const u16 gUnknown_846E4B0[] = INCBIN_U16("graphics/link_games/unk_846ECC4.gbapal");
+
+static const u32 gUnknown_846E4D0[] = INCBIN_U32("graphics/link_games/unk_846E4D0.4bpp.lz");
+static const u32 gUnknown_846E7FC[] = INCBIN_U32("graphics/link_games/unk_846E7FC.4bpp.lz");
+static const u32 gUnknown_846EB78[] = INCBIN_U32("graphics/link_games/unk_846EB78.4bpp.lz");
+static const u32 gUnknown_846ECC4[] = INCBIN_U32("graphics/link_games/unk_846ECC4.4bpp.lz");
+
+static const u32 gBerryCrushGrinderTopTilemap[] = INCBIN_U32("graphics/link_games/unk_846ED90.bin.lz");
+static const u32 gBerryCrushContainerCapTilemap[] = INCBIN_U32("graphics/link_games/unk_846EEC0.bin.lz");
+static const u32 gBerryCrushBackgroundTilemap[] = INCBIN_U32("graphics/link_games/unk_846F058.bin.lz");
+
+static const u8 gUnknown_846F280[][5] = {
+    {1, 3},
+    {0, 1, 3},
+    {1, 3, 2, 4},
+    {0, 1, 3, 2, 4}
+};
+
+static const struct BerryCrushGame_138_C gUnknown_846F294[] = {
+    {0x00, 0x00, 0x00, 0x0000, 0xfff0, 0x0000, 0x0000},
+    {0x01, 0x00, 0x03, 0xffe4, 0xfffc, 0xffe8, 0x0010},
+    {0x02, 0x00, 0x06, 0xfff0, 0x0014, 0xfff8, 0x0010},
+    {0x03, 0x14, 0x03, 0x001c, 0xfffc, 0x0020, 0xfff8},
+    {0x04, 0x14, 0x06, 0x0010, 0x0014, 0x0010, 0xfff8}
+};
+
+static const s8 gUnknown_846F2D0[][2] = {
+    {0x00, 0x00},
+    {0xff, 0x00},
+    {0x01, 0x01}
+};
+
+static const s8 gUnknown_846F2D6[][2] = {
+    {0x00, 0x00},
+    {0xf0, 0xfc},
+    {0x10, 0xfc},
+    {0xf8, 0xfe},
+    {0x08, 0xfe},
+    {0xe8, 0xf8},
+    {0x18, 0xf8},
+    {0xe0, 0xf4},
+    {0x20, 0xf4},
+    {0xd8, 0xf0},
+    {0x28, 0xf0}
+};
+
+static const u16 gUnknown_846F2EC[] = {
+    5, 6, 7, 8, 9
+};
+
+static const struct CompressedSpriteSheet gUnknown_846F2F8[] = {
+    {gUnknown_846E4D0, 0x0800, 1},
+    {gUnknown_846E7FC, 0x0e00, 2},
+    {gUnknown_846EB78, 0x0700, 3},
+    {gUnknown_846ECC4, 0x02c0, 4},
+    {}
+};
+
+static const struct SpritePalette gUnknown_846F320[] = {
+    {gUnknown_846E470, 1},
+    {gUnknown_846E490, 2},
+    {gUnknown_846E4B0, 4},
+    {}
+};
+
+static const union AnimCmd gUnknown_846F340[] = {
+    ANIMCMD_FRAME(0x00, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846F348[] = {
+    ANIMCMD_FRAME(0x00, 4),
+    ANIMCMD_FRAME(0x10, 4),
+    ANIMCMD_FRAME(0x20, 4),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846F358[] = {
+    ANIMCMD_FRAME(0x30, 2),
+    ANIMCMD_FRAME(0x40, 2),
+    ANIMCMD_FRAME(0x50, 2),
+    ANIMCMD_FRAME(0x60, 2),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846F36C[] = {
+    ANIMCMD_FRAME(0x00, 2),
+    ANIMCMD_FRAME(0x04, 2),
+    ANIMCMD_FRAME(0x08, 2),
+    ANIMCMD_FRAME(0x0c, 2),
+    ANIMCMD_FRAME(0x10, 2),
+    ANIMCMD_FRAME(0x14, 2),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd gUnknown_846F388[] = {
+    ANIMCMD_FRAME(0x18, 4),
+    ANIMCMD_FRAME(0x1c, 4),
+    ANIMCMD_FRAME(0x20, 4),
+    ANIMCMD_FRAME(0x24, 4),
+    ANIMCMD_FRAME(0x28, 4),
+    ANIMCMD_FRAME(0x2c, 4),
+    ANIMCMD_FRAME(0x30, 4),
+    ANIMCMD_FRAME(0x34, 4),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd gUnknown_846F3AC[] = {
+    ANIMCMD_FRAME(0x14, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846F3B4[] = {
+    ANIMCMD_FRAME(0x00, 0),
+    ANIMCMD_END
+};
+
+static const union AffineAnimCmd gUnknown_846F3BC[] = {
+    AFFINEANIMCMD_FRAME(256, 256, 0, 0),
+    AFFINEANIMCMD_FRAME(0, 0, 2, 1),
+    AFFINEANIMCMD_JUMP(1)
+};
+
+static const union AffineAnimCmd gUnknown_846F3D4[] = {
+    AFFINEANIMCMD_FRAME(256, 256, 0, 0),
+    AFFINEANIMCMD_FRAME(0, 0, -2, 1),
+    AFFINEANIMCMD_JUMP(1)
+};
+
+static const union AnimCmd *const gUnknown_846F3EC[] = {
+    gUnknown_846F340
+};
+
+static const union AnimCmd *const gUnknown_846F3F0[] = {
+    gUnknown_846F348,
+    gUnknown_846F358
+};
+
+static const union AnimCmd *const gUnknown_846F3F8[] = {
+    gUnknown_846F36C,
+    gUnknown_846F388
+};
+
+static const union AnimCmd *const gUnknown_846F400[] = {
+    gUnknown_846F3AC
+};
+
+static const union AnimCmd *const gUnknown_846F404[] = {
+    gUnknown_846F3B4
+};
+
+static const union AffineAnimCmd *const gUnknown_846F408[] = {
+    gUnknown_846F3BC,
+    gUnknown_846F3D4
+};
+
+
+static const struct SpriteTemplate gUnknown_846F410 = {
+    .tileTag = 1,
+    .paletteTag = 1,
+    .oam = &gOamData_AffineOff_ObjNormal_64x64,
+    .anims = gUnknown_846F3EC,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_846F428 = {
+    .tileTag = 2,
+    .paletteTag = 2,
+    .oam = &gOamData_AffineOff_ObjNormal_32x32,
+    .anims = gUnknown_846F3F0,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_814EFD0
+};
+
+static const struct SpriteTemplate gUnknown_846F440 = {
+    .tileTag = 3,
+    .paletteTag = 2,
+    .oam = &gOamData_AffineOff_ObjNormal_16x16,
+    .anims = gUnknown_846F3F8,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_846F458 = {
+    .tileTag = 4,
+    .paletteTag = 4,
+    .oam = &gOamData_AffineOff_ObjNormal_8x16,
+    .anims = gUnknown_846F400,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_846F470 = {
+    .tileTag = 5,
+    .paletteTag = 5,
+    .oam = &gOamData_AffineDouble_ObjNormal_32x32,
+    .anims = gUnknown_846F404,
+    .affineAnims = gUnknown_846F408,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct DigitObjUtilTemplate gUnknown_846F488[] = {
+    {
+        .strConvMode = 1,
+        .shape = SPRITE_SHAPE(8x16),
+        .size = SPRITE_SIZE(8x16),
+        .priority = 0,
+        .oamCount = 2,
+        .xDelta = 8,
+        .x = 156,
+        .y = 0,
+        .spriteSheet = {.compressed = &gUnknown_846F2F8[3]},
+        .spritePal = &gUnknown_846F320[2],
+    }, {
+        .strConvMode = 0,
+        .shape = SPRITE_SHAPE(8x16),
+        .size = SPRITE_SIZE(8x16),
+        .priority = 0,
+        .oamCount = 2,
+        .xDelta = 8,
+        .x = 180,
+        .y = 0,
+        .spriteSheet = {.compressed = &gUnknown_846F2F8[3]},
+        .spritePal = &gUnknown_846F320[2],
+    }, {
+        .strConvMode = 0,
+        .shape = SPRITE_SHAPE(8x16),
+        .size = SPRITE_SIZE(8x16),
+        .priority = 0,
+        .oamCount = 2,
+        .xDelta = 8,
+        .x = 204,
+        .y = 0,
+        .spriteSheet = {.compressed = &gUnknown_846F2F8[3]},
+        .spritePal = &gUnknown_846F320[2],
+    }
+};
+
+static const u8 *const gUnknown_846F4B8[] = {
+    gText_SpaceTimes,
+    gText_XDotY,
+    gText_StrVar1Berry,
+    gText_NeatnessRankings,
+    gText_CooperativeRankings,
+    gText_PressingPowerRankings
+};
+
+int sub_814D5C8(void)
+{
+    struct BerryCrushGame * var0 = sub_814B6F0();
+    if (!var0)
+        return -1;
+
+    switch (var0->unkC)
+    {
+    case 0:
+        SetVBlankCallback(NULL);
+        SetHBlankCallback(NULL);
+        SetGpuReg(REG_OFFSET_DISPCNT, 0);
+        ScanlineEffect_Stop();
+        ResetTempTileDataBuffers();
+        break;
+    case 1:
+        CpuFill16(0, (void *)OAM, OAM_SIZE);
+        gReservedSpritePaletteCount = 0;
+        DigitObjUtil_Init(3);
+        break;
+    case 2:
+        ResetPaletteFade();
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        break;
+    case 3:
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, gUnknown_846E3CC, NELEMS(gUnknown_846E3CC));
+        SetBgTilemapBuffer(1, var0->unk1C0);
+        SetBgTilemapBuffer(2, var0->unk21C0);
+        SetBgTilemapBuffer(3, var0->unk31C0);
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgX(2, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        break;
+    case 4:
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
+        FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 64);
+        FillBgTilemapBufferRect_Palette0(2, 0, 0, 0, 32, 32);
+        FillBgTilemapBufferRect_Palette0(3, 0, 0, 0, 32, 32);
+        break;
+    case 5:
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(3);
+        DecompressAndCopyTileDataToVram(1, gUnknown_8EAFFC0, 0, 0, 0);
+        break;
+    case 6:
+        if (FreeTempTileDataBuffersIfPossible())
+            return 0;
+
+        InitStandardTextBoxWindows();
+        ResetBg0();
+        sub_814EB38(var0);
+        sub_814EBB0(var0);
+        gPaletteFade.bufferTransferDisabled = TRUE;
+        break;
+    case 7:
+        LoadPalette(gUnknown_8EAFEA0, 0, 0x180);
+        CopyToBgTilemapBuffer(1, gBerryCrushGrinderTopTilemap, 0, 0);
+        CopyToBgTilemapBuffer(2, gBerryCrushContainerCapTilemap, 0, 0);
+        CopyToBgTilemapBuffer(3, gBerryCrushBackgroundTilemap, 0, 0);
+        sub_814EC80(var0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 8:
+        LoadWirelessStatusIndicatorSpriteGfx();
+        CreateWirelessStatusIndicatorSprite(0,  0);
+        sub_814ECE0(var0);
+        SetGpuReg(REG_OFFSET_BG1VOFS, -gSpriteCoordOffsetY);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        break;
+    case 9:
+        gPaletteFade.bufferTransferDisabled = FALSE;
+        BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(2);
+        ShowBg(3);
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+        sub_814B914();
+        var0->unkC = 0;
+        return 1;
+    }
+
+    var0->unkC++;
+    return 0;
+}
+
+int sub_814D888(void)
+{
+    struct BerryCrushGame * var0 = sub_814B6F0();
+    if (!var0)
+        return -1;
+
+    switch (var0->unkC)
+    {
+    case 0:
+        LinkRfu_SetRfuFuncToSend6600();
+        break;
+    case 1:
+        if (!IsLinkTaskFinished())
+            return 0;
+        // fall through. The original author forgot to use "break" here
+        // because this will call BeginNormalPaletteFade() twice.
+    case 2:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        UpdatePaletteFade();
+        break;
+    case 3:
+        if (UpdatePaletteFade())
+            return 0;
+        break;
+    case 4:
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
+        FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 32);
+        FillBgTilemapBufferRect_Palette0(2, 0, 0, 0, 32, 32);
+        FillBgTilemapBufferRect_Palette0(3, 0, 0, 0, 32, 32);
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 5:
+        FreeAllWindowBuffers();
+        HideBg(0);
+        UnsetBgTilemapBuffer(0);
+        HideBg(1);
+        UnsetBgTilemapBuffer(1);
+        HideBg(2);
+        UnsetBgTilemapBuffer(2);
+        HideBg(3);
+        UnsetBgTilemapBuffer(3);
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+        break;
+    case 6:
+        DestroyWirelessStatusIndicatorSprite();
+        sub_814EF10(var0);
+        DigitObjUtil_Teardown();
+        break;
+    case 7:
+        var0->unkC = 0;
+        return 1;
+    }
+
+    var0->unkC++;
+    return 0;
+}
+
+int sub_814D9CC(struct BerryCrushGame * arg0)
+{
+    gSpriteCoordOffsetY = arg0->unk2A + arg0->unk2C;
+    SetGpuReg(REG_OFFSET_BG1VOFS, -gSpriteCoordOffsetY);
+    if (arg0->unk12 == 7)
+    {
+        sub_814EAD4(&arg0->unk138, arg0->unk28);
+    }
+
+    return 0;
+}
+
+void sub_814DA04(struct BerryCrushGame * arg0)
+{
+    arg0->unk2A = -104;
+    arg0->unk2C = 0;
+    gSpriteCoordOffsetX = 0;
+    gSpriteCoordOffsetY = -104;
+}
+
+void sub_814DA24(struct BerryCrushGame * arg0, struct BerryCrushGame_138 * arg1)
+{
+    u8 i;
+    u8 spriteId;
+    s16 var0, var1;
+    s16 *data;
+    int var3;
+    s16 var5;
+    u32 var6;
+
+    for (i = 0; i < arg0->unk9; i++)
+    {
+        spriteId = AddItemIconObjectWithCustomObjectTemplate(
+            &gUnknown_846F470,
+            gUnknown_846F2EC[i],
+            gUnknown_846F2EC[i],
+            arg0->unk68.as_four_players.others[i].unk0 + FIRST_BERRY_INDEX);
+        arg1->unk38[i] = &gSprites[spriteId];
+        arg1->unk38[i]->oam.priority = 3;
+        arg1->unk38[i]->affineAnimPaused = TRUE;
+        arg1->unk38[i]->pos1.x = arg1->unkC[i]->unk8 + 120;
+        arg1->unk38[i]->pos1.y = -16;
+        data = arg1->unk38[i]->data;
+        var5 = 512;
+        data[1] = var5;
+        data[2] = 32;
+        data[7] = 112;
+        var0 = arg1->unkC[i]->unkA - arg1->unkC[i]->unk8;
+        var3 = var0;
+        if (var0 < 0)
+            var3 += 3;
+
+        data[6] = var3 >> 2;
+        var0 *= 128;
+        var6 = var5 + 32;
+        var6 = var6 / 2;
+        var1 = sub_80D8B40(7, 0x3F80, var6);
+        data[0] = (u16)arg1->unk38[i]->pos1.x * 128;
+        data[3] = sub_80D8B40(7, var0, var1);
+        var1 = sub_80D8ABC(7, var1, 85);
+        data[4] = 0;
+        data[5] = sub_80D8B40(7, 0x3F80, var1);
+        data[7] |= 0x8000;
+        if (arg1->unkC[i]->unk8 < 0)
+            StartSpriteAffineAnim(arg1->unk38[i], 1);
+    }
+}
+
+void sub_814DB84(struct Sprite * sprite)
+{
+    s16 *data = sprite->data;
+
+    data[1] += data[2];
+    sprite->pos2.y += data[1] >> 8;
+    if (data[7] & 0x8000)
+    {
+        sprite->data[0] += data[3];
+        data[4] += data[5];
+        sprite->pos2.x = Sin(data[4] >> 7, data[6]);
+        if ((data[7] & 0x8000) && (data[4] >> 7) > 126)
+        {
+            sprite->pos2.x = 0;
+            data[7] &= 0x7FFF;
+        }
+    }
+
+    sprite->pos1.x = data[0] >> 7;
+    if (sprite->pos1.y + sprite->pos2.y >= (data[7] & 0x7FFF))
+    {
+        sprite->callback = SpriteCallbackDummy;
+        FreeSpriteOamMatrix(sprite);
+        DestroySprite(sprite);
+    }
+}
+
+void sub_814DC24(struct BerryCrushGame * arg0, UNUSED struct BerryCrushGame_138 * arg1)
+{
+    u8 i;
+    for (i = 0; i < arg0->unk9; i++)
+    {
+        FreeSpritePaletteByTag(gUnknown_846F2EC[i]);
+        FreeSpriteTilesByTag(gUnknown_846F2EC[i]);
+    }
+}
+
+void sub_814DC5C(struct BerryCrushGame * arg0, struct BerryCrushGame_138 * arg1)
+{
+    u8 sp4;
+    struct BerryCrushGame_4E * var4E;
+    u8 i;
+    u16 var, var2;
+
+    sp4 = 0;
+    var4E = &arg0->unk40.unkE;
+    for (i = 0; i < arg0->unk9; i++)
+    {
+        var = var4E->unkA >> (i * 3);
+        var &= 7;
+        if (var)
+        {
+            sp4++;
+            if (var & 0x4)
+                StartSpriteAnim(arg1->unk24[i], 1);
+            else
+                StartSpriteAnim(arg1->unk24[i], 0);
+
+            arg1->unk24[i]->invisible = FALSE;
+            arg1->unk24[i]->animPaused = FALSE;
+            arg1->unk24[i]->pos2.x = gUnknown_846F2D0[(var % 4) - 1][0];
+            arg1->unk24[i]->pos2.y = gUnknown_846F2D0[(var % 4) - 1][1];
+        }
+    }
+
+    if (sp4 == 0)
+    {
+        arg0->unk25_2 = 0;
+    }
+    else
+    {
+        var = (u8)(arg0->unk28 % 3);
+        var2 = var;
+        for (i = 0; i < var4E->unkC * 2 + 3; i++)
+        {
+            if (arg1->unk4C[i]->invisible)
+            {
+                arg1->unk4C[i]->callback = sub_814F0D8;
+                arg1->unk4C[i]->pos1.x = gUnknown_846F2D6[i][0] + 120;
+                arg1->unk4C[i]->pos1.y = gUnknown_846F2D6[i][1] + 136 - (var * 4);
+                arg1->unk4C[i]->pos2.x = gUnknown_846F2D6[i][0] + (gUnknown_846F2D6[i][0] / (var2 * 4));
+                arg1->unk4C[i]->pos2.y = gUnknown_846F2D6[i][1];
+                if (var4E->unk4_1)
+                    StartSpriteAnim(arg1->unk4C[i], 1);
+                else
+                    StartSpriteAnim(arg1->unk4C[i], 0);
+
+                var++;
+                if (var > 3)
+                    var = 0;
+            }
+        }
+
+        if (arg0->unk25_2)
+        {
+            arg0->unk25_2 = 0;
+        }
+        else
+        {
+            if (sp4 == 1)
+                PlaySE(SE_TOY_DANGO);
+            else
+                PlaySE(SE_TOY_KABE);
+
+            arg0->unk25_2 = 1;
+        }
+    }
+}
+
+bool32 sub_814DE50(struct BerryCrushGame * arg0, struct BerryCrushGame_138 * arg1)
+{
+    u8 i;
+
+    for (i = 0; i < arg0->unk9; i++)
+    {
+        if (!arg1->unk24[i]->invisible)
+            return FALSE;
+    }
+
+    for (i = 0; i < 11; i++)
+    {
+        if (!arg1->unk4C[i]->invisible)
+            return FALSE;
+    }
+
+    if (arg0->unk2C != 0)
+        arg0->unk2C = 0;
+
+    return TRUE;
+}
+
+static void sub_814DEC0(struct BerryCrushGame_138 * arg0, u16 arg1)
+{
+    u8 i = 0;
+    u32 r7 = 0;
+    s16 r3 = 0;
+
+    arg0->unk4 = arg1 / 3600;
+    arg0->unk6 = (arg1 % 3600) / 60;
+    r3 = sub_80D8AA0((arg1 % 60) << 8, 4);
+
+    for (i = 0; i < 8; i++)
+    {
+        if ((r3 >> (7 - i)) & 1)
+            r7 += gUnknown_846E450[i];
+    }
+
+    arg0->unk8 = r7 / 1000000;
+}
+
+static void sub_814DF44(u8 windowId, u8 left, u8 colorId, const u8 *string)
+{
+    left = (left * 4) - (GetStringWidth(2, string, -1) / 2u);
+    AddTextPrinterParameterized3(windowId, 2, left, 0, sBerryCrushTextColorTable[colorId], 0, string);
+}
+
+static void sub_814DFA4(struct BerryCrushGame * sp0C, u8 sp10, u8 sp14, u8 sp18)
+{
+    u8 r8 = 0;
+    u8 sp1C = 0;
+    u8 sp20 = 0;
+    u8 r2;
+    s32 r3;
+    u8 r7;
+    union BerryCrushGame_68 * sp24 = &sp0C->unk68;
+    s32 sp30;
+
+    for (; r8 < sp0C->unk9; r8++)
+    {
+        DynamicPlaceholderTextUtil_Reset();
+        switch (sp10)
+        {
+        case 0:
+            sp1C = sp24->as_five_players.unk1C[0].unk4.as_2d_bytes[sp10][r8];
+            if (r8 != 0 && sp24->as_four_players.unk00.unk0C[sp10][r8] != sp24->as_four_players.unk00.unk0C[sp10][r8 - 1])
+            {
+                sp20 = r8;
+            }
+            ConvertIntToDecimalStringN(gStringVar1, sp24->as_four_players.unk00.unk0C[sp10][r8], STR_CONV_MODE_RIGHT_ALIGN, 4);
+            r7 = sp14 - GetStringWidth(2, gUnknown_846F4B8[sp10], -1) - 4;
+            AddTextPrinterParameterized3(sp0C->unk138.unk82, 2, r7, sp18 + 14 * r8, sBerryCrushTextColorTable[0], 0, gUnknown_846F4B8[sp10]);
+            AddTextPrinterParameterized3(sp0C->unk138.unk82, 2, r7 - 24, sp18 + 14 * r8, sBerryCrushTextColorTable[0], 0, gStringVar1);
+            break;
+        case 1:
+            sp1C = sp24->as_five_players.unk1C[0].unk4.as_2d_bytes[sp10][r8];
+            if (r8 != 0 && sp24->as_four_players.unk00.unk0C[sp10][r8] != sp24->as_four_players.unk00.unk0C[sp10][r8 - 1])
+            {
+                sp20 = r8;
+            }
+            ConvertIntToDecimalStringN(gStringVar1, sp24->as_four_players.unk00.unk0C[sp10][r8] >> 4, STR_CONV_MODE_RIGHT_ALIGN, 3);
+            r3 = 0;
+            r7 = sp24->as_four_players.unk00.unk0C[sp10][r8] & 15;
+            for (r2 = 0; r2 < 4; r2++)
+            {
+                if ((r7 >> (3 - r2)) & 1)
+                    r3 += gUnknown_846E450[r2];
+            }
+            r7 = r3 / 1000000u;
+            ConvertIntToDecimalStringN(gStringVar2, r7, STR_CONV_MODE_LEADING_ZEROS, 2);
+            StringExpandPlaceholders(gStringVar4, gUnknown_846F4B8[sp10]);
+            sp30 = sp14 - 4;
+            AddTextPrinterParameterized3(sp0C->unk138.unk82, 2, sp30 - GetStringWidth(2, gStringVar4, 0), sp18 + 14 * r8, sBerryCrushTextColorTable[0], 0, gStringVar4);
+            break;
+        case 2:
+            sp1C = r8;
+            sp20 = r8;
+            r2 = sp0C->unk68.as_five_players.unk1C[r8].unk14[12];
+            if (r2 >= LAST_BERRY_INDEX - FIRST_BERRY_INDEX + 2)
+                r2 = 0;
+            StringCopy(gStringVar1, gBerries[r2].name);
+            StringExpandPlaceholders(gStringVar4, gUnknown_846F4B8[sp10]);
+            AddTextPrinterParameterized3(sp0C->unk138.unk82, 2, sp14 - GetStringWidth(2, gStringVar4, -1) - 4, sp18 + 14 * r8, sBerryCrushTextColorTable[0], 0, gStringVar4);
+            break;
+        }
+        if (sp1C == sp0C->unk8)
+            StringCopy(gStringVar3, gText_1_ClrLtGryShdwBlk_Dynamic0);
+        else
+            StringCopy(gStringVar3, gText_1_Dynamic0);
+        gStringVar3[0] = sp20 + CHAR_1;
+        DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, PLAYER_UNK14(sp0C, sp1C));
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gStringVar3);
+        AddTextPrinterParameterized3(sp0C->unk138.unk82, 2, 4, sp18 + 14 * r8, sBerryCrushTextColorTable[0], 0, gStringVar4);
+    }
+}
+
+static void sub_814E32C(struct BerryCrushGame * r8)
+{
+    u8 r10 = 0;
+    u8 r6 = 0;
+    u32 sp0C = 0;
+    union BerryCrushGame_68 *sp10 = &r8->unk68;
+    u8 r7 = GetWindowAttribute(r8->unk138.unk82, WINDOW_HEIGHT) * 8 - 42;
+
+    sub_814DEC0(&r8->unk138, sp10->as_four_players.unk00.unk04);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, 2, r7, sBerryCrushTextColorTable[0], 0, gText_TimeColon);
+
+    r6 = 190 - (u8)GetStringWidth(2, gText_SpaceSec, 0);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gText_SpaceSec);
+
+    r6 -= 32;
+    ConvertIntToDecimalStringN(gStringVar1, r8->unk138.unk6, STR_CONV_MODE_LEADING_ZEROS, 2);
+    ConvertIntToDecimalStringN(gStringVar2, r8->unk138.unk8, STR_CONV_MODE_LEADING_ZEROS, 2);
+    StringExpandPlaceholders(gStringVar4, gText_XDotY2);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gStringVar4);
+
+    r6 -= (u8)GetStringWidth(2, gText_SpaceMin, 0) + 3;
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gText_SpaceMin);
+
+    r6 -= 9;
+    ConvertIntToDecimalStringN(gStringVar1, r8->unk138.unk4, STR_CONV_MODE_LEADING_ZEROS, 1);
+    StringExpandPlaceholders(gStringVar4, gText_StrVar1);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gStringVar4);
+
+    r7 += 14;
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, 2, r7, sBerryCrushTextColorTable[0], 0, gText_PressingSpeed);
+
+    r6 = 190 - (u8)GetStringWidth(2, gText_TimesPerSec, 0);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 3, r6, r7, sBerryCrushTextColorTable[0], 0, gText_TimesPerSec);
+
+    for (r10 = 0; r10 < 8; ++r10)
+        if (((u8)r8->unk16 >> (7 - r10)) & 1)
+            sp0C += *(r10 + gUnknown_846E450); // It's accessed in a different way here for unknown reason
+    ConvertIntToDecimalStringN(gStringVar1, r8->unk16 >> 8, STR_CONV_MODE_RIGHT_ALIGN, 3);
+    ConvertIntToDecimalStringN(gStringVar2, sp0C / 1000000, STR_CONV_MODE_LEADING_ZEROS, 2);
+    StringExpandPlaceholders(gStringVar4, gText_XDotY3);
+    r6 -= 38;
+    if (r8->unk25_1)
+        AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[5], 0, gStringVar4);
+    else
+        AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gStringVar4);
+
+    r7 += 14;
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, 2, r7, sBerryCrushTextColorTable[0], 0, gText_Silkiness);
+
+    ConvertIntToDecimalStringN(gStringVar1, sp10->as_four_players.unk00.unk08, STR_CONV_MODE_RIGHT_ALIGN, 3);
+    StringExpandPlaceholders(gStringVar4, gText_Var1Percent);
+    r6 = 190 - (u8)GetStringWidth(2, gStringVar4, 0);
+    AddTextPrinterParameterized3(r8->unk138.unk82, 2, r6, r7, sBerryCrushTextColorTable[0], 0, gStringVar4);
+}
+
+bool32 sub_814E644(struct BerryCrushGame * r4, struct BerryCrushGame_138 * r6)
+{
+    u8 r5;
+    struct WindowTemplate template;
+
+    switch (r6->unk80)
+    {
+    case 0:
+        r5 = r4->unk9 - 2;
+        sub_814EB04(r6);
+        memcpy(&template, &gUnknown_846E428[r4->unk12 - 11], sizeof(struct WindowTemplate));
+        if (r4->unk12 == 13)
+            template.height = gUnknown_846E448[1][r5];
+        else
+            template.height = gUnknown_846E448[0][r5];
+        r6->unk82 = AddWindow(&template);
+        break;
+    case 1:
+        PutWindowTilemap(r6->unk82);
+        FillWindowPixelBuffer(r6->unk82, PIXEL_FILL(0));
+        break;
+    case 2:
+        TextWindow_SetStdFrame0_WithPal(r6->unk82, 0x21D, 0xD0);
+        DrawStdFrameWithCustomTileAndPalette(r6->unk82, 0, 541, 13);
+        break;
+    case 3:
+        r5 = r4->unk9 - 2;
+        switch (r4->unk12)
+        {
+        case 11:
+            sub_814DF44(r6->unk82, 22, 3, gText_PressesRankings);
+            sub_814DFA4(r4, 0, 0xB0, 8 * gUnknown_846E448[0][r5] - r4->unk9 * 14);
+            r6->unk80 = 5;
+            return FALSE;
+        case 12:
+            sub_814DF44(r6->unk82, 22, 4, gUnknown_846F4B8[r4->unk68.as_five_players.unk1C[0].unk4.as_2d_bytes[0][7] + 3]);
+            sub_814DFA4(r4, 1, 0xB0, 8 * gUnknown_846E448[0][r5] - r4->unk9 * 14);
+            r6->unk80 = 5;
+            return FALSE;
+        case 13:
+            sub_814DF44(r6->unk82, 24, 3, gText_CrushingResults);
+            sub_814DFA4(r4, 2, 0xC0, 0x10);
+            break;
+        }
+        break;
+    case 4:
+        sub_814E32C(r4);
+        break;
+    case 5:
+        CopyWindowToVram(r6->unk82, 3);
+        r6->unk80 = 0;
+        return TRUE;
+    }
+    ++r6->unk80;
+    return FALSE;
+}
+
+void sub_814E80C(struct BerryCrushGame * r4)
+{
+    ClearStdWindowAndFrameToTransparent(r4->unk138.unk82, 1);
+    RemoveWindow(r4->unk138.unk82);
+    sub_814EBB0(r4);
+}
+
+static void Task_ShowBerryCrushRankings(u8 taskId)
+{
+    u8 i = 0, j, xPos, yPos;
+    u32 score = 0;
+    s16 *data = gTasks[taskId].data;
+    u8 *str;
+
+    switch (data[0])
+    {
+    case 0:
+        data[1] = AddWindow(&gUnknown_846E3F0);
+        PutWindowTilemap(data[1]);
+        FillWindowPixelBuffer(data[1], PIXEL_FILL(0));
+        TextWindow_SetStdFrame0_WithPal(data[1], 0x21D, 0xD0);
+        DrawStdFrameWithCustomTileAndPalette(data[1], 0, 0x21D, 0xD);
+        break;
+    case 1:
+        xPos = 96 - GetStringWidth(2, gText_BerryCrush2, -1) / 2u;
+        AddTextPrinterParameterized3(
+            data[1],
+            2,
+            xPos,
+            2,
+            sBerryCrushTextColorTable[3],
+            0,
+            gText_BerryCrush2
+        );
+        xPos = 96 - GetStringWidth(2, gText_PressingSpeedRankings, -1) / 2u;
+        AddTextPrinterParameterized3(
+            data[1],
+            2,
+            xPos,
+            18,
+            sBerryCrushTextColorTable[3],
+            0,
+            gText_PressingSpeedRankings
+        );
+        yPos = 42;
+        for (i = 0; i < 4; ++i)
+        {
+            ConvertIntToDecimalStringN(gStringVar1, i + 2, STR_CONV_MODE_LEFT_ALIGN, 1);
+            StringExpandPlaceholders(gStringVar4, gText_Var1Players);
+            AddTextPrinterParameterized3(
+                data[1],
+                2,
+                4,
+                yPos,
+                sBerryCrushTextColorTable[0],
+                0,
+                gStringVar4
+            );
+            for (j = 0; j < 8; ++j)
+            {
+                if (((data[i + 2] & 0xFF) >> (7 - j)) & 1)
+                    score += gUnknown_846E450[j];
+            }
+            ConvertIntToDecimalStringN(gStringVar1, (u16)data[i + 2] >> 8, STR_CONV_MODE_RIGHT_ALIGN, 3);
+            ConvertIntToDecimalStringN(gStringVar2, score / 1000000, STR_CONV_MODE_LEADING_ZEROS, 2);
+            str = StringExpandPlaceholders(gStringVar4, gText_XDotY3);
+            *str++ = CHAR_SPACE;
+            StringCopy(str, gText_TimesPerSec);
+            xPos = 192 - (u8)GetStringWidth(3, gStringVar4, 0);
+            AddTextPrinterParameterized3(
+                data[1],
+                3,
+                xPos,
+                yPos,
+                sBerryCrushTextColorTable[0],
+                0,
+                gStringVar4
+            );
+            yPos += 14;
+            score = 0;
+        }
+        CopyWindowToVram(data[1], 3);
+        break;
+    case 2:
+        if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+            break;
+        else
+            return;
+    case 3:
+        ClearStdWindowAndFrameToTransparent(data[1], 1);
+        ClearWindowTilemap(data[1]);
+        RemoveWindow(data[1]);
+        DestroyTask(taskId);
+        EnableBothScriptContexts();
+        ScriptContext2_Disable();
+        data[0] = 0;
+        return;
+    }
+    ++data[0];
+}
+
+void ShowBerryCrushRankings(void)
+{
+    u8 taskId;
+
+    ScriptContext2_Enable();
+    taskId = CreateTask(Task_ShowBerryCrushRankings, 0);
+    gTasks[taskId].data[2] = gSaveBlock2Ptr->berryCrush.berryCrushResults[0];
+    gTasks[taskId].data[3] = gSaveBlock2Ptr->berryCrush.berryCrushResults[1];
+    gTasks[taskId].data[4] = gSaveBlock2Ptr->berryCrush.berryCrushResults[2];
+    gTasks[taskId].data[5] = gSaveBlock2Ptr->berryCrush.berryCrushResults[3];
+}
+
+static void sub_814EAD4(struct BerryCrushGame_138 * r4, u16 r1)
+{
+    sub_814DEC0(r4, r1);
+    DigitObjUtil_PrintNumOn(0, r4->unk4);
+    DigitObjUtil_PrintNumOn(1, r4->unk6);
+    DigitObjUtil_PrintNumOn(2, r4->unk8);
+}
+
+void sub_814EB04(struct BerryCrushGame_138 * r0)
+{
+    r0->unk78[0]->invisible = TRUE;
+    r0->unk78[1]->invisible = TRUE;
+    DigitObjUtil_HideOrShow(2, 1);
+    DigitObjUtil_HideOrShow(1, 1);
+    DigitObjUtil_HideOrShow(0, 1);
+}
+
+static void sub_814EB38(struct BerryCrushGame * r5)
+{
+    u8 r6;
+
+    for (r6 = 0; r6 < r5->unk9; ++r6)
+    {
+        r5->unk138.unkC[r6] = &gUnknown_846F294[gUnknown_846F280[r5->unk9 - 2][r6]];
+        r5->unk138.unk83[r6] = AddWindow(&gUnknown_846E3F8[r5->unk138.unkC[r6]->unk0]);
+        PutWindowTilemap(r5->unk138.unk83[r6]);
+        FillWindowPixelBuffer(r5->unk138.unk83[r6], 0);
+    }
+}
+
+static void sub_814EBB0(struct BerryCrushGame * r6)
+{
+    u8 r7, r2;
+    u8 *r4;
+
+    for (r7 = 0; r7 < r6->unk9; ++r7)
+    {
+        PutWindowTilemap(r6->unk138.unk83[r7]);
+        if (r7 == r6->unk8)
+        {
+            AddTextPrinterParameterized4(
+                r6->unk138.unk83[r7],
+                2,
+                36 - GetStringWidth(2, PLAYER_UNK14(r6, r7), 0) / 2u,
+                1,
+                0,
+                0,
+                sBerryCrushTextColorTable[1],
+                0,
+                PLAYER_UNK14(r6, r7)
+            );
+        }
+        else
+        {
+            AddTextPrinterParameterized4(
+                r6->unk138.unk83[r7],
+                2,
+                36 - GetStringWidth(2, PLAYER_UNK14(r6, r7), 0) / 2u,
+                1,
+                0,
+                0,
+                sBerryCrushTextColorTable[2],
+                0,
+                PLAYER_UNK14(r6, r7)
+            );
+        }
+        CopyWindowToVram(r6->unk138.unk83[r7], 3);
+    }
+    CopyBgTilemapBufferToVram(0);
+}
+
+static void sub_814EC80(struct BerryCrushGame * r6)
+{
+    u8 r5 = 0;
+    const u32 *r0 = gUnknown_8EB0ADC;
+#ifndef NONMATCHING // r4, r5, r6 register roulette
+    register u8 *r4 asm("r4") = gDecompressionBuffer;
+    register u32 r0_ asm("r0");
+#else
+    u8 *r4 = gDecompressionBuffer;
+    u32 r0_;
+#endif
+
+    LZ77UnCompWram(r0, r4);
+    for (; r5 < r6->unk9; ++r5)
+    {
+        r0_ = r6->unk138.unkC[r5]->unk0;
+        CopyToBgTilemapBufferRect(
+            3,
+            &r4[r0_ * 40],
+            r6->unk138.unkC[r5]->unk1,
+            r6->unk138.unkC[r5]->unk2,
+            10,
+            2
+        );
+    }
+    CopyBgTilemapBufferToVram(3);
+}
+
+static void sub_814ECE0(struct BerryCrushGame * r6)
+{
+    u8 r5 = 0;
+    u8 r2;
+
+    r6->unk2A = -104;
+    r6->unk2C = 0;
+    gSpriteCoordOffsetX = 0;
+    gSpriteCoordOffsetY = -104;
+    for (; r5 < 4; ++r5)
+        LoadCompressedSpriteSheet(&gUnknown_846F2F8[r5]);
+    LoadSpritePalettes(gUnknown_846F320);
+    r2 = CreateSprite(&gUnknown_846F410, 120, 88, 5);
+    r6->unk138.unk20 = &gSprites[r2];
+    r6->unk138.unk20->oam.priority = 3;
+    r6->unk138.unk20->coordOffsetEnabled = TRUE;
+    r6->unk138.unk20->animPaused = TRUE;
+    for (r5 = 0; r5 < r6->unk9; ++r5)
+    {
+        r2 = CreateSprite(
+            &gUnknown_846F428,
+            r6->unk138.unkC[r5]->unk4 + 120,
+            r6->unk138.unkC[r5]->unk6 + 32,
+            0
+        );
+        r6->unk138.unk24[r5] = &gSprites[r2];
+        r6->unk138.unk24[r5]->oam.priority = 1;
+        r6->unk138.unk24[r5]->invisible = TRUE;
+        r6->unk138.unk24[r5]->coordOffsetEnabled = TRUE;
+        r6->unk138.unk24[r5]->animPaused = TRUE;
+    }
+    for (r5 = 0; r5 < NELEMS(r6->unk138.unk4C); ++r5)
+    {
+        r2 = CreateSprite(
+            &gUnknown_846F440,
+            gUnknown_846F2D6[r5][0] + 120,
+            gUnknown_846F2D6[r5][1] + 136,
+            6
+        );
+        r6->unk138.unk4C[r5] = &gSprites[r2];
+        r6->unk138.unk4C[r5]->oam.priority = 3;
+        r6->unk138.unk4C[r5]->invisible = TRUE;
+        r6->unk138.unk4C[r5]->animPaused = TRUE;
+        r6->unk138.unk4C[r5]->data[0] = r5;
+    }
+    for (r5 = 0; r5 < NELEMS(r6->unk138.unk78); ++r5)
+    {
+        r2 = CreateSprite(
+            &gUnknown_846F458,
+            24 * r5 + 176,
+            8,
+            0
+        );
+        r6->unk138.unk78[r5] = &gSprites[r2];
+        r6->unk138.unk78[r5]->oam.priority = 0;
+        r6->unk138.unk78[r5]->invisible = FALSE;
+        r6->unk138.unk78[r5]->animPaused = FALSE;
+    }
+    DigitObjUtil_CreatePrinter(0, 0, &gUnknown_846F488[0]);
+    DigitObjUtil_CreatePrinter(1, 0, &gUnknown_846F488[1]);
+    DigitObjUtil_CreatePrinter(2, 0, &gUnknown_846F488[2]);
+    if (r6->unk12 == 1)
+        sub_814EB04(&r6->unk138);
+}
+
+static void sub_814EF10(struct BerryCrushGame * r5)
+{
+    u8 r4 = 0;
+
+    FreeSpriteTilesByTag(4);
+    FreeSpriteTilesByTag(3);
+    FreeSpriteTilesByTag(2);
+    FreeSpriteTilesByTag(1);
+    FreeSpritePaletteByTag(4);
+    FreeSpritePaletteByTag(2);
+    FreeSpritePaletteByTag(1);
+    for (; r4 < NELEMS(r5->unk138.unk78); ++r4)
+        DestroySprite(r5->unk138.unk78[r4]);
+    DigitObjUtil_DeletePrinter(2);
+    DigitObjUtil_DeletePrinter(1);
+    DigitObjUtil_DeletePrinter(0);
+    for (r4 = 0; r4 < NELEMS(r5->unk138.unk4C); ++r4)
+        DestroySprite(r5->unk138.unk4C[r4]);
+    for (r4 = 0; r4 < r5->unk9; ++r4)
+        DestroySprite(r5->unk138.unk24[r4]);
+    if (r5->unk138.unk20->inUse)
+        DestroySprite(r5->unk138.unk20);
+}
+
+static void sub_814EFD0(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+    {
+        sprite->invisible = TRUE;
+        sprite->animPaused = TRUE;
+    }
+}
+
+static void sub_814EFFC(struct Sprite * sprite)
+{
+    u8 r1 = 0;
+    SpriteCallback r5 = SpriteCallbackDummy;
+
+    for (; r1 < NELEMS(sprite->data); ++r1)
+        sprite->data[r1] = 0;
+    sprite->pos2.x = 0;
+    sprite->pos2.y = 0;
+    sprite->invisible = TRUE;
+    sprite->animPaused = TRUE;
+    sprite->callback = r5;
+}
+
+static void sub_814F044(struct Sprite * sprite)
+{
+    s16 *r4 = sprite->data;
+
+    r4[1] += r4[2];
+    sprite->pos2.y += r4[1] >> 8;
+    if (r4[7] & 0x8000)
+    {
+        sprite->data[0] += r4[3];
+        r4[4] += r4[5];
+        sprite->pos2.x = Sin(r4[4] >> 7, r4[6]);
+        if (r4[7] & 0x8000 && r4[4] >> 7 > 126)
+        {
+            sprite->pos2.x = 0;
+            r4[7] &= 0x7FFF;
+        }
+    }
+    sprite->pos1.x = r4[0] >> 7;
+    if (sprite->pos1.y + sprite->pos2.y > (r4[7] & 0x7FFF))
+        sprite->callback = sub_814EFFC;
+}
+
+static void sub_814F0D8(struct Sprite * sprite)
+{
+    s16 *r7 = sprite->data;
+    s16 r4, r5;
+    s32 r2;
+    u32 r8 = 0;
+
+    r2 = 640;
+    r7[1] = r2;
+    r7[2] = 32;
+    r7[7] = 168;
+    r4 = sprite->pos2.x * 128;
+    r5 = sub_80D8B40(7, (168 - sprite->pos1.y) << 7, (r2 + 32) >> 1);
+    sprite->data[0] = sprite->pos1.x << 7;
+    r7[3] = sub_80D8B40(7, r4, r5);
+    r2 = sub_80D8ABC(7, r5, 85);
+    r7[4] = r8;
+    r7[5] = sub_80D8B40(7, 0x3F80, r2);
+    r7[6] = sprite->pos2.x / 4;
+    r7[7] |= 0x8000;
+    sprite->pos2.y = r8;
+    sprite->pos2.x = r8;
+    sprite->callback = sub_814F044;
+    sprite->animPaused = FALSE;
+    sprite->invisible = FALSE;
+}
diff --git a/src/berry_fix_program.c b/src/berry_fix_program.c
index e60a53ef9..2e0bf8256 100644
--- a/src/berry_fix_program.c
+++ b/src/berry_fix_program.c
@@ -1,17 +1,12 @@
 #include "global.h"
 #include "gpu_regs.h"
 #include "multiboot.h"
-#include "malloc.h"
-#include "bg.h"
 #include "graphics.h"
 #include "main.h"
 #include "sprite.h"
 #include "task.h"
 #include "scanline_effect.h"
-#include "window.h"
-#include "text.h"
 #include "help_system.h"
-#include "menu.h"
 #include "m4a.h"
 
 // Static type declarations
diff --git a/src/berry_pouch.c b/src/berry_pouch.c
index 63677574b..a0b2c03a3 100644
--- a/src/berry_pouch.c
+++ b/src/berry_pouch.c
@@ -748,7 +748,7 @@ static void BerryPouchSetArrowCursorAt(u8 y, u8 colorIdx)
     }
     else
     {
-        BerryPouchPrint(0, 2, gFameCheckerText_ListMenuCursor, 1, y, 0, 0, 0, colorIdx);
+        BerryPouchPrint(0, 2, gText_SelectorArrow2, 1, y, 0, 0, 0, colorIdx);
     }
 }
 
@@ -1027,7 +1027,7 @@ static void CreateNormalContextMenu(u8 taskId)
     Menu_InitCursor(windowId, 2, 0, 2, GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT) + 2, sContextMenuNumOptions, 0);
     windowId2 = GetOrCreateVariableWindow(6);
     CopySelectedListMenuItemName(data[1], gStringVar1);
-    StringExpandPlaceholders(gStringVar4, gOtherText_StrVar1);
+    StringExpandPlaceholders(gStringVar4, gText_Var1IsSelected);
     BerryPouchPrint(windowId2, 2, gStringVar4, 0, 2, 1, 2, 0, 1);
 }
 
diff --git a/src/berry_powder.c b/src/berry_powder.c
index 2eff23802..3ebffed48 100644
--- a/src/berry_powder.c
+++ b/src/berry_powder.c
@@ -36,7 +36,7 @@ static bool8 HasEnoughBerryPowder(u32 cost)
         return TRUE;
 }
 
-bool8 Special_HasEnoughBerryPowder(void)
+bool8 Script_HasEnoughBerryPowder(void)
 {
     if (DecryptBerryPowder(&gSaveBlock2Ptr->berryCrush.berryPowderAmount) < gSpecialVar_0x8004)
         return FALSE;
@@ -73,7 +73,7 @@ static bool8 TakeBerryPowder(u32 cost)
     }
 }
 
-bool8 Special_TakeBerryPowder(void)
+bool8 Script_TakeBerryPowder(void)
 {
     u32 *powder = &gSaveBlock2Ptr->berryCrush.berryPowderAmount;
     if (!HasEnoughBerryPowder(gSpecialVar_0x8004))
diff --git a/src/cable_club.c b/src/cable_club.c
new file mode 100644
index 000000000..b7f9b9114
--- /dev/null
+++ b/src/cable_club.c
@@ -0,0 +1,964 @@
+#include "global.h"
+#include "gflib.h"
+#include "battle.h"
+#include "battle_records.h"
+#include "cable_club.h"
+#include "event_data.h"
+#include "event_scripts.h"
+#include "field_message_box.h"
+#include "field_weather.h"
+#include "link.h"
+#include "load_save.h"
+#include "m4a.h"
+#include "mevent.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+#include "quest_log.h"
+#include "script.h"
+#include "script_pokemon_util.h"
+#include "start_menu.h"
+#include "strings.h"
+#include "task.h"
+#include "trade.h"
+#include "trainer_card.h"
+#include "union_room.h"
+#include "constants/songs.h"
+#include "constants/cable_club.h"
+#include "constants/field_weather.h"
+
+u32 UnusedVarNeededToMatch[8];
+
+static void Task_Linkup0(u8 taskId);
+static void Task_Linkup1(u8 taskId);
+static void Task_LinkupMaster_2(u8 taskId);
+static void Task_LinkupMaster_3(u8 taskId);
+static void Task_LinkupMaster_4(u8 taskId);
+static void Task_LinkupMaster_5(u8 taskId);
+static void Task_LinkupSlave_2(u8 taskId);
+static void Task_LinkupMaster_6(u8 taskId);
+static void Task_Linkup_6a(u8 taskId);
+static void Task_Linkup_7(u8 taskId);
+static void Task_Linkup_Canceled(u8 taskId);
+static void Task_Linkup_ErroredOut(u8 taskId);
+static bool8 Task_Linkup_TimedOut(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_0(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_1(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_Master(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_2(u8 taskId);
+
+static const struct WindowTemplate gUnknown_83C6AB0 = {
+    .bg = 0,
+    .tilemapLeft = 16,
+    .tilemapTop = 11,
+    .width = 11,
+    .height = 2,
+    .paletteNum = 15,
+    .baseBlock = 0x125
+};
+
+static const u8 *const sStarsMessagePtrs[] = {
+    gUnknown_841DF8B,
+    gUnknown_841DF92,
+    gUnknown_841DF99,
+    gUnknown_841DFA0
+};
+
+static void CreateLinkupTask(u8 lower, u8 higher)
+{
+    u8 taskId;
+    if (FindTaskIdByFunc(Task_Linkup0) == 0xFF)
+    {
+        taskId = CreateTask(Task_Linkup0, 80);
+        gTasks[taskId].data[1] = lower;
+        gTasks[taskId].data[2] = higher;
+    }
+}
+
+static void PrintNewCountOnLinkPlayerCountDisplayWindow(u16 windowId, s32 num)
+{
+    ConvertIntToDecimalStringN(gStringVar1, num, STR_CONV_MODE_LEFT_ALIGN, 1);
+    SetStdWindowBorderStyle(windowId, FALSE);
+    StringExpandPlaceholders(gStringVar4, gUnknown_841DF82);
+    AddTextPrinterParameterized(windowId, 2, gStringVar4, 0, 0, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(windowId, 3);
+}
+
+static void DestroyLinkPlayerCountDisplayWindow(u16 windowId)
+{
+    ClearStdWindowAndFrame(windowId, FALSE);
+    CopyWindowToVram(windowId, 3);
+}
+
+static void UpdateLinkPlayerCountDisplay(u8 taskId, u8 num)
+{
+    s16 *data = gTasks[taskId].data;
+    if (num != data[3])
+    {
+        if (num < 2)
+            DestroyLinkPlayerCountDisplayWindow(data[5]);
+        else
+            PrintNewCountOnLinkPlayerCountDisplayWindow(data[5], num);
+        data[3] = num;
+    }
+}
+
+static u16 sub_8080844(u8 lower, u8 higher)
+{
+    switch (GetLinkPlayerDataExchangeStatusTimed(lower, higher))
+    {
+    case EXCHANGE_COMPLETE:
+        return 1;
+    case EXCHANGE_IN_PROGRESS:
+        return 3;
+    case EXCHANGE_STAT_4:
+        return 7;
+    case EXCHANGE_STAT_5:
+        return 9;
+    case EXCHANGE_STAT_6:
+        ConvertIntToDecimalStringN(gStringVar1, GetLinkPlayerCount_2(), STR_CONV_MODE_LEFT_ALIGN, 1);
+        return 4;
+    default:
+        return 0;
+    }
+}
+
+static bool32 sub_80808BC(u8 taskId)
+{
+    if (HasLinkErrorOccurred() == TRUE)
+    {
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 sub_80808F0(u8 taskId)
+{
+    if (JOY_NEW(B_BUTTON) && !IsLinkConnectionEstablished())
+    {
+        gLinkType = 0;
+        gTasks[taskId].func = Task_Linkup_Canceled;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 sub_808093C(u8 taskId)
+{
+    if (IsLinkConnectionEstablished())
+    {
+        SetSuppressLinkErrorMessage(TRUE);
+    }
+    if (JOY_NEW(B_BUTTON))
+    {
+        gLinkType = 0;
+        gTasks[taskId].func = Task_Linkup_Canceled;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool32 sub_8080990(u8 taskId)
+{
+    if (GetSioMultiSI() == TRUE)
+    {
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static void sub_80809C4(u8 taskId)
+{
+    gTasks[taskId].data[0]++;
+    if (gTasks[taskId].data[0] == 10)
+    {
+        sub_800A474(2);
+        DestroyTask(taskId);
+    }
+}
+
+static void Task_Linkup0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        OpenLinkTimed();
+        sub_800AA24();
+        ResetLinkPlayers();
+        data[5] = AddWindow(&gUnknown_83C6AB0);
+    }
+    else if (data[0] > 9)
+    {
+        gTasks[taskId].func = Task_Linkup1;
+    }
+    data[0]++;
+}
+
+static void Task_Linkup1(u8 taskId)
+{
+    u8 linkPlayerCount = GetLinkPlayerCount_2();
+    if (sub_80808F0(taskId) != TRUE && sub_808093C(taskId) != TRUE && linkPlayerCount >= 2)
+    {
+        SetSuppressLinkErrorMessage(TRUE);
+        gTasks[taskId].data[3] = 0;
+        if (IsLinkMaster() == TRUE)
+        {
+            PlaySE(SE_PIN);
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = Task_LinkupMaster_2;
+        }
+        else
+        {
+            PlaySE(SE_BOO);
+            ShowFieldAutoScrollMessage(CableClub_Text_AwaitingLinkupBCancel);
+            gTasks[taskId].func = Task_LinkupSlave_2;
+        }
+    }
+}
+
+static void Task_LinkupMaster_2(u8 taskId)
+{
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
+    {
+        gTasks[taskId].data[3] = 0;
+        gTasks[taskId].func = Task_LinkupMaster_3;
+    }
+}
+
+static void Task_LinkupMaster_3(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s32 linkPlayerCount = GetLinkPlayerCount_2();
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE)
+    {
+        UpdateLinkPlayerCountDisplay(taskId, linkPlayerCount);
+        if (JOY_NEW(A_BUTTON) && linkPlayerCount >= data[1])
+        {
+            sub_800A900(linkPlayerCount);
+            DestroyLinkPlayerCountDisplayWindow(data[5]);
+            ConvertIntToDecimalStringN(gStringVar1, linkPlayerCount, STR_CONV_MODE_LEFT_ALIGN, 1);
+            ShowFieldAutoScrollMessage(CableClub_Text_StartLinkWithXPlayersAConfirmBCancel);
+            gTasks[taskId].func = Task_LinkupMaster_4;
+        }
+    }
+}
+
+static void Task_LinkupMaster_4(u8 taskId)
+{
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
+    {
+        if (GetSavedPlayerCount() != GetLinkPlayerCount_2())
+        {
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = Task_LinkupMaster_2;
+        }
+        else if (JOY_HELD(B_BUTTON))
+        {
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = Task_LinkupMaster_2;
+        }
+        else if (JOY_HELD(A_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+            CheckShouldAdvanceLinkState();
+            gTasks[taskId].func = Task_LinkupMaster_5;
+        }
+    }
+}
+
+static void Task_LinkupMaster_5(u8 taskId)
+{
+    u8 lower = gTasks[taskId].data[1];
+    u8 higher = gTasks[taskId].data[2];
+    u16 *res;
+    if (sub_80808BC(taskId) != TRUE && Task_Linkup_TimedOut(taskId) != TRUE)
+    {
+        if (GetLinkPlayerCount_2() != GetSavedPlayerCount())
+        {
+            gTasks[taskId].func = Task_Linkup_ErroredOut;
+        }
+        else
+        {
+            res = &gSpecialVar_Result;
+            *res = sub_8080844(lower, higher);
+            if (*res)
+                gTasks[taskId].func = Task_LinkupMaster_6;
+        }
+    }
+}
+
+static void Task_LinkupSlave_2(u8 taskId)
+{
+    u8 lower = gTasks[taskId].data[1];
+    u8 higher = gTasks[taskId].data[2];
+    u16 *res;
+    if (sub_80808F0(taskId) != TRUE && sub_80808BC(taskId) != TRUE)
+    {
+        res = &gSpecialVar_Result;
+        *res = sub_8080844(lower, higher);
+        if (*res)
+        {
+            if (*res == 3 || *res == 4)
+            {
+                Link_TryStartSend5FFF();
+                HideFieldMessageBox();
+                gTasks[taskId].func = Task_Linkup_7;
+            }
+            else if (*res == 7 || *res == 9)
+            {
+                CloseLink();
+                HideFieldMessageBox();
+                gTasks[taskId].func = Task_Linkup_7;
+            }
+            else
+            {
+                gFieldLinkPlayerCount = GetLinkPlayerCount_2();
+                gLocalLinkPlayerId = GetMultiplayerId();
+                sub_800A900(gFieldLinkPlayerCount);
+                TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
+                gTasks[taskId].func = Task_Linkup_6a;
+            }
+        }
+    }
+}
+
+static bool32 AnyConnectedPartnersPlayingRS(void)
+{
+    int i;
+    u16 version;
+
+    for (i = 0; i < GetLinkPlayerCount(); i++)
+    {
+        version = gLinkPlayers[i].version & 0xFF;
+        if (version == VERSION_RUBY || version == VERSION_SAPPHIRE)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+static void Task_LinkupMaster_6(u8 taskId)
+{
+    if (sub_80808BC(taskId) != TRUE)
+    {
+        if (gSpecialVar_Result == 4)
+        {
+            if (AnyConnectedPartnersPlayingRS() == TRUE)
+                CloseLink();
+            else
+                Link_TryStartSend5FFF();
+            HideFieldMessageBox();
+            gTasks[taskId].func = Task_Linkup_7;
+        }
+        else if (gSpecialVar_Result == 3)
+        {
+            Link_TryStartSend5FFF();
+            HideFieldMessageBox();
+            gTasks[taskId].func = Task_Linkup_7;
+        }
+        else if (gSpecialVar_Result == 7 || gSpecialVar_Result == 9)
+        {
+            CloseLink();
+            HideFieldMessageBox();
+            gTasks[taskId].func = Task_Linkup_7;
+        }
+        else
+        {
+            gFieldLinkPlayerCount = GetLinkPlayerCount_2();
+            gLocalLinkPlayerId = GetMultiplayerId();
+            sub_800A900(gFieldLinkPlayerCount);
+            TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
+            gTasks[taskId].func = Task_Linkup_6a;
+            sub_800A474(2);
+        }
+    }
+}
+
+static void Task_Linkup_6a(u8 taskId)
+{
+    u8 i;
+    u16 version;
+    u8 * dest;
+    if (sub_80808BC(taskId) != TRUE && GetBlockReceivedStatus() == sub_800A8A4())
+    {
+        for(i = 0; i < GetLinkPlayerCount(); i++)
+        {
+            version = gLinkPlayers[i].version & 0xFF;
+            if (version != VERSION_FIRE_RED && version != VERSION_LEAF_GREEN)
+            {
+                const struct TrainerCardRSE * src = (const struct TrainerCardRSE *)gBlockRecvBuffer[i];
+                gTrainerCards[i].rse = *src;
+                gTrainerCards[i].version = gLinkPlayers[i].version;
+            }
+            else
+            {
+                const struct TrainerCard * src = (const struct TrainerCard *)gBlockRecvBuffer[i];
+                gTrainerCards[i] = *src;
+            }
+        }
+        SetSuppressLinkErrorMessage(FALSE);
+        ResetBlockReceivedFlags();
+        HideFieldMessageBox();
+        if (gSpecialVar_Result == 1)
+        {
+            // Dumb trick required to match
+            if (gLinkType == LINKTYPE_0x4411)
+                *UnusedVarNeededToMatch += 0;
+            DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
+            EnableBothScriptContexts();
+            DestroyTask(taskId);
+        }
+        else
+        {
+            Link_TryStartSend5FFF();
+            gTasks[taskId].func = Task_Linkup_7;
+        }
+    }
+}
+
+static void Task_Linkup_7(u8 taskId)
+{
+    if (!gReceivedRemoteLinkPlayers)
+    {
+        DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
+        EnableBothScriptContexts();
+        RemoveWindow(gTasks[taskId].data[5]);
+        DestroyTask(taskId);
+    }
+}
+
+static void Task_Linkup_Canceled(u8 taskId)
+{
+    gSpecialVar_Result = 5;
+    DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
+    HideFieldMessageBox();
+    EnableBothScriptContexts();
+    DestroyTask(taskId);
+}
+
+static void Task_Linkup_ErroredOut(u8 taskId)
+{
+    gSpecialVar_Result = 6;
+    DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
+    HideFieldMessageBox();
+    EnableBothScriptContexts();
+    DestroyTask(taskId);
+}
+
+static bool8 Task_Linkup_TimedOut(u8 taskId)
+{
+    gTasks[taskId].data[4]++;
+    if (gTasks[taskId].data[4] > 600)
+    {
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void TryBattleLinkup(void)
+{
+    u8 lower, higher;
+    higher = lower = 2;
+    switch (gSpecialVar_0x8004)
+    {
+    case USING_SINGLE_BATTLE:
+        higher = lower = 2;
+        gLinkType = LINKTYPE_SINGLE_BATTLE;
+        break;
+    case USING_DOUBLE_BATTLE:
+        higher = lower = 2;
+        gLinkType = LINKTYPE_DOUBLE_BATTLE;
+        break;
+    case USING_MULTI_BATTLE:
+        higher = lower = 4;
+        gLinkType = LINKTYPE_MULTI_BATTLE;
+        break;
+    }
+    CreateLinkupTask(lower, higher);
+}
+
+void TryTradeLinkup(void)
+{
+    gLinkType = LINKTYPE_0x1133;
+    gBattleTypeFlags = 0;
+    CreateLinkupTask(2, 2);
+}
+
+void TryRecordMixLinkup(void)
+{
+    gSpecialVar_Result = 0;
+    gLinkType = LINKTYPE_0x3311;
+    gBattleTypeFlags = 0;
+    CreateLinkupTask(2, 4);
+}
+
+void sub_8081128(void)
+{
+    gLinkType = LINKTYPE_0x6601;
+    gBattleTypeFlags = 0;
+    CreateLinkupTask(4, 4);
+}
+
+u8 CreateTask_ReestablishLinkInCableClubRoom(void)
+{
+    if (FuncIsActiveTask(Task_ReestablishLinkInCableClubRoom_0))
+        return 0xFF;
+    switch (gSpecialVar_0x8004)
+    {
+    case USING_SINGLE_BATTLE:
+        gLinkType = LINKTYPE_SINGLE_BATTLE;
+        break;
+    case USING_DOUBLE_BATTLE:
+        gLinkType = LINKTYPE_DOUBLE_BATTLE;
+        break;
+    case USING_MULTI_BATTLE:
+        gLinkType = LINKTYPE_MULTI_BATTLE;
+        break;
+    case USING_TRADE_CENTER:
+        gLinkType = LINKTYPE_0x1111;
+        break;
+    case USING_RECORD_CORNER:
+        gLinkType = LINKTYPE_0x3322;
+        break;
+    }
+    return CreateTask(Task_ReestablishLinkInCableClubRoom_0, 80);
+}
+
+static void Task_ReestablishLinkInCableClubRoom_0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        OpenLink();
+        ResetLinkPlayers();
+        CreateTask(sub_8081A90, 80);
+    }
+    else if (data[0] > 9)
+        gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_1;
+    data[0]++;
+}
+
+static void Task_ReestablishLinkInCableClubRoom_1(u8 taskId)
+{
+    if (GetLinkPlayerCount_2() >= 2)
+    {
+        if (IsLinkMaster() == TRUE)
+        {
+            gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_Master;
+        }
+        else
+        {
+            gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_2;
+        }
+    }
+}
+
+static void Task_ReestablishLinkInCableClubRoom_Master(u8 taskId)
+{
+    if (GetSavedPlayerCount() == GetLinkPlayerCount_2())
+    {
+        CheckShouldAdvanceLinkState();
+        gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_2;
+    }
+}
+
+static void Task_ReestablishLinkInCableClubRoom_2(u8 taskId)
+{
+    if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE)
+    {
+        sub_800A9A4();
+        sub_8009FE8();
+        DestroyTask(taskId);
+    }
+}
+
+void CableClub_AskSaveTheGame(void)
+{
+    Field_AskSaveTheGame();
+}
+
+static void Task_StartWiredCableClubBattle(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        FadeScreen(FADE_TO_BLACK, 0);
+        gLinkType = LINKTYPE_BATTLE;
+        ClearLinkCallback_2();
+        task->data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            task->data[0]++;
+        break;
+    case 2:
+        task->data[1]++;
+        if (task->data[1] > 20)
+            task->data[0]++;
+        break;
+    case 3:
+        Link_TryStartSend5FFF();
+        task->data[0]++;
+        break;
+    case 4:
+        if (!gReceivedRemoteLinkPlayers)
+            task->data[0]++;
+        break;
+    case 5:
+        if (gLinkPlayers[0].trainerId & 1)
+            PlayMapChosenOrBattleBGM(MUS_BATTLE32);
+        else
+            PlayMapChosenOrBattleBGM(MUS_BATTLE20);
+        switch (gSpecialVar_0x8004)
+        {
+        case USING_SINGLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK;
+            break;
+        case USING_DOUBLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE;
+            break;
+        case USING_MULTI_BATTLE:
+            ReducePlayerPartyToThree();
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI;
+            break;
+        }
+        CleanupOverworldWindowsAndTilemaps();
+        gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
+        SetMainCallback2(CB2_InitBattle);
+        gMain.savedCallback = CB2_ReturnFromCableClubBattle;
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+static void Task_StartWirelessCableClubBattle(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    int i;
+    switch (data[0])
+    {
+    case 0:
+        FadeScreen(FADE_TO_BLACK, 0);
+        gLinkType = LINKTYPE_BATTLE;
+        ClearLinkCallback_2();
+        data[0] = 1;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            data[0] = 2;
+        break;
+    case 2:
+        SendBlock(0, &gLocalLinkPlayer, sizeof(struct LinkPlayer));
+        data[0] = 3;
+        break;
+    case 3:
+        if (GetBlockReceivedStatus() == sub_800A8D4())
+        {
+            for (i = 0; i < GetLinkPlayerCount(); i++)
+            {
+                gLinkPlayers[i] = *(struct LinkPlayer *)gBlockRecvBuffer[i];
+                IntlConvertLinkPlayerName(&gLinkPlayers[i]);
+                ResetBlockReceivedFlag(i);
+            }
+            data[0] = 4;
+        }
+        break;
+    case 4:
+        data[1]++;
+        if (data[1] > 20)
+            data[0] = 5;
+        break;
+    case 5:
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
+        data[0] = 6;
+        break;
+    case 6:
+        if (IsLinkTaskFinished())
+            data[0] = 7;
+        break;
+    case 7:
+        if (gLinkPlayers[0].trainerId & 1)
+            PlayMapChosenOrBattleBGM(MUS_BATTLE32);
+        else
+            PlayMapChosenOrBattleBGM(MUS_BATTLE20);
+        gLinkPlayers[0].linkType = LINKTYPE_BATTLE;
+        switch (gSpecialVar_0x8004)
+        {
+        case USING_SINGLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK;
+            break;
+        case USING_DOUBLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE;
+            break;
+        case USING_MULTI_BATTLE:
+            ReducePlayerPartyToThree();
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI;
+            break;
+        }
+        CleanupOverworldWindowsAndTilemaps();
+        gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
+        SetMainCallback2(CB2_InitBattle);
+        gMain.savedCallback = CB2_ReturnFromCableClubBattle;
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+static void sub_8081624(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        Link_TryStartSend5FFF();
+        gMain.state++;
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+            SetMainCallback2(CB2_ReturnToField);
+        break;
+    }
+}
+
+void CB2_ReturnFromCableClubBattle(void)
+{
+    gBattleTypeFlags &= (u16)~BATTLE_TYPE_20;
+    sub_8055DB8();
+    LoadPlayerParty();
+    SavePlayerBag();
+    Special_UpdateTrainerFansAfterLinkBattle();
+    if (gSpecialVar_0x8004 != USING_MULTI_BATTLE)
+    {
+        TryRecordLinkBattleOutcome(gLocalLinkPlayerId ^ 1);
+        if (gWirelessCommType != 0)
+        {
+            switch (gBattleOutcome)
+            {
+            case B_OUTCOME_WON:
+                MEvent_RecordIdOfWonderCardSenderByEventType(0, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
+                break;
+            case B_OUTCOME_LOST:
+                MEvent_RecordIdOfWonderCardSenderByEventType(1, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
+                break;
+            }
+        }
+    }
+    if (InUnionRoom() == TRUE)
+    {
+        gMain.savedCallback = sub_8081624;
+    }
+    else
+    {
+        gMain.savedCallback = c2_8056854;
+    }
+    SetMainCallback2(CB2_SetUpSaveAfterLinkBattle);
+}
+
+void CleanupLinkRoomState(void)
+{
+    if (gSpecialVar_0x8004 == USING_SINGLE_BATTLE || gSpecialVar_0x8004 == USING_DOUBLE_BATTLE || gSpecialVar_0x8004 == USING_MULTI_BATTLE)
+    {
+        LoadPlayerParty();
+        SavePlayerBag();
+    }
+    copy_saved_warp2_bank_and_enter_x_to_warp1(127);
+}
+
+void ExitLinkRoom(void)
+{
+    sub_8057F5C();
+}
+
+static void Task_EnterCableClubSeat(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        ShowFieldMessage(CableClub_Text_PleaseWaitBCancel);
+        task->data[0] = 1;
+        break;
+    case 1:
+        if (IsFieldMessageBoxHidden())
+        {
+            sub_8057F34();
+            SetLocalLinkPlayerId(gSpecialVar_0x8005);
+            task->data[0] = 2;
+        }
+        break;
+    case 2:
+        switch (sub_8057EC0())
+        {
+        case 0:
+            break;
+        case 1:
+            HideFieldMessageBox();
+            task->data[0] = 0;
+            sub_8057F70();
+            SwitchTaskToFollowupFunc(taskId);
+            break;
+        case 2:
+            task->data[0] = 3;
+            break;
+        }
+        break;
+    case 3:
+        sub_8057F48();
+        sub_80F771C(TRUE);
+        DestroyTask(taskId);
+        EnableBothScriptContexts();
+        break;
+    }
+}
+
+static void CreateEnterCableClubSeatTaskWithFollowupFunc(TaskFunc followUpFunc)
+{
+    u8 taskId = CreateTask(Task_EnterCableClubSeat, 80);
+    SetTaskFuncWithFollowupFunc(taskId, Task_EnterCableClubSeat, followUpFunc);
+    ScriptContext1_Stop();
+}
+
+static void Task_StartWiredCableClubTrade(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        ScriptContext2_Enable();
+        FadeScreen(FADE_TO_BLACK, 0);
+        ClearLinkCallback_2();
+        task->data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            task->data[0]++;
+        break;
+    case 2:
+        gSelectedTradeMonPositions[0] = 0;
+        gSelectedTradeMonPositions[1] = 0;
+        m4aMPlayAllStop();
+        Link_TryStartSend5FFF();
+        task->data[0]++;
+        break;
+    case 3:
+        if (!gReceivedRemoteLinkPlayers)
+        {
+            SetMainCallback2(CB2_ReturnFromLinkTrade);
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+static void Task_StartWirelessCableClubTrade(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    switch (data[0])
+    {
+    case 0:
+        ScriptContext2_Enable();
+        FadeScreen(FADE_TO_BLACK, 0);
+        Rfu_set_zero();
+        data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            data[0]++;
+        break;
+    case 2:
+        gSelectedTradeMonPositions[0] = 0;
+        gSelectedTradeMonPositions[1] = 0;
+        m4aMPlayAllStop();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
+        data[0]++;
+        break;
+    case 3:
+        if (IsLinkTaskFinished())
+        {
+            UnionRoom_CreateTask_CallCB2ReturnFromLinkTrade();
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+void EnterTradeSeat(void)
+{
+    if (gWirelessCommType)
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWirelessCableClubTrade);
+    else
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWiredCableClubTrade);
+}
+
+static void CreateTask_StartWiredCableClubTrade(void)
+{
+    CreateTask(Task_StartWiredCableClubTrade, 80);
+}
+
+void StartWiredCableClubTrade(void)
+{
+    CreateTask_StartWiredCableClubTrade();
+    ScriptContext1_Stop();
+}
+
+void EnterColosseumPlayerSpot(void)
+{
+    gLinkType = LINKTYPE_BATTLE;
+    if (gWirelessCommType)
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWirelessCableClubBattle);
+    else
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWiredCableClubBattle);
+}
+
+static void Debug_CreateTaskEnterCableClubSeat(void)
+{
+    CreateTask(Task_EnterCableClubSeat, 80);
+    ScriptContext1_Stop();
+}
+
+void Script_ShowLinkTrainerCard(void)
+{
+    ShowTrainerCardInLink(gSpecialVar_0x8006, CB2_ReturnToFieldContinueScriptPlayMapMusic);
+}
+
+bool32 GetSeeingLinkPlayerCardMsg(u8 who)
+{
+    u8 stars;
+    gSpecialVar_0x8006 = who;
+    StringCopy(gStringVar1, gLinkPlayers[who].name);
+    stars = GetTrainerCardStars(who);
+    if (stars == 0)
+        return FALSE;
+    StringCopy(gStringVar2, sStarsMessagePtrs[stars - 1]);
+    return TRUE;
+}
+
+void sub_8081A90(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    task->data[0]++;
+    if (task->data[0] > 300)
+    {
+        CloseLink();
+        SetMainCallback2(CB2_LinkError);
+        DestroyTask(taskId);
+    }
+    if (gReceivedRemoteLinkPlayers)
+        DestroyTask(taskId);
+}
+
+static void sub_8081AE4(u8 taskId)
+{
+    if (!gReceivedRemoteLinkPlayers)
+    {
+        EnableBothScriptContexts();
+        DestroyTask(taskId);
+    }
+}
+
+static void sub_8081B08(u8 taskId)
+{
+    Link_TryStartSend5FFF();
+    gTasks[taskId].func = sub_8081AE4;
+}
diff --git a/src/cereader_tool.c b/src/cereader_tool.c
index 2c5d05018..c6e0c9a99 100644
--- a/src/cereader_tool.c
+++ b/src/cereader_tool.c
@@ -6,40 +6,40 @@
 
 u8 sub_815D654(void)
 {
-    return (gSaveBlock1Ptr->unkArray[0].unk9 + 1) % 256;
+    return (gSaveBlock1Ptr->trainerTower[0].unk9 + 1) % 256;
 }
 
 static bool32 ValidateTrainerTowerTrainer(struct TrainerTowerFloor * floor)
 {
-    if (floor->floorIdx < 1 || floor->floorIdx > 8)
+    if (floor->floorIdx < 1 || floor->floorIdx > MAX_TRAINER_TOWER_FLOORS)
         return FALSE;
-    if (floor->challengeType > 2)
+    if (floor->challengeType > CHALLENGE_TYPE_KNOCKOUT)
         return FALSE;
     if (CalcByteArraySum((const u8 *)floor, offsetof(typeof(*floor), checksum)) != floor->checksum)
         return FALSE;
     return TRUE;
 }
 
-bool32 ValidateTrainerTowerData(struct EReaderTrainerHillSet * ttdata)
+bool32 ValidateTrainerTowerData(struct EReaderTrainerTowerSet * ttdata)
 {
-    u32 count = ttdata->count;
+    u32 numFloors = ttdata->numFloors;
     s32 i;
-    if (count < 1 || count > 8)
+    if (numFloors < 1 || numFloors > MAX_TRAINER_TOWER_FLOORS)
         return FALSE;
-    for (i = 0; i < count; i++)
+    for (i = 0; i < numFloors; i++)
     {
         if (!ValidateTrainerTowerTrainer(&ttdata->floors[i]))
             return FALSE;
     }
-    if (CalcByteArraySum((const u8 *)ttdata->floors, count * sizeof(ttdata->floors[0])) != ttdata->checksum)
+    if (CalcByteArraySum((const u8 *)ttdata->floors, numFloors * sizeof(ttdata->floors[0])) != ttdata->checksum)
         return FALSE;
     return TRUE;
 }
 
-#define SEC30_SIZE  (offsetof(struct EReaderTrainerHillSet, floors[4]))
-#define SEC31_SIZE  (sizeof(struct EReaderTrainerHillSet) - SEC30_SIZE)
+#define SEC30_SIZE  (offsetof(struct EReaderTrainerTowerSet, floors[4]))
+#define SEC31_SIZE  (sizeof(struct EReaderTrainerTowerSet) - SEC30_SIZE)
 
-static bool32 CEReaderTool_SaveTrainerTower_r(struct EReaderTrainerHillSet * ttdata, u8 * buffer)
+static bool32 CEReaderTool_SaveTrainerTower_r(struct EReaderTrainerTowerSet * ttdata, u8 * buffer)
 {
     AGB_ASSERT_EX(ttdata->dummy == 0, ABSPATH("cereader_tool.c"), 198);
     AGB_ASSERT_EX(ttdata->id == 0, ABSPATH("cereader_tool.c"), 199)
@@ -56,7 +56,7 @@ static bool32 CEReaderTool_SaveTrainerTower_r(struct EReaderTrainerHillSet * ttd
     return TRUE;
 }
 
-bool32 CEReaderTool_SaveTrainerTower(struct EReaderTrainerHillSet * ttdata)
+bool32 CEReaderTool_SaveTrainerTower(struct EReaderTrainerTowerSet * ttdata)
 {
     u8 * buffer = AllocZeroed(0x1000);
     bool32 result = CEReaderTool_SaveTrainerTower_r(ttdata, buffer);
@@ -64,7 +64,7 @@ bool32 CEReaderTool_SaveTrainerTower(struct EReaderTrainerHillSet * ttdata)
     return result;
 }
 
-static bool32 CEReaderTool_LoadTrainerTower_r(struct EReaderTrainerHillSet * ttdata, void * buffer)
+static bool32 CEReaderTool_LoadTrainerTower_r(struct EReaderTrainerTowerSet * ttdata, void * buffer)
 {
     if (TryCopySpecialSaveSection(SECTOR_TTOWER(0), buffer) != 1)
         return FALSE;
@@ -79,10 +79,16 @@ static bool32 CEReaderTool_LoadTrainerTower_r(struct EReaderTrainerHillSet * ttd
     return TRUE;
 }
 
-bool32 CEReaderTool_LoadTrainerTower(struct EReaderTrainerHillSet * ttdata)
+bool32 CEReaderTool_LoadTrainerTower(struct EReaderTrainerTowerSet * ttdata)
 {
     void * buffer = AllocZeroed(0x1000);
     bool32 success = CEReaderTool_LoadTrainerTower_r(ttdata, buffer);
     Free(buffer);
     return success;
 }
+
+bool32 ReadTrainerTowerAndValidate(void)
+{
+    // Stubbed out. Populated in Emerald
+    return FALSE;
+}
diff --git a/src/clear_save_data_screen.c b/src/clear_save_data_screen.c
new file mode 100644
index 000000000..b6f8b83e9
--- /dev/null
+++ b/src/clear_save_data_screen.c
@@ -0,0 +1,224 @@
+#include "global.h"
+#include "gflib.h"
+#include "menu.h"
+#include "save.h"
+#include "strings.h"
+#include "task.h"
+#include "text_window.h"
+#include "constants/songs.h"
+
+struct ClearSaveDataStruct {
+    u8 unk0;
+    u8 unk1;
+    u8 unk2;
+};
+
+static EWRAM_DATA struct ClearSaveDataStruct * sClearSaveDataState = NULL;
+
+static void Task_DrawClearSaveDataScreen(u8 taskId);
+static void Task_HandleYesNoMenu(u8 taskId);
+static void Task_CleanUpAndSoftReset(u8 taskId);
+static void CB2_Sub_SaveClearScreen_Init(void);
+static void SaveClearScreen_GpuInit(void);
+
+static const struct BgTemplate sBgTemplates[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    }
+};
+
+static const struct WindowTemplate sWindowTemplates[] = {
+    {
+        .bg = 0,
+        .tilemapLeft = 3,
+        .tilemapTop = 5,
+        .width = 6,
+        .height = 4,
+        .paletteNum = 0xF,
+        .baseBlock = 0x00A
+    }, {
+        .bg = 0,
+        .tilemapLeft = 3,
+        .tilemapTop = 15,
+        .width = 23,
+        .height = 4,
+        .paletteNum = 0xF,
+        .baseBlock = 0x022
+    }, DUMMY_WIN_TEMPLATE
+};
+
+static const u8 sTextColor[] = {
+    TEXT_COLOR_WHITE,
+    TEXT_COLOR_DARK_GREY,
+    TEXT_COLOR_LIGHT_GREY
+};
+
+static void CB2_RunClearSaveDataScreen(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void VBlankCB_WaitYesNo(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void CB2_SaveClearScreen_Init(void)
+{
+    sClearSaveDataState = AllocZeroed(sizeof(struct ClearSaveDataStruct));
+    sClearSaveDataState->unk1 = 0;
+    sClearSaveDataState->unk0 = 0;
+    sClearSaveDataState->unk2 = 0;
+    CB2_Sub_SaveClearScreen_Init();
+    CreateTask(Task_DrawClearSaveDataScreen, 0);
+    SetMainCallback2(CB2_RunClearSaveDataScreen);
+}
+
+static void Task_DrawClearSaveDataScreen(u8 taskId)
+{
+    switch (sClearSaveDataState->unk1)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        break;
+    case 1:
+        if (gPaletteFade.active)
+            return;
+        SetVBlankCallback(NULL);
+        break;
+    case 2:
+        SaveClearScreen_GpuInit();
+        break;
+    case 3:
+        TextWindow_SetStdFrame0_WithPal(0, 0x001, 0xF0);
+        TextWindow_SetStdFrame0_WithPal(1, 0x001, 0xF0);
+        break;
+    case 4:
+        DrawStdFrameWithCustomTileAndPalette(1, TRUE, 0x001, 0xF);
+        AddTextPrinterParameterized4(1, 2, 0, 3, 1, 1, sTextColor, 0, gUnknown_841B69E);
+        CopyWindowToVram(1, 2);
+        break;
+    case 5:
+        CreateYesNoMenu(&sWindowTemplates[0], 2, 0, 2, 0x001, 0xF, 1);
+        CopyBgTilemapBufferToVram(0);
+        break;
+    default:
+        BeginNormalPaletteFade(0xFFFF, 0, 16, 0, RGB_WHITEALPHA);
+        SetVBlankCallback(VBlankCB_WaitYesNo);
+        gTasks[taskId].func = Task_HandleYesNoMenu;
+        break;
+    }
+    sClearSaveDataState->unk1++;
+}
+
+static void Task_HandleYesNoMenu(u8 taskId)
+{
+    // agbcc refuses to keep &sClearSaveDataState in a register
+    // unless explicitly told to do so as such:
+    struct ClearSaveDataStruct ** r5 = &sClearSaveDataState;
+    if ((*r5)->unk0 == 0)
+    {
+        switch (Menu_ProcessInputNoWrapClearOnChoose())
+        {
+        case MENU_B_PRESSED:
+        case 1:
+            PlaySE(SE_SELECT);
+            break;
+        case 0:
+            PlaySE(SE_SELECT);
+            FillWindowPixelBuffer(1, PIXEL_FILL(1));
+            AddTextPrinterParameterized4(1, 2, 0, 3, 1, 1, sTextColor, 0, gUnknown_841B6B9);
+            CopyWindowToVram(1, 3);
+            ClearSaveData();
+            break;
+        case MENU_NOTHING_CHOSEN:
+        default:
+            return;
+        }
+        (*r5)->unk0++;
+    }
+    else
+    {
+        Task_CleanUpAndSoftReset(taskId);
+    }
+}
+
+static void Task_CleanUpAndSoftReset(u8 taskId)
+{
+    switch (sClearSaveDataState->unk2)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFF, 0, 0, 16, RGB_WHITEALPHA);
+        sClearSaveDataState->unk2++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            DestroyYesNoMenu();
+            DestroyTask(taskId);
+            FreeAllWindowBuffers();
+            FREE_AND_SET_NULL(sClearSaveDataState);
+            DoSoftReset();
+            // noreturn
+        }
+        break;
+    }
+}
+
+static void CB2_Sub_SaveClearScreen_Init(void)
+{
+    ResetSpriteData();
+    ResetPaletteFade();
+    ResetTasks();
+}
+
+static void SaveClearScreen_GpuInit(void)
+{
+    DmaClearLarge16(3, (void *)VRAM, VRAM_SIZE, 0x1000);
+
+#ifndef NONMATCHING
+    asm("":::"ip");
+#endif
+
+    do
+    {
+        void * dest = (void *)OAM;
+        size_t size = OAM_SIZE;
+        DmaClear32(3, dest, size);
+    } while (0);
+
+    do
+    {
+        void * dest = (void *)PLTT;
+        size_t size = PLTT_SIZE;
+        DmaClear16(3, dest, size);
+    } while (0);
+
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, sBgTemplates, NELEMS(sBgTemplates));
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+    InitWindows(sWindowTemplates);
+    DeactivateAllTextPrinters();
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+    ShowBg(0);
+}
diff --git a/src/coins.c b/src/coins.c
index 0f1828a96..fd5000fbd 100644
--- a/src/coins.c
+++ b/src/coins.c
@@ -4,11 +4,10 @@
 #include "menu.h"
 #include "text_window.h"
 #include "strings.h"
+#include "constants/coins.h"
 
 EWRAM_DATA static u8 sCoinsWindowId = 0;
 
-#define MAX_COINS 9999
-
 u16 GetCoins(void)
 {
     return gSaveBlock1Ptr->coins ^ gSaveBlock2Ptr->encryptionKey;
diff --git a/src/credits.c b/src/credits.c
index ceb2028f9..e0d57a2a4 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -11,12 +11,11 @@
 #include "decompress.h"
 #include "graphics.h"
 #include "strings.h"
-#include "menu.h"
-#include "field_weather.h"
 #include "trainer_pokemon_sprites.h"
 #include "sound.h"
 #include "constants/species.h"
 #include "constants/maps.h"
+#include "constants/field_weather.h"
 
 #if defined(FIRERED)
 #define TITLE_TEXT gString_PokemonFireRed_Staff
@@ -716,7 +715,7 @@ static const struct CreditsTextHeader sCreditsTexts[] = {
     { gString_Dummy, gString_Dummy, FALSE }
 };
 
-void Special_Credits(void)
+void DoCredits(void)
 {
     sCreditsMgr = AllocZeroed(sizeof(*sCreditsMgr));
     ResetTasks();
@@ -920,7 +919,7 @@ static s32 RollCredits(void)
             case CREDITSSCRCMD_MON:
                 sCreditsMgr->mainseqno = CREDITSSCENE_MON_DESTROY_ASSETS;
                 sCreditsMgr->whichMon = sCreditsScript[sCreditsMgr->scrcmdidx].param;
-                FadeScreen(1, 0);
+                FadeScreen(FADE_TO_BLACK, 0);
                 break;
             case CREDITSSCRCMD_THEENDGFX:
                 sCreditsMgr->mainseqno = CREDITSSCENE_THEEND_DESTROY_ASSETS;
diff --git a/src/data/dodrio_berry_picking.h b/src/data/dodrio_berry_picking.h
new file mode 100644
index 000000000..e71ce13cf
--- /dev/null
+++ b/src/data/dodrio_berry_picking.h
@@ -0,0 +1,247 @@
+#ifndef GUARD_DATA_DODRIO_BERRY_PICKING_H
+#define GUARD_DATA_DODRIO_BERRY_PICKING_H
+
+static const struct BgTemplate sUnknown_847565C[] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 12,
+        .screenSize = 1,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0
+    },
+    {
+        .bg = 2,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 14,
+        .screenSize = 1,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0
+    },
+};
+
+// Unknown unreferenced data, feel free to remove.
+static const u32 sUnused[] = {255, 0};
+
+static const struct WindowTemplate sUnknown_8475674[] =
+{
+    {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 1,
+        .width = 28,
+        .height = 3,
+        .paletteNum = 13,
+        .baseBlock = 0x13,
+    },
+    {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 6,
+        .width = 28,
+        .height = 13,
+        .paletteNum = 13,
+        .baseBlock = 0x67,
+    }
+};
+
+static const struct WindowTemplate sUnknown_8475684 =
+{
+    .bg = 0,
+    .tilemapLeft = 1,
+    .tilemapTop = 6,
+    .width = 28,
+    .height = 7,
+    .paletteNum = 13,
+    .baseBlock = 0x67,
+};
+
+static const struct WindowTemplate sUnknown_847568C[] =
+{
+    {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 8,
+        .width = 19,
+        .height = 3,
+        .paletteNum = 13,
+        .baseBlock = 0x13,
+    },
+    {
+        .bg = 0,
+        .tilemapLeft = 22,
+        .tilemapTop = 7,
+        .width = 6,
+        .height = 4,
+        .paletteNum = 13,
+        .baseBlock = 0x4C,
+    }
+};
+
+static const struct WindowTemplate sUnknown_847569C =
+{
+    .bg = 0,
+    .tilemapLeft = 4,
+    .tilemapTop = 6,
+    .width = 22,
+    .height = 5,
+    .paletteNum = 13,
+    .baseBlock = 0x13,
+};
+
+static const struct WindowTemplate sUnknown_84756A4 =
+{
+    .bg = 0,
+    .tilemapLeft = 5,
+    .tilemapTop = 8,
+    .width = 19,
+    .height = 3,
+    .paletteNum = 13,
+    .baseBlock = 0x13,
+};
+
+static const u8 sUnknown_8471F50[5][5][11] =
+{
+    {
+        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
+    },
+    {
+        {0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 0},
+        {0, 1, 2, 5, 6, 3, 4, 5, 8, 9, 0},
+    },
+    {
+        {0, 1, 2, 3, 4, 5, 6, 7, 2, 9, 0},
+        {0, 1, 4, 5, 6, 7, 2, 3, 4, 9, 0},
+        {0, 1, 6, 7, 2, 3, 4, 5, 6, 9, 0},
+    },
+    {
+        {0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 0},
+        {0, 3, 4, 5, 6, 7, 8, 1, 2, 3, 0},
+        {0, 5, 6, 7, 8, 1, 2, 3, 4, 5, 0},
+        {0, 7, 8, 1, 2, 3, 4, 5, 6, 7, 0},
+    },
+    {
+        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
+        {2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2},
+        {4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4},
+        {6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6},
+        {8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8},
+    },
+};
+
+static const u8 sUnknown_8472063[5][5][3] =
+{
+    {
+        {4, 5, 6},
+    },
+    {
+        {3, 4, 5},
+        {5, 6, 3},
+    },
+    {
+        {4, 5, 6},
+        {6, 7, 2},
+        {2, 3, 4},
+    },
+    {
+        {3, 4, 5},
+        {5, 6, 7},
+        {7, 8, 1},
+        {1, 2, 3},
+    },
+    {
+        {4, 5, 6},
+        {6, 7, 8},
+        {8, 9, 0},
+        {0, 1, 2},
+        {2, 3, 4},
+    },
+};
+
+static const u8 sUnknown_84720AE[5][5][3] =
+{
+    {
+        {1, 0, 1},
+    },
+    {
+        {1, 0, 1},
+        {0, 1, 0},
+    },
+    {
+        {2, 0, 1},
+        {0, 1, 2},
+        {1, 2, 0},
+    },
+    {
+        {3, 0, 1},
+        {0, 1, 2},
+        {1, 2, 3},
+        {2, 3, 0},
+    },
+    {
+        {4, 0, 1},
+        {0, 1, 2},
+        {1, 2, 3},
+        {2, 3, 4},
+        {3, 4, 0},
+    },
+};
+
+ALIGNED(4)
+static const u8 sUnknown_84720FC[5][11] =
+{
+    {9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 9},
+    {9, 9, 9, 0, 0, 1, 1, 0, 9, 9, 9},
+    {9, 9, 2, 2, 0, 0, 1, 1, 1, 9, 9},
+    {9, 3, 3, 0, 0, 1, 1, 2, 2, 3, 9},
+    {3, 3, 4, 4, 0, 0, 1, 1, 2, 2, 3},
+};
+
+static const u8 sUnknown_8472133[5][5] =
+{
+    {5},
+    {4, 6},
+    {3, 5, 7},
+    {2, 4, 6, 8},
+    {1, 3, 5, 6, 9},
+};
+
+static const u16 sDodrioBerryBgPal1[] = INCBIN_U16("graphics/link_games/dodrioberry_bg1.gbapal",
+                                            "graphics/link_games/dodrioberry_bg2.gbapal");
+static const u16 sDodrioBerryPkmnPal[] = INCBIN_U16("graphics/link_games/dodrioberry_pkmn.gbapal");
+static const u16 sDodrioBerryShinyPal[] = INCBIN_U16("graphics/link_games/dodrioberry_shiny.gbapal");
+static const u16 sDodrioBerryStatusPal[] = INCBIN_U16("graphics/link_games/dodrioberry_status.gbapal");
+static const u16 sDodrioBerrySpritesPal[] = INCBIN_U16("graphics/link_games/dodrioberry_berrysprites.gbapal");
+static const u32 sDodrioBerrySpritesGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_berrysprites.4bpp.lz");
+static const u16 sDodrioBerryPlatformPal[] = INCBIN_U16("graphics/link_games/dodrioberry_platform.gbapal");
+static const u32 sDodrioBerryBgGfx1[] = INCBIN_U32("graphics/link_games/dodrioberry_bg1.4bpp.lz");
+static const u32 sDodrioBerryBgGfx2[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2.4bpp.lz");
+static const u32 sDodrioBerryStatusGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_status.4bpp.lz");
+static const u32 sDodrioBerryPlatformGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_platform.4bpp.lz");
+static const u32 sDodrioBerryPkmnGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_pkmn.4bpp.lz");
+static const u32 sDodrioBerryBgTilemap1[] = INCBIN_U32("graphics/link_games/dodrioberry_bg1.bin.lz");
+static const u32 sDodrioBerryBgTilemap2Right[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2right.bin.lz");
+static const u32 sDodrioBerryBgTilemap2Left[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2left.bin.lz");
+
+#endif //GUARD_DATA_DODRIO_BERRY_PICKING_H
diff --git a/src/data/graphics/battle_terrain.h b/src/data/graphics/battle_terrain.h
new file mode 100644
index 000000000..f91c2d0d9
--- /dev/null
+++ b/src/data/graphics/battle_terrain.h
@@ -0,0 +1,30 @@
+
+const u32 gFile_graphics_battle_terrain_plain_palette_palette[] = INCBIN_U32("graphics/battle_terrain/plain/palette.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_building_tiles_sheet[] = INCBIN_U32("graphics/battle_terrain/building/tiles.4bpp.lz");
+
+const u32 gFile_graphics_battle_terrain_stadium_battle_frontier_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/battle_frontier.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_building_map_tilemap[] = INCBIN_U32("graphics/battle_terrain/building/map.bin.lz");
+
+const u32 gFile_graphics_battle_terrain_stadium_tiles_sheet[] = INCBIN_U32("graphics/battle_terrain/stadium/tiles.4bpp.lz");
+const u32 gFile_graphics_battle_terrain_stadium_map_tilemap[] = INCBIN_U32("graphics/battle_terrain/stadium/map.bin.lz");
+
+const u32 gFile_graphics_battle_terrain_building_palette_palette[] = INCBIN_U32("graphics/battle_terrain/building/palette.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_water_kyogre_palette[] = INCBIN_U32("graphics/battle_terrain/water/kyogre.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_cave_groudon_palette[] = INCBIN_U32("graphics/battle_terrain/cave/groudon.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_building_palette2_palette[] = INCBIN_U32("graphics/battle_terrain/building/palette2.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_building_palette3_palette[] = INCBIN_U32("graphics/battle_terrain/building/palette3.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_stadium_palette1_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette1.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette2_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette2.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette3_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette3.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette4_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette4.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette5_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette5.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette6_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette6.gbapal.lz");
+const u32 gFile_graphics_battle_terrain_stadium_palette7_palette[] = INCBIN_U32("graphics/battle_terrain/stadium/palette7.gbapal.lz");
+
+const u32 gFile_graphics_battle_terrain_building_anim_tiles_sheet[] = INCBIN_U32("graphics/battle_terrain/building/anim_tiles.4bpp.lz");
+const u32 gFile_graphics_battle_terrain_building_anim_map_tilemap[] = INCBIN_U32("graphics/battle_terrain/building/anim_map.bin.lz");
diff --git a/src/data/graphics/interface_pokeballs.h b/src/data/graphics/interface_pokeballs.h
new file mode 100644
index 000000000..fe9a4e5be
--- /dev/null
+++ b/src/data/graphics/interface_pokeballs.h
@@ -0,0 +1,37 @@
+const u32 gInterfaceGfx_PokeBall[] = INCBIN_U32("graphics/interface/ball/poke.4bpp.lz");
+const u32 gInterfacePal_PokeBall[] = INCBIN_U32("graphics/interface/ball/poke.gbapal.lz");
+
+const u32 gInterfaceGfx_GreatBall[] = INCBIN_U32("graphics/interface/ball/great.4bpp.lz");
+const u32 gInterfacePal_GreatBall[] = INCBIN_U32("graphics/interface/ball/great.gbapal.lz");
+
+const u32 gInterfaceGfx_SafariBall[] = INCBIN_U32("graphics/interface/ball/safari.4bpp.lz");
+const u32 gInterfacePal_SafariBall[] = INCBIN_U32("graphics/interface/ball/safari.gbapal.lz");
+
+const u32 gInterfaceGfx_UltraBall[] = INCBIN_U32("graphics/interface/ball/ultra.4bpp.lz");
+const u32 gInterfacePal_UltraBall[] = INCBIN_U32("graphics/interface/ball/ultra.gbapal.lz");
+
+const u32 gInterfaceGfx_MasterBall[] = INCBIN_U32("graphics/interface/ball/master.4bpp.lz");
+const u32 gInterfacePal_MasterBall[] = INCBIN_U32("graphics/interface/ball/master.gbapal.lz");
+
+const u32 gInterfaceGfx_NetBall[] = INCBIN_U32("graphics/interface/ball/net.4bpp.lz");
+const u32 gInterfacePal_NetBall[] = INCBIN_U32("graphics/interface/ball/net.gbapal.lz");
+
+const u32 gInterfaceGfx_DiveBall[] = INCBIN_U32("graphics/interface/ball/dive.4bpp.lz");
+const u32 gInterfacePal_DiveBall[] = INCBIN_U32("graphics/interface/ball/dive.gbapal.lz");
+
+const u32 gInterfaceGfx_NestBall[] = INCBIN_U32("graphics/interface/ball/nest.4bpp.lz");
+const u32 gInterfacePal_NestBall[] = INCBIN_U32("graphics/interface/ball/nest.gbapal.lz");
+
+const u32 gInterfaceGfx_RepeatBall[] = INCBIN_U32("graphics/interface/ball/repeat.4bpp.lz");
+const u32 gInterfacePal_RepeatBall[] = INCBIN_U32("graphics/interface/ball/repeat.gbapal.lz");
+
+const u32 gInterfaceGfx_TimerBall[] = INCBIN_U32("graphics/interface/ball/timer.4bpp.lz");
+const u32 gInterfacePal_TimerBall[] = INCBIN_U32("graphics/interface/ball/timer.gbapal.lz");
+
+const u32 gInterfaceGfx_LuxuryBall[] = INCBIN_U32("graphics/interface/ball/luxury.4bpp.lz");
+const u32 gInterfacePal_LuxuryBall[] = INCBIN_U32("graphics/interface/ball/luxury.gbapal.lz");
+
+const u32 gInterfaceGfx_PremierBall[] = INCBIN_U32("graphics/interface/ball/premier.4bpp.lz");
+const u32 gInterfacePal_PremierBall[] = INCBIN_U32("graphics/interface/ball/premier.gbapal.lz");
+
+const u32 gOpenPokeballGfx[] = INCBIN_U32("graphics/interface/ball_open.4bpp.lz");
diff --git a/src/data/graphics/items.h b/src/data/graphics/items.h
new file mode 100644
index 000000000..ee86b454c
--- /dev/null
+++ b/src/data/graphics/items.h
@@ -0,0 +1,672 @@
+const u32 gFile_graphics_items_icons_question_mark_sheet[] = INCBIN_U32("graphics/items/icons/question_mark.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_question_mark_palette[] = INCBIN_U32("graphics/items/icon_palettes/question_mark.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_return_to_field_arrow_sheet[] = INCBIN_U32("graphics/items/icons/return_to_field_arrow.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_return_to_field_arrow_palette[] = INCBIN_U32("graphics/items/icon_palettes/return_to_field_arrow.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_master_ball_sheet[] = INCBIN_U32("graphics/items/icons/master_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_master_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/master_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_ultra_ball_sheet[] = INCBIN_U32("graphics/items/icons/ultra_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_ultra_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/ultra_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_great_ball_sheet[] = INCBIN_U32("graphics/items/icons/great_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_great_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/great_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_poke_ball_sheet[] = INCBIN_U32("graphics/items/icons/poke_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_poke_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/poke_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_safari_ball_sheet[] = INCBIN_U32("graphics/items/icons/safari_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_safari_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/safari_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_net_ball_sheet[] = INCBIN_U32("graphics/items/icons/net_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_net_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/net_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_dive_ball_sheet[] = INCBIN_U32("graphics/items/icons/dive_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_dive_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/dive_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_nest_ball_sheet[] = INCBIN_U32("graphics/items/icons/nest_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_nest_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/nest_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_repeat_ball_sheet[] = INCBIN_U32("graphics/items/icons/repeat_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_repeat_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/repeat_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_timer_ball_sheet[] = INCBIN_U32("graphics/items/icons/timer_ball.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_luxury_ball_sheet[] = INCBIN_U32("graphics/items/icons/luxury_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_luxury_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/luxury_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_premier_ball_sheet[] = INCBIN_U32("graphics/items/icons/premier_ball.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_potion_sheet[] = INCBIN_U32("graphics/items/icons/potion.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_potion_palette[] = INCBIN_U32("graphics/items/icon_palettes/potion.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_antidote_sheet[] = INCBIN_U32("graphics/items/icons/antidote.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_antidote_palette[] = INCBIN_U32("graphics/items/icon_palettes/antidote.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_burn_heal_palette[] = INCBIN_U32("graphics/items/icon_palettes/burn_heal.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_ice_heal_palette[] = INCBIN_U32("graphics/items/icon_palettes/ice_heal.gbapal.lz");
+const u32 gFile_graphics_items_icons_status_heal_sheet[] = INCBIN_U32("graphics/items/icons/status_heal.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_awakening_palette[] = INCBIN_U32("graphics/items/icon_palettes/awakening.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_paralyze_heal_palette[] = INCBIN_U32("graphics/items/icon_palettes/paralyze_heal.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_large_potion_sheet[] = INCBIN_U32("graphics/items/icons/large_potion.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_full_restore_palette[] = INCBIN_U32("graphics/items/icon_palettes/full_restore.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_max_potion_palette[] = INCBIN_U32("graphics/items/icon_palettes/max_potion.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_hyper_potion_palette[] = INCBIN_U32("graphics/items/icon_palettes/hyper_potion.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_super_potion_palette[] = INCBIN_U32("graphics/items/icon_palettes/super_potion.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_full_heal_sheet[] = INCBIN_U32("graphics/items/icons/full_heal.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_full_heal_palette[] = INCBIN_U32("graphics/items/icon_palettes/full_heal.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_revive_sheet[] = INCBIN_U32("graphics/items/icons/revive.4bpp.lz");
+const u32 gFile_graphics_items_icons_max_revive_sheet[] = INCBIN_U32("graphics/items/icons/max_revive.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_revive_palette[] = INCBIN_U32("graphics/items/icon_palettes/revive.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_fresh_water_sheet[] = INCBIN_U32("graphics/items/icons/fresh_water.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fresh_water_palette[] = INCBIN_U32("graphics/items/icon_palettes/fresh_water.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_soda_pop_sheet[] = INCBIN_U32("graphics/items/icons/soda_pop.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_soda_pop_palette[] = INCBIN_U32("graphics/items/icon_palettes/soda_pop.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lemonade_sheet[] = INCBIN_U32("graphics/items/icons/lemonade.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lemonade_palette[] = INCBIN_U32("graphics/items/icon_palettes/lemonade.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_moomoo_milk_sheet[] = INCBIN_U32("graphics/items/icons/moomoo_milk.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_moomoo_milk_palette[] = INCBIN_U32("graphics/items/icon_palettes/moomoo_milk.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_powder_sheet[] = INCBIN_U32("graphics/items/icons/powder.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_energy_powder_palette[] = INCBIN_U32("graphics/items/icon_palettes/energy_powder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_energy_root_sheet[] = INCBIN_U32("graphics/items/icons/energy_root.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_energy_root_palette[] = INCBIN_U32("graphics/items/icon_palettes/energy_root.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_heal_powder_palette[] = INCBIN_U32("graphics/items/icon_palettes/heal_powder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_revival_herb_sheet[] = INCBIN_U32("graphics/items/icons/revival_herb.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_revival_herb_palette[] = INCBIN_U32("graphics/items/icon_palettes/revival_herb.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_ether_sheet[] = INCBIN_U32("graphics/items/icons/ether.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_ether_palette[] = INCBIN_U32("graphics/items/icon_palettes/ether.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_max_ether_palette[] = INCBIN_U32("graphics/items/icon_palettes/max_ether.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_elixir_palette[] = INCBIN_U32("graphics/items/icon_palettes/elixir.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_max_elixir_palette[] = INCBIN_U32("graphics/items/icon_palettes/max_elixir.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lava_cookie_sheet[] = INCBIN_U32("graphics/items/icons/lava_cookie.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lava_cookie_and_letter_palette[] = INCBIN_U32("graphics/items/icon_palettes/lava_cookie_and_letter.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_flute_sheet[] = INCBIN_U32("graphics/items/icons/flute.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_blue_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/blue_flute.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_yellow_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/yellow_flute.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_red_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/red_flute.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_black_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/black_flute.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_white_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/white_flute.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_berry_juice_sheet[] = INCBIN_U32("graphics/items/icons/berry_juice.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_berry_juice_palette[] = INCBIN_U32("graphics/items/icon_palettes/berry_juice.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_sacred_ash_sheet[] = INCBIN_U32("graphics/items/icons/sacred_ash.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sacred_ash_palette[] = INCBIN_U32("graphics/items/icon_palettes/sacred_ash.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_shoal_salt_palette[] = INCBIN_U32("graphics/items/icon_palettes/shoal_salt.gbapal.lz");
+const u32 gFile_graphics_items_icons_shoal_shell_sheet[] = INCBIN_U32("graphics/items/icons/shoal_shell.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_shell_palette[] = INCBIN_U32("graphics/items/icon_palettes/shell.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_shard_sheet[] = INCBIN_U32("graphics/items/icons/shard.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_red_shard_palette[] = INCBIN_U32("graphics/items/icon_palettes/red_shard.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_blue_shard_palette[] = INCBIN_U32("graphics/items/icon_palettes/blue_shard.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_yellow_shard_palette[] = INCBIN_U32("graphics/items/icon_palettes/yellow_shard.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_green_shard_palette[] = INCBIN_U32("graphics/items/icon_palettes/green_shard.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_hp_up_sheet[] = INCBIN_U32("graphics/items/icons/hp_up.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_hp_up_palette[] = INCBIN_U32("graphics/items/icon_palettes/hp_up.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_vitamin_sheet[] = INCBIN_U32("graphics/items/icons/vitamin.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_protein_palette[] = INCBIN_U32("graphics/items/icon_palettes/protein.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_iron_palette[] = INCBIN_U32("graphics/items/icon_palettes/iron.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_carbos_palette[] = INCBIN_U32("graphics/items/icon_palettes/carbos.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_calcium_palette[] = INCBIN_U32("graphics/items/icon_palettes/calcium.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_rare_candy_sheet[] = INCBIN_U32("graphics/items/icons/rare_candy.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_rare_candy_palette[] = INCBIN_U32("graphics/items/icon_palettes/rare_candy.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pp_up_sheet[] = INCBIN_U32("graphics/items/icons/pp_up.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pp_up_palette[] = INCBIN_U32("graphics/items/icon_palettes/pp_up.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_zinc_palette[] = INCBIN_U32("graphics/items/icon_palettes/zinc.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pp_max_sheet[] = INCBIN_U32("graphics/items/icons/pp_max.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pp_max_palette[] = INCBIN_U32("graphics/items/icon_palettes/pp_max.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_guard_spec_palette[] = INCBIN_U32("graphics/items/icon_palettes/guard_spec.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_dire_hit_palette[] = INCBIN_U32("graphics/items/icon_palettes/dire_hit.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_x_attack_palette[] = INCBIN_U32("graphics/items/icon_palettes/x_attack.gbapal.lz");
+const u32 gFile_graphics_items_icons_battle_stat_item_sheet[] = INCBIN_U32("graphics/items/icons/battle_stat_item.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_x_defend_palette[] = INCBIN_U32("graphics/items/icon_palettes/x_defend.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_x_speed_palette[] = INCBIN_U32("graphics/items/icon_palettes/x_speed.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_x_accuracy_palette[] = INCBIN_U32("graphics/items/icon_palettes/x_accuracy.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_x_special_palette[] = INCBIN_U32("graphics/items/icon_palettes/x_special.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_poke_doll_sheet[] = INCBIN_U32("graphics/items/icons/poke_doll.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_poke_doll_palette[] = INCBIN_U32("graphics/items/icon_palettes/poke_doll.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_fluffy_tail_sheet[] = INCBIN_U32("graphics/items/icons/fluffy_tail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fluffy_tail_palette[] = INCBIN_U32("graphics/items/icon_palettes/fluffy_tail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_repel_sheet[] = INCBIN_U32("graphics/items/icons/repel.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_super_repel_palette[] = INCBIN_U32("graphics/items/icon_palettes/super_repel.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_max_repel_palette[] = INCBIN_U32("graphics/items/icon_palettes/max_repel.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_escape_rope_sheet[] = INCBIN_U32("graphics/items/icons/escape_rope.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_escape_rope_palette[] = INCBIN_U32("graphics/items/icon_palettes/escape_rope.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_repel_palette[] = INCBIN_U32("graphics/items/icon_palettes/repel.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_sun_stone_sheet[] = INCBIN_U32("graphics/items/icons/sun_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sun_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/sun_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_moon_stone_sheet[] = INCBIN_U32("graphics/items/icons/moon_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_moon_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/moon_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_fire_stone_sheet[] = INCBIN_U32("graphics/items/icons/fire_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fire_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/fire_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_thunder_stone_sheet[] = INCBIN_U32("graphics/items/icons/thunder_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_thunder_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/thunder_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_water_stone_sheet[] = INCBIN_U32("graphics/items/icons/water_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_water_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/water_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_leaf_stone_sheet[] = INCBIN_U32("graphics/items/icons/leaf_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_leaf_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/leaf_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tiny_mushroom_sheet[] = INCBIN_U32("graphics/items/icons/tiny_mushroom.4bpp.lz");
+const u32 gFile_graphics_items_icons_big_mushroom_sheet[] = INCBIN_U32("graphics/items/icons/big_mushroom.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mushroom_palette[] = INCBIN_U32("graphics/items/icon_palettes/mushroom.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pearl_sheet[] = INCBIN_U32("graphics/items/icons/pearl.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pearl_palette[] = INCBIN_U32("graphics/items/icon_palettes/pearl.gbapal.lz");
+const u32 gFile_graphics_items_icons_big_pearl_sheet[] = INCBIN_U32("graphics/items/icons/big_pearl.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_stardust_sheet[] = INCBIN_U32("graphics/items/icons/stardust.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_star_palette[] = INCBIN_U32("graphics/items/icon_palettes/star.gbapal.lz");
+const u32 gFile_graphics_items_icons_star_piece_sheet[] = INCBIN_U32("graphics/items/icons/star_piece.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_nugget_sheet[] = INCBIN_U32("graphics/items/icons/nugget.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_nugget_palette[] = INCBIN_U32("graphics/items/icon_palettes/nugget.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_heart_scale_sheet[] = INCBIN_U32("graphics/items/icons/heart_scale.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_heart_scale_palette[] = INCBIN_U32("graphics/items/icon_palettes/heart_scale.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_orange_mail_sheet[] = INCBIN_U32("graphics/items/icons/orange_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_orange_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/orange_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_harbor_mail_sheet[] = INCBIN_U32("graphics/items/icons/harbor_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_harbor_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/harbor_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_glitter_mail_sheet[] = INCBIN_U32("graphics/items/icons/glitter_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_glitter_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/glitter_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_mech_mail_sheet[] = INCBIN_U32("graphics/items/icons/mech_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mech_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/mech_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_wood_mail_sheet[] = INCBIN_U32("graphics/items/icons/wood_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_wood_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/wood_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_wave_mail_sheet[] = INCBIN_U32("graphics/items/icons/wave_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_wave_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/wave_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_bead_mail_sheet[] = INCBIN_U32("graphics/items/icons/bead_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_bead_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/bead_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_shadow_mail_sheet[] = INCBIN_U32("graphics/items/icons/shadow_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_shadow_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/shadow_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tropic_mail_sheet[] = INCBIN_U32("graphics/items/icons/tropic_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_tropic_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/tropic_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_dream_mail_sheet[] = INCBIN_U32("graphics/items/icons/dream_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_dream_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/dream_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_fab_mail_sheet[] = INCBIN_U32("graphics/items/icons/fab_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fab_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/fab_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_retro_mail_sheet[] = INCBIN_U32("graphics/items/icons/retro_mail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_retro_mail_palette[] = INCBIN_U32("graphics/items/icon_palettes/retro_mail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_cheri_berry_sheet[] = INCBIN_U32("graphics/items/icons/cheri_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_cheri_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/cheri_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_chesto_berry_sheet[] = INCBIN_U32("graphics/items/icons/chesto_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_chesto_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/chesto_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pecha_berry_sheet[] = INCBIN_U32("graphics/items/icons/pecha_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pecha_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/pecha_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_rawst_berry_sheet[] = INCBIN_U32("graphics/items/icons/rawst_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_rawst_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/rawst_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_aspear_berry_sheet[] = INCBIN_U32("graphics/items/icons/aspear_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_aspear_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/aspear_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_leppa_berry_sheet[] = INCBIN_U32("graphics/items/icons/leppa_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_leppa_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/leppa_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_oran_berry_sheet[] = INCBIN_U32("graphics/items/icons/oran_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_oran_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/oran_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_persim_berry_sheet[] = INCBIN_U32("graphics/items/icons/persim_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_persim_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/persim_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lum_berry_sheet[] = INCBIN_U32("graphics/items/icons/lum_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lum_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/lum_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_sitrus_berry_sheet[] = INCBIN_U32("graphics/items/icons/sitrus_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sitrus_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/sitrus_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_figy_berry_sheet[] = INCBIN_U32("graphics/items/icons/figy_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_figy_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/figy_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_wiki_berry_sheet[] = INCBIN_U32("graphics/items/icons/wiki_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_wiki_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/wiki_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_mago_berry_sheet[] = INCBIN_U32("graphics/items/icons/mago_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mago_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/mago_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_aguav_berry_sheet[] = INCBIN_U32("graphics/items/icons/aguav_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_aguav_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/aguav_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_iapapa_berry_sheet[] = INCBIN_U32("graphics/items/icons/iapapa_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_iapapa_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/iapapa_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_razz_berry_sheet[] = INCBIN_U32("graphics/items/icons/razz_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_razz_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/razz_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_bluk_berry_sheet[] = INCBIN_U32("graphics/items/icons/bluk_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_bluk_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/bluk_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_nanab_berry_sheet[] = INCBIN_U32("graphics/items/icons/nanab_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_nanab_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/nanab_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_wepear_berry_sheet[] = INCBIN_U32("graphics/items/icons/wepear_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_wepear_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/wepear_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pinap_berry_sheet[] = INCBIN_U32("graphics/items/icons/pinap_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pinap_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/pinap_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pomeg_berry_sheet[] = INCBIN_U32("graphics/items/icons/pomeg_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pomeg_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/pomeg_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_kelpsy_berry_sheet[] = INCBIN_U32("graphics/items/icons/kelpsy_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_kelpsy_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/kelpsy_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_qualot_berry_sheet[] = INCBIN_U32("graphics/items/icons/qualot_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_qualot_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/qualot_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_hondew_berry_sheet[] = INCBIN_U32("graphics/items/icons/hondew_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_hondew_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/hondew_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_grepa_berry_sheet[] = INCBIN_U32("graphics/items/icons/grepa_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_grepa_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/grepa_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tamato_berry_sheet[] = INCBIN_U32("graphics/items/icons/tamato_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_tamato_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/tamato_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_cornn_berry_sheet[] = INCBIN_U32("graphics/items/icons/cornn_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_cornn_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/cornn_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_magost_berry_sheet[] = INCBIN_U32("graphics/items/icons/magost_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_magost_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/magost_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_rabuta_berry_sheet[] = INCBIN_U32("graphics/items/icons/rabuta_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_rabuta_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/rabuta_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_nomel_berry_sheet[] = INCBIN_U32("graphics/items/icons/nomel_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_nomel_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/nomel_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_spelon_berry_sheet[] = INCBIN_U32("graphics/items/icons/spelon_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_spelon_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/spelon_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pamtre_berry_sheet[] = INCBIN_U32("graphics/items/icons/pamtre_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pamtre_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/pamtre_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_watmel_berry_sheet[] = INCBIN_U32("graphics/items/icons/watmel_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_watmel_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/watmel_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_durin_berry_sheet[] = INCBIN_U32("graphics/items/icons/durin_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_durin_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/durin_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_belue_berry_sheet[] = INCBIN_U32("graphics/items/icons/belue_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_belue_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/belue_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_liechi_berry_sheet[] = INCBIN_U32("graphics/items/icons/liechi_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_liechi_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/liechi_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_ganlon_berry_sheet[] = INCBIN_U32("graphics/items/icons/ganlon_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_ganlon_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/ganlon_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_salac_berry_sheet[] = INCBIN_U32("graphics/items/icons/salac_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_salac_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/salac_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_petaya_berry_sheet[] = INCBIN_U32("graphics/items/icons/petaya_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_petaya_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/petaya_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_apicot_berry_sheet[] = INCBIN_U32("graphics/items/icons/apicot_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_apicot_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/apicot_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lansat_berry_sheet[] = INCBIN_U32("graphics/items/icons/lansat_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lansat_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/lansat_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_starf_berry_sheet[] = INCBIN_U32("graphics/items/icons/starf_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_starf_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/starf_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_enigma_berry_sheet[] = INCBIN_U32("graphics/items/icons/enigma_berry.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_enigma_berry_palette[] = INCBIN_U32("graphics/items/icon_palettes/enigma_berry.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_bright_powder_sheet[] = INCBIN_U32("graphics/items/icons/bright_powder.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_bright_powder_palette[] = INCBIN_U32("graphics/items/icon_palettes/bright_powder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_in_battle_herb_sheet[] = INCBIN_U32("graphics/items/icons/in_battle_herb.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_white_herb_palette[] = INCBIN_U32("graphics/items/icon_palettes/white_herb.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_macho_brace_sheet[] = INCBIN_U32("graphics/items/icons/macho_brace.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_macho_brace_palette[] = INCBIN_U32("graphics/items/icon_palettes/macho_brace.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_exp_share_sheet[] = INCBIN_U32("graphics/items/icons/exp_share.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_exp_share_palette[] = INCBIN_U32("graphics/items/icon_palettes/exp_share.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_quick_claw_sheet[] = INCBIN_U32("graphics/items/icons/quick_claw.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_quick_claw_palette[] = INCBIN_U32("graphics/items/icon_palettes/quick_claw.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_soothe_bell_sheet[] = INCBIN_U32("graphics/items/icons/soothe_bell.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_soothe_bell_palette[] = INCBIN_U32("graphics/items/icon_palettes/soothe_bell.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_mental_herb_palette[] = INCBIN_U32("graphics/items/icon_palettes/mental_herb.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_choice_band_sheet[] = INCBIN_U32("graphics/items/icons/choice_band.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_choice_band_palette[] = INCBIN_U32("graphics/items/icon_palettes/choice_band.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_kings_rock_sheet[] = INCBIN_U32("graphics/items/icons/kings_rock.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_kings_rock_palette[] = INCBIN_U32("graphics/items/icon_palettes/kings_rock.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_silver_powder_sheet[] = INCBIN_U32("graphics/items/icons/silver_powder.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_silver_powder_palette[] = INCBIN_U32("graphics/items/icon_palettes/silver_powder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_amulet_coin_sheet[] = INCBIN_U32("graphics/items/icons/amulet_coin.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_amulet_coin_palette[] = INCBIN_U32("graphics/items/icon_palettes/amulet_coin.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_cleanse_tag_sheet[] = INCBIN_U32("graphics/items/icons/cleanse_tag.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_cleanse_tag_palette[] = INCBIN_U32("graphics/items/icon_palettes/cleanse_tag.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_soul_dew_sheet[] = INCBIN_U32("graphics/items/icons/soul_dew.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_soul_dew_palette[] = INCBIN_U32("graphics/items/icon_palettes/soul_dew.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_deep_sea_tooth_sheet[] = INCBIN_U32("graphics/items/icons/deep_sea_tooth.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_deep_sea_tooth_palette[] = INCBIN_U32("graphics/items/icon_palettes/deep_sea_tooth.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_deep_sea_scale_sheet[] = INCBIN_U32("graphics/items/icons/deep_sea_scale.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_deep_sea_scale_palette[] = INCBIN_U32("graphics/items/icon_palettes/deep_sea_scale.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_smoke_ball_sheet[] = INCBIN_U32("graphics/items/icons/smoke_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_smoke_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/smoke_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_everstone_sheet[] = INCBIN_U32("graphics/items/icons/everstone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_everstone_palette[] = INCBIN_U32("graphics/items/icon_palettes/everstone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_focus_band_sheet[] = INCBIN_U32("graphics/items/icons/focus_band.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_focus_band_palette[] = INCBIN_U32("graphics/items/icon_palettes/focus_band.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lucky_egg_sheet[] = INCBIN_U32("graphics/items/icons/lucky_egg.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lucky_egg_palette[] = INCBIN_U32("graphics/items/icon_palettes/lucky_egg.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_scope_lens_sheet[] = INCBIN_U32("graphics/items/icons/scope_lens.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_scope_lens_palette[] = INCBIN_U32("graphics/items/icon_palettes/scope_lens.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_metal_coat_sheet[] = INCBIN_U32("graphics/items/icons/metal_coat.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_metal_coat_palette[] = INCBIN_U32("graphics/items/icon_palettes/metal_coat.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_leftovers_sheet[] = INCBIN_U32("graphics/items/icons/leftovers.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_leftovers_palette[] = INCBIN_U32("graphics/items/icon_palettes/leftovers.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_dragon_scale_sheet[] = INCBIN_U32("graphics/items/icons/dragon_scale.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_dragon_scale_palette[] = INCBIN_U32("graphics/items/icon_palettes/dragon_scale.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_light_ball_sheet[] = INCBIN_U32("graphics/items/icons/light_ball.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_light_ball_palette[] = INCBIN_U32("graphics/items/icon_palettes/light_ball.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_soft_sand_sheet[] = INCBIN_U32("graphics/items/icons/soft_sand.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_soft_sand_palette[] = INCBIN_U32("graphics/items/icon_palettes/soft_sand.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_hard_stone_sheet[] = INCBIN_U32("graphics/items/icons/hard_stone.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_hard_stone_palette[] = INCBIN_U32("graphics/items/icon_palettes/hard_stone.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_miracle_seed_sheet[] = INCBIN_U32("graphics/items/icons/miracle_seed.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_miracle_seed_palette[] = INCBIN_U32("graphics/items/icon_palettes/miracle_seed.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_black_glasses_sheet[] = INCBIN_U32("graphics/items/icons/black_glasses.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_black_type_enhancing_item_palette[] = INCBIN_U32("graphics/items/icon_palettes/black_type_enhancing_item.gbapal.lz");
+const u32 gFile_graphics_items_icons_black_belt_sheet[] = INCBIN_U32("graphics/items/icons/black_belt.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_magnet_sheet[] = INCBIN_U32("graphics/items/icons/magnet.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_magnet_palette[] = INCBIN_U32("graphics/items/icon_palettes/magnet.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_mystic_water_sheet[] = INCBIN_U32("graphics/items/icons/mystic_water.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mystic_water_palette[] = INCBIN_U32("graphics/items/icon_palettes/mystic_water.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_sharp_beak_sheet[] = INCBIN_U32("graphics/items/icons/sharp_beak.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sharp_beak_palette[] = INCBIN_U32("graphics/items/icon_palettes/sharp_beak.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_poison_barb_sheet[] = INCBIN_U32("graphics/items/icons/poison_barb.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_poison_barb_palette[] = INCBIN_U32("graphics/items/icon_palettes/poison_barb.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_never_melt_ice_sheet[] = INCBIN_U32("graphics/items/icons/never_melt_ice.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_never_melt_ice_palette[] = INCBIN_U32("graphics/items/icon_palettes/never_melt_ice.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_spell_tag_sheet[] = INCBIN_U32("graphics/items/icons/spell_tag.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_spell_tag_palette[] = INCBIN_U32("graphics/items/icon_palettes/spell_tag.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_twisted_spoon_sheet[] = INCBIN_U32("graphics/items/icons/twisted_spoon.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_twisted_spoon_palette[] = INCBIN_U32("graphics/items/icon_palettes/twisted_spoon.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_charcoal_sheet[] = INCBIN_U32("graphics/items/icons/charcoal.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_charcoal_palette[] = INCBIN_U32("graphics/items/icon_palettes/charcoal.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_dragon_fang_sheet[] = INCBIN_U32("graphics/items/icons/dragon_fang.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_dragon_fang_palette[] = INCBIN_U32("graphics/items/icon_palettes/dragon_fang.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_silk_scarf_sheet[] = INCBIN_U32("graphics/items/icons/silk_scarf.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_silk_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/silk_scarf.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_up_grade_sheet[] = INCBIN_U32("graphics/items/icons/up_grade.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_up_grade_palette[] = INCBIN_U32("graphics/items/icon_palettes/up_grade.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_shell_bell_sheet[] = INCBIN_U32("graphics/items/icons/shell_bell.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_sea_incense_sheet[] = INCBIN_U32("graphics/items/icons/sea_incense.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sea_incense_palette[] = INCBIN_U32("graphics/items/icon_palettes/sea_incense.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lax_incense_sheet[] = INCBIN_U32("graphics/items/icons/lax_incense.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lax_incense_palette[] = INCBIN_U32("graphics/items/icon_palettes/lax_incense.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lucky_punch_sheet[] = INCBIN_U32("graphics/items/icons/lucky_punch.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_lucky_punch_palette[] = INCBIN_U32("graphics/items/icon_palettes/lucky_punch.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_metal_powder_sheet[] = INCBIN_U32("graphics/items/icons/metal_powder.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_metal_powder_palette[] = INCBIN_U32("graphics/items/icon_palettes/metal_powder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_thick_club_sheet[] = INCBIN_U32("graphics/items/icons/thick_club.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_thick_club_palette[] = INCBIN_U32("graphics/items/icon_palettes/thick_club.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_stick_sheet[] = INCBIN_U32("graphics/items/icons/stick.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_stick_palette[] = INCBIN_U32("graphics/items/icon_palettes/stick.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_scarf_sheet[] = INCBIN_U32("graphics/items/icons/scarf.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_red_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/red_scarf.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_blue_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/blue_scarf.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_pink_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/pink_scarf.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_green_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/green_scarf.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_yellow_scarf_palette[] = INCBIN_U32("graphics/items/icon_palettes/yellow_scarf.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_mach_bike_sheet[] = INCBIN_U32("graphics/items/icons/mach_bike.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mach_bike_palette[] = INCBIN_U32("graphics/items/icon_palettes/mach_bike.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_coin_case_sheet[] = INCBIN_U32("graphics/items/icons/coin_case.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_coin_case_palette[] = INCBIN_U32("graphics/items/icon_palettes/coin_case.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_itemfinder_sheet[] = INCBIN_U32("graphics/items/icons/itemfinder.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_itemfinder_palette[] = INCBIN_U32("graphics/items/icon_palettes/itemfinder.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_old_rod_sheet[] = INCBIN_U32("graphics/items/icons/old_rod.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_old_rod_palette[] = INCBIN_U32("graphics/items/icon_palettes/old_rod.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_good_rod_sheet[] = INCBIN_U32("graphics/items/icons/good_rod.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_good_rod_palette[] = INCBIN_U32("graphics/items/icon_palettes/good_rod.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_super_rod_sheet[] = INCBIN_U32("graphics/items/icons/super_rod.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_super_rod_palette[] = INCBIN_U32("graphics/items/icon_palettes/super_rod.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_ss_ticket_sheet[] = INCBIN_U32("graphics/items/icons/ss_ticket.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_ss_ticket_palette[] = INCBIN_U32("graphics/items/icon_palettes/ss_ticket.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_contest_pass_sheet[] = INCBIN_U32("graphics/items/icons/contest_pass.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_contest_pass_palette[] = INCBIN_U32("graphics/items/icon_palettes/contest_pass.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_wailmer_pail_sheet[] = INCBIN_U32("graphics/items/icons/wailmer_pail.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_wailmer_pail_palette[] = INCBIN_U32("graphics/items/icon_palettes/wailmer_pail.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_devon_goods_sheet[] = INCBIN_U32("graphics/items/icons/devon_goods.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_devon_goods_palette[] = INCBIN_U32("graphics/items/icon_palettes/devon_goods.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_soot_sack_sheet[] = INCBIN_U32("graphics/items/icons/soot_sack.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_soot_sack_palette[] = INCBIN_U32("graphics/items/icon_palettes/soot_sack.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_basement_key_sheet[] = INCBIN_U32("graphics/items/icons/basement_key.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_old_key_palette[] = INCBIN_U32("graphics/items/icon_palettes/old_key.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_acro_bike_sheet[] = INCBIN_U32("graphics/items/icons/acro_bike.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_acro_bike_palette[] = INCBIN_U32("graphics/items/icon_palettes/acro_bike.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_pokeblock_case_sheet[] = INCBIN_U32("graphics/items/icons/pokeblock_case.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_pokeblock_case_palette[] = INCBIN_U32("graphics/items/icon_palettes/pokeblock_case.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_letter_sheet[] = INCBIN_U32("graphics/items/icons/letter.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_eon_ticket_sheet[] = INCBIN_U32("graphics/items/icons/eon_ticket.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_eon_ticket_palette[] = INCBIN_U32("graphics/items/icon_palettes/eon_ticket.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_orb_sheet[] = INCBIN_U32("graphics/items/icons/orb.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_red_orb_palette[] = INCBIN_U32("graphics/items/icon_palettes/red_orb.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_blue_orb_palette[] = INCBIN_U32("graphics/items/icon_palettes/blue_orb.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_scanner_sheet[] = INCBIN_U32("graphics/items/icons/scanner.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_scanner_palette[] = INCBIN_U32("graphics/items/icon_palettes/scanner.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_go_goggles_sheet[] = INCBIN_U32("graphics/items/icons/go_goggles.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_go_goggles_palette[] = INCBIN_U32("graphics/items/icon_palettes/go_goggles.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_meteorite_sheet[] = INCBIN_U32("graphics/items/icons/meteorite.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_meteorite_palette[] = INCBIN_U32("graphics/items/icon_palettes/meteorite.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_room1_key_sheet[] = INCBIN_U32("graphics/items/icons/room1_key.4bpp.lz");
+const u32 gFile_graphics_items_icons_room2_key_sheet[] = INCBIN_U32("graphics/items/icons/room2_key.4bpp.lz");
+const u32 gFile_graphics_items_icons_room4_key_sheet[] = INCBIN_U32("graphics/items/icons/room4_key.4bpp.lz");
+const u32 gFile_graphics_items_icons_room6_key_sheet[] = INCBIN_U32("graphics/items/icons/room6_key.4bpp.lz");
+const u32 gFile_graphics_items_icons_storage_key_sheet[] = INCBIN_U32("graphics/items/icons/storage_key.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_root_fossil_sheet[] = INCBIN_U32("graphics/items/icons/root_fossil.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_hoenn_fossil_palette[] = INCBIN_U32("graphics/items/icon_palettes/hoenn_fossil.gbapal.lz");
+const u32 gFile_graphics_items_icons_claw_fossil_sheet[] = INCBIN_U32("graphics/items/icons/claw_fossil.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_devon_scope_sheet[] = INCBIN_U32("graphics/items/icons/devon_scope.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_devon_scope_palette[] = INCBIN_U32("graphics/items/icon_palettes/devon_scope.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tm_sheet[] = INCBIN_U32("graphics/items/icons/tm.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fighting_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/fighting_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_dragon_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/dragon_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_water_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/water_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_psychic_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/psychic_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_normal_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/normal_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_poison_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/poison_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_ice_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/ice_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_grass_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/grass_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_fire_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/fire_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_dark_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/dark_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_steel_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/steel_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_electric_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/electric_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_ground_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/ground_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_ghost_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/ghost_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_rock_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/rock_tm_hm.gbapal.lz");
+const u32 gFile_graphics_items_icon_palettes_flying_tm_hm_palette[] = INCBIN_U32("graphics/items/icon_palettes/flying_tm_hm.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_oaks_parcel_sheet[] = INCBIN_U32("graphics/items/icons/oaks_parcel.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_oaks_parcel_palette[] = INCBIN_U32("graphics/items/icon_palettes/oaks_parcel.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_poke_flute_sheet[] = INCBIN_U32("graphics/items/icons/poke_flute.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_poke_flute_palette[] = INCBIN_U32("graphics/items/icon_palettes/poke_flute.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_secret_key_sheet[] = INCBIN_U32("graphics/items/icons/secret_key.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_secret_key_palette[] = INCBIN_U32("graphics/items/icon_palettes/secret_key.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_bike_voucher_sheet[] = INCBIN_U32("graphics/items/icons/bike_voucher.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_bike_voucher_palette[] = INCBIN_U32("graphics/items/icon_palettes/bike_voucher.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_gold_teeth_sheet[] = INCBIN_U32("graphics/items/icons/gold_teeth.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_gold_teeth_palette[] = INCBIN_U32("graphics/items/icon_palettes/gold_teeth.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_old_amber_sheet[] = INCBIN_U32("graphics/items/icons/old_amber.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_old_amber_palette[] = INCBIN_U32("graphics/items/icon_palettes/old_amber.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_card_key_sheet[] = INCBIN_U32("graphics/items/icons/card_key.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_card_key_palette[] = INCBIN_U32("graphics/items/icon_palettes/card_key.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_lift_key_sheet[] = INCBIN_U32("graphics/items/icons/lift_key.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_key_palette[] = INCBIN_U32("graphics/items/icon_palettes/key.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_helix_fossil_sheet[] = INCBIN_U32("graphics/items/icons/helix_fossil.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_kanto_fossil_palette[] = INCBIN_U32("graphics/items/icon_palettes/kanto_fossil.gbapal.lz");
+const u32 gFile_graphics_items_icons_dome_fossil_sheet[] = INCBIN_U32("graphics/items/icons/dome_fossil.4bpp.lz");
+
+const u32 gFile_graphics_items_icons_silph_scope_sheet[] = INCBIN_U32("graphics/items/icons/silph_scope.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_silph_scope_palette[] = INCBIN_U32("graphics/items/icon_palettes/silph_scope.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_bicycle_sheet[] = INCBIN_U32("graphics/items/icons/bicycle.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_bicycle_palette[] = INCBIN_U32("graphics/items/icon_palettes/bicycle.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_town_map_sheet[] = INCBIN_U32("graphics/items/icons/town_map.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_town_map_palette[] = INCBIN_U32("graphics/items/icon_palettes/town_map.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_vs_seeker_sheet[] = INCBIN_U32("graphics/items/icons/vs_seeker.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_vs_seeker_palette[] = INCBIN_U32("graphics/items/icon_palettes/vs_seeker.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_fame_checker_sheet[] = INCBIN_U32("graphics/items/icons/fame_checker.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_fame_checker_palette[] = INCBIN_U32("graphics/items/icon_palettes/fame_checker.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tm_case_sheet[] = INCBIN_U32("graphics/items/icons/tm_case.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_tm_case_palette[] = INCBIN_U32("graphics/items/icon_palettes/tm_case.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_berry_pouch_sheet[] = INCBIN_U32("graphics/items/icons/berry_pouch.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_berry_pouch_palette[] = INCBIN_U32("graphics/items/icon_palettes/berry_pouch.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_teachy_tv_sheet[] = INCBIN_U32("graphics/items/icons/teachy_tv.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_teachy_tv_palette[] = INCBIN_U32("graphics/items/icon_palettes/teachy_tv.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tri_pass_sheet[] = INCBIN_U32("graphics/items/icons/tri_pass.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_tri_pass_palette[] = INCBIN_U32("graphics/items/icon_palettes/tri_pass.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_rainbow_pass_sheet[] = INCBIN_U32("graphics/items/icons/rainbow_pass.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_rainbow_pass_palette[] = INCBIN_U32("graphics/items/icon_palettes/rainbow_pass.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_tea_sheet[] = INCBIN_U32("graphics/items/icons/tea.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_tea_palette[] = INCBIN_U32("graphics/items/icon_palettes/tea.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_mystic_ticket_sheet[] = INCBIN_U32("graphics/items/icons/mystic_ticket.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_mystic_ticket_palette[] = INCBIN_U32("graphics/items/icon_palettes/mystic_ticket.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_aurora_ticket_sheet[] = INCBIN_U32("graphics/items/icons/aurora_ticket.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_aurora_ticket_palette[] = INCBIN_U32("graphics/items/icon_palettes/aurora_ticket.gbapal.lz");
+
+const u32 gFile_graphics_items_icons_powder_jar_sheet[] = INCBIN_U32("graphics/items/icons/powder_jar.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_powder_jar_palette[] = INCBIN_U32("graphics/items/icon_palettes/powder_jar.gbapal.lz");
+
+const u32 gFile_graphics_items_icon_palettes_ruby_palette[] = INCBIN_U32("graphics/items/icon_palettes/ruby.gbapal.lz");
+const u32 gFile_graphics_items_icons_gem_sheet[] = INCBIN_U32("graphics/items/icons/gem.4bpp.lz");
+const u32 gFile_graphics_items_icon_palettes_sapphire_palette[] = INCBIN_U32("graphics/items/icon_palettes/sapphire.gbapal.lz");
diff --git a/src/data/graphics/mail.h b/src/data/graphics/mail.h
new file mode 100644
index 000000000..86d827b49
--- /dev/null
+++ b/src/data/graphics/mail.h
@@ -0,0 +1,38 @@
+const u16 gFile_graphics_mail_orange_palette_pal[] = INCBIN_U16("graphics/mail/orange/palette.gbapal");
+const u16 gFile_graphics_mail_harbor_palette_pal[] = INCBIN_U16("graphics/mail/harbor/palette.gbapal");
+const u16 gFile_graphics_mail_glitter_palette_pal[] = INCBIN_U16("graphics/mail/glitter/palette.gbapal");
+const u16 gFile_graphics_mail_mech_palette_pal[] = INCBIN_U16("graphics/mail/mech/palette.gbapal");
+const u16 gFile_graphics_mail_wood_palette_pal[] = INCBIN_U16("graphics/mail/wood/palette.gbapal");
+const u16 gFile_graphics_mail_wave_palette_pal[] = INCBIN_U16("graphics/mail/wave/palette.gbapal");
+const u16 gFile_graphics_mail_bead_palette_pal[] = INCBIN_U16("graphics/mail/bead/palette.gbapal");
+const u16 gFile_graphics_mail_shadow_palette_pal[] = INCBIN_U16("graphics/mail/shadow/palette.gbapal");
+const u16 gFile_graphics_mail_tropic_palette_pal[] = INCBIN_U16("graphics/mail/tropic/palette.gbapal");
+const u16 gFile_graphics_mail_dream_palette_pal[] = INCBIN_U16("graphics/mail/dream/palette.gbapal");
+const u16 gFile_graphics_mail_fab_palette_pal[] = INCBIN_U16("graphics/mail/fab/palette.gbapal");
+const u16 gFile_graphics_mail_retro_palette_pal[] = INCBIN_U16("graphics/mail/retro/palette.gbapal");
+
+const u32 gFile_graphics_mail_orange_tiles_sheet[] = INCBIN_U32("graphics/mail/orange/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_harbor_tiles_sheet[] = INCBIN_U32("graphics/mail/harbor/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_glitter_tiles_sheet[] = INCBIN_U32("graphics/mail/glitter/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_mech_tiles_sheet[] = INCBIN_U32("graphics/mail/mech/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_wood_tiles_sheet[] = INCBIN_U32("graphics/mail/wood/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_wave_tiles_sheet[] = INCBIN_U32("graphics/mail/wave/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_bead_tiles_sheet[] = INCBIN_U32("graphics/mail/bead/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_shadow_tiles_sheet[] = INCBIN_U32("graphics/mail/shadow/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_tropic_tiles_sheet[] = INCBIN_U32("graphics/mail/tropic/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_dream_tiles_sheet[] = INCBIN_U32("graphics/mail/dream/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_fab_tiles_sheet[] = INCBIN_U32("graphics/mail/fab/tiles.4bpp.lz");
+const u32 gFile_graphics_mail_retro_tiles_sheet[] = INCBIN_U32("graphics/mail/retro/tiles.4bpp.lz");
+
+const u32 gFile_graphics_mail_orange_map_tilemap[] = INCBIN_U32("graphics/mail/orange/map.bin.lz");
+const u32 gFile_graphics_mail_harbor_map_tilemap[] = INCBIN_U32("graphics/mail/harbor/map.bin.lz");
+const u32 gFile_graphics_mail_glitter_map_tilemap[] = INCBIN_U32("graphics/mail/glitter/map.bin.lz");
+const u32 gFile_graphics_mail_mech_map_tilemap[] = INCBIN_U32("graphics/mail/mech/map.bin.lz");
+const u32 gFile_graphics_mail_wood_map_tilemap[] = INCBIN_U32("graphics/mail/wood/map.bin.lz");
+const u32 gFile_graphics_mail_wave_map_tilemap[] = INCBIN_U32("graphics/mail/wave/map.bin.lz");
+const u32 gFile_graphics_mail_bead_map_tilemap[] = INCBIN_U32("graphics/mail/bead/map.bin.lz");
+const u32 gFile_graphics_mail_shadow_map_tilemap[] = INCBIN_U32("graphics/mail/shadow/map.bin.lz");
+const u32 gFile_graphics_mail_tropic_map_tilemap[] = INCBIN_U32("graphics/mail/tropic/map.bin.lz");
+const u32 gFile_graphics_mail_dream_map_tilemap[] = INCBIN_U32("graphics/mail/dream/map.bin.lz");
+const u32 gFile_graphics_mail_fab_map_tilemap[] = INCBIN_U32("graphics/mail/fab/map.bin.lz");
+const u32 gFile_graphics_mail_retro_map_tilemap[] = INCBIN_U32("graphics/mail/retro/map.bin.lz");
diff --git a/src/data/graphics/pokemon.h b/src/data/graphics/pokemon.h
new file mode 100644
index 000000000..edb7e982d
--- /dev/null
+++ b/src/data/graphics/pokemon.h
@@ -0,0 +1,2833 @@
+const u32 gMonFrontPic_Bulbasaur[] = INCBIN_U32("graphics/pokemon/bulbasaur/front.4bpp.lz");
+const u32 gMonPalette_Bulbasaur[] = INCBIN_U32("graphics/pokemon/bulbasaur/normal.gbapal.lz");
+const u32 gMonBackPic_Bulbasaur[] = INCBIN_U32("graphics/pokemon/bulbasaur/back.4bpp.lz");
+const u32 gMonShinyPalette_Bulbasaur[] = INCBIN_U32("graphics/pokemon/bulbasaur/shiny.gbapal.lz");
+const u8 gMonIcon_Bulbasaur[] = INCBIN_U8("graphics/pokemon/bulbasaur/icon.4bpp");
+const u8 gMonFootprint_Bulbasaur[] = INCBIN_U8("graphics/pokemon/bulbasaur/footprint.1bpp");
+
+const u32 gMonFrontPic_Ivysaur[] = INCBIN_U32("graphics/pokemon/ivysaur/front.4bpp.lz");
+const u32 gMonPalette_Ivysaur[] = INCBIN_U32("graphics/pokemon/ivysaur/normal.gbapal.lz");
+const u32 gMonBackPic_Ivysaur[] = INCBIN_U32("graphics/pokemon/ivysaur/back.4bpp.lz");
+const u32 gMonShinyPalette_Ivysaur[] = INCBIN_U32("graphics/pokemon/ivysaur/shiny.gbapal.lz");
+const u8 gMonIcon_Ivysaur[] = INCBIN_U8("graphics/pokemon/ivysaur/icon.4bpp");
+const u8 gMonFootprint_Ivysaur[] = INCBIN_U8("graphics/pokemon/ivysaur/footprint.1bpp");
+
+const u32 gMonFrontPic_Venusaur[] = INCBIN_U32("graphics/pokemon/venusaur/front.4bpp.lz");
+const u32 gMonPalette_Venusaur[] = INCBIN_U32("graphics/pokemon/venusaur/normal.gbapal.lz");
+const u32 gMonBackPic_Venusaur[] = INCBIN_U32("graphics/pokemon/venusaur/back.4bpp.lz");
+const u32 gMonShinyPalette_Venusaur[] = INCBIN_U32("graphics/pokemon/venusaur/shiny.gbapal.lz");
+const u8 gMonIcon_Venusaur[] = INCBIN_U8("graphics/pokemon/venusaur/icon.4bpp");
+const u8 gMonFootprint_Venusaur[] = INCBIN_U8("graphics/pokemon/venusaur/footprint.1bpp");
+
+const u32 gMonFrontPic_Charmander[] = INCBIN_U32("graphics/pokemon/charmander/front.4bpp.lz");
+const u32 gMonPalette_Charmander[] = INCBIN_U32("graphics/pokemon/charmander/normal.gbapal.lz");
+const u32 gMonBackPic_Charmander[] = INCBIN_U32("graphics/pokemon/charmander/back.4bpp.lz");
+const u32 gMonShinyPalette_Charmander[] = INCBIN_U32("graphics/pokemon/charmander/shiny.gbapal.lz");
+const u8 gMonIcon_Charmander[] = INCBIN_U8("graphics/pokemon/charmander/icon.4bpp");
+const u8 gMonFootprint_Charmander[] = INCBIN_U8("graphics/pokemon/charmander/footprint.1bpp");
+
+const u32 gMonFrontPic_Charmeleon[] = INCBIN_U32("graphics/pokemon/charmeleon/front.4bpp.lz");
+const u32 gMonPalette_Charmeleon[] = INCBIN_U32("graphics/pokemon/charmeleon/normal.gbapal.lz");
+const u32 gMonBackPic_Charmeleon[] = INCBIN_U32("graphics/pokemon/charmeleon/back.4bpp.lz");
+const u32 gMonShinyPalette_Charmeleon[] = INCBIN_U32("graphics/pokemon/charmeleon/shiny.gbapal.lz");
+const u8 gMonIcon_Charmeleon[] = INCBIN_U8("graphics/pokemon/charmeleon/icon.4bpp");
+const u8 gMonFootprint_Charmeleon[] = INCBIN_U8("graphics/pokemon/charmeleon/footprint.1bpp");
+
+const u32 gMonFrontPic_Charizard[] = INCBIN_U32("graphics/pokemon/charizard/front.4bpp.lz");
+const u32 gMonPalette_Charizard[] = INCBIN_U32("graphics/pokemon/charizard/normal.gbapal.lz");
+const u32 gMonBackPic_Charizard[] = INCBIN_U32("graphics/pokemon/charizard/back.4bpp.lz");
+const u32 gMonShinyPalette_Charizard[] = INCBIN_U32("graphics/pokemon/charizard/shiny.gbapal.lz");
+const u8 gMonIcon_Charizard[] = INCBIN_U8("graphics/pokemon/charizard/icon.4bpp");
+const u8 gMonFootprint_Charizard[] = INCBIN_U8("graphics/pokemon/charizard/footprint.1bpp");
+
+const u32 gMonFrontPic_Squirtle[] = INCBIN_U32("graphics/pokemon/squirtle/front.4bpp.lz");
+const u32 gMonPalette_Squirtle[] = INCBIN_U32("graphics/pokemon/squirtle/normal.gbapal.lz");
+const u32 gMonBackPic_Squirtle[] = INCBIN_U32("graphics/pokemon/squirtle/back.4bpp.lz");
+const u32 gMonShinyPalette_Squirtle[] = INCBIN_U32("graphics/pokemon/squirtle/shiny.gbapal.lz");
+const u8 gMonIcon_Squirtle[] = INCBIN_U8("graphics/pokemon/squirtle/icon.4bpp");
+const u8 gMonFootprint_Squirtle[] = INCBIN_U8("graphics/pokemon/squirtle/footprint.1bpp");
+
+const u32 gMonFrontPic_Wartortle[] = INCBIN_U32("graphics/pokemon/wartortle/front.4bpp.lz");
+const u32 gMonPalette_Wartortle[] = INCBIN_U32("graphics/pokemon/wartortle/normal.gbapal.lz");
+const u32 gMonBackPic_Wartortle[] = INCBIN_U32("graphics/pokemon/wartortle/back.4bpp.lz");
+const u32 gMonShinyPalette_Wartortle[] = INCBIN_U32("graphics/pokemon/wartortle/shiny.gbapal.lz");
+const u8 gMonIcon_Wartortle[] = INCBIN_U8("graphics/pokemon/wartortle/icon.4bpp");
+const u8 gMonFootprint_Wartortle[] = INCBIN_U8("graphics/pokemon/wartortle/footprint.1bpp");
+
+const u32 gMonFrontPic_Blastoise[] = INCBIN_U32("graphics/pokemon/blastoise/front.4bpp.lz");
+const u32 gMonPalette_Blastoise[] = INCBIN_U32("graphics/pokemon/blastoise/normal.gbapal.lz");
+const u32 gMonBackPic_Blastoise[] = INCBIN_U32("graphics/pokemon/blastoise/back.4bpp.lz");
+const u32 gMonShinyPalette_Blastoise[] = INCBIN_U32("graphics/pokemon/blastoise/shiny.gbapal.lz");
+const u8 gMonIcon_Blastoise[] = INCBIN_U8("graphics/pokemon/blastoise/icon.4bpp");
+const u8 gMonFootprint_Blastoise[] = INCBIN_U8("graphics/pokemon/blastoise/footprint.1bpp");
+
+const u32 gMonFrontPic_Caterpie[] = INCBIN_U32("graphics/pokemon/caterpie/front.4bpp.lz");
+const u32 gMonPalette_Caterpie[] = INCBIN_U32("graphics/pokemon/caterpie/normal.gbapal.lz");
+const u32 gMonBackPic_Caterpie[] = INCBIN_U32("graphics/pokemon/caterpie/back.4bpp.lz");
+const u32 gMonShinyPalette_Caterpie[] = INCBIN_U32("graphics/pokemon/caterpie/shiny.gbapal.lz");
+const u8 gMonIcon_Caterpie[] = INCBIN_U8("graphics/pokemon/caterpie/icon.4bpp");
+const u8 gMonFootprint_Caterpie[] = INCBIN_U8("graphics/pokemon/caterpie/footprint.1bpp");
+
+const u32 gMonFrontPic_Metapod[] = INCBIN_U32("graphics/pokemon/metapod/front.4bpp.lz");
+const u32 gMonPalette_Metapod[] = INCBIN_U32("graphics/pokemon/metapod/normal.gbapal.lz");
+const u32 gMonBackPic_Metapod[] = INCBIN_U32("graphics/pokemon/metapod/back.4bpp.lz");
+const u32 gMonShinyPalette_Metapod[] = INCBIN_U32("graphics/pokemon/metapod/shiny.gbapal.lz");
+const u8 gMonIcon_Metapod[] = INCBIN_U8( "graphics/pokemon/metapod/icon.4bpp");
+const u8 gMonFootprint_Metapod[] = INCBIN_U8("graphics/pokemon/metapod/footprint.1bpp");
+
+const u32 gMonFrontPic_Butterfree[] = INCBIN_U32("graphics/pokemon/butterfree/front.4bpp.lz");
+const u32 gMonPalette_Butterfree[] = INCBIN_U32("graphics/pokemon/butterfree/normal.gbapal.lz");
+const u32 gMonBackPic_Butterfree[] = INCBIN_U32("graphics/pokemon/butterfree/back.4bpp.lz");
+const u32 gMonShinyPalette_Butterfree[] = INCBIN_U32("graphics/pokemon/butterfree/shiny.gbapal.lz");
+const u8 gMonIcon_Butterfree[] = INCBIN_U8("graphics/pokemon/butterfree/icon.4bpp");
+const u8 gMonFootprint_Butterfree[] = INCBIN_U8("graphics/pokemon/butterfree/footprint.1bpp");
+
+const u32 gMonFrontPic_Weedle[] = INCBIN_U32("graphics/pokemon/weedle/front.4bpp.lz");
+const u32 gMonPalette_Weedle[] = INCBIN_U32("graphics/pokemon/weedle/normal.gbapal.lz");
+const u32 gMonBackPic_Weedle[] = INCBIN_U32("graphics/pokemon/weedle/back.4bpp.lz");
+const u32 gMonShinyPalette_Weedle[] = INCBIN_U32("graphics/pokemon/weedle/shiny.gbapal.lz");
+const u8 gMonIcon_Weedle[] = INCBIN_U8("graphics/pokemon/weedle/icon.4bpp");
+const u8 gMonFootprint_Weedle[] = INCBIN_U8("graphics/pokemon/weedle/footprint.1bpp");
+
+const u32 gMonFrontPic_Kakuna[] = INCBIN_U32("graphics/pokemon/kakuna/front.4bpp.lz");
+const u32 gMonPalette_Kakuna[] = INCBIN_U32("graphics/pokemon/kakuna/normal.gbapal.lz");
+const u32 gMonBackPic_Kakuna[] = INCBIN_U32("graphics/pokemon/kakuna/back.4bpp.lz");
+const u32 gMonShinyPalette_Kakuna[] = INCBIN_U32("graphics/pokemon/kakuna/shiny.gbapal.lz");
+const u8 gMonIcon_Kakuna[] = INCBIN_U8("graphics/pokemon/kakuna/icon.4bpp");
+const u8 gMonFootprint_Kakuna[] = INCBIN_U8("graphics/pokemon/kakuna/footprint.1bpp");
+
+const u32 gMonFrontPic_Beedrill[] = INCBIN_U32("graphics/pokemon/beedrill/front.4bpp.lz");
+const u32 gMonPalette_Beedrill[] = INCBIN_U32("graphics/pokemon/beedrill/normal.gbapal.lz");
+const u32 gMonBackPic_Beedrill[] = INCBIN_U32("graphics/pokemon/beedrill/back.4bpp.lz");
+const u32 gMonShinyPalette_Beedrill[] = INCBIN_U32("graphics/pokemon/beedrill/shiny.gbapal.lz");
+const u8 gMonIcon_Beedrill[] = INCBIN_U8("graphics/pokemon/beedrill/icon.4bpp");
+const u8 gMonFootprint_Beedrill[] = INCBIN_U8("graphics/pokemon/beedrill/footprint.1bpp");
+
+const u32 gMonFrontPic_Pidgey[] = INCBIN_U32("graphics/pokemon/pidgey/front.4bpp.lz");
+const u32 gMonPalette_Pidgey[] = INCBIN_U32("graphics/pokemon/pidgey/normal.gbapal.lz");
+const u32 gMonBackPic_Pidgey[] = INCBIN_U32("graphics/pokemon/pidgey/back.4bpp.lz");
+const u32 gMonShinyPalette_Pidgey[] = INCBIN_U32("graphics/pokemon/pidgey/shiny.gbapal.lz");
+const u8 gMonIcon_Pidgey[] = INCBIN_U8("graphics/pokemon/pidgey/icon.4bpp");
+const u8 gMonFootprint_Pidgey[] = INCBIN_U8("graphics/pokemon/pidgey/footprint.1bpp");
+
+const u32 gMonFrontPic_Pidgeotto[] = INCBIN_U32("graphics/pokemon/pidgeotto/front.4bpp.lz");
+const u32 gMonPalette_Pidgeotto[] = INCBIN_U32("graphics/pokemon/pidgeotto/normal.gbapal.lz");
+const u32 gMonBackPic_Pidgeotto[] = INCBIN_U32("graphics/pokemon/pidgeotto/back.4bpp.lz");
+const u32 gMonShinyPalette_Pidgeotto[] = INCBIN_U32("graphics/pokemon/pidgeotto/shiny.gbapal.lz");
+const u8 gMonIcon_Pidgeotto[] = INCBIN_U8("graphics/pokemon/pidgeotto/icon.4bpp");
+const u8 gMonFootprint_Pidgeotto[] = INCBIN_U8("graphics/pokemon/pidgeotto/footprint.1bpp");
+
+const u32 gMonFrontPic_Pidgeot[] = INCBIN_U32("graphics/pokemon/pidgeot/front.4bpp.lz");
+const u32 gMonPalette_Pidgeot[] = INCBIN_U32("graphics/pokemon/pidgeot/normal.gbapal.lz");
+const u32 gMonBackPic_Pidgeot[] = INCBIN_U32("graphics/pokemon/pidgeot/back.4bpp.lz");
+const u32 gMonShinyPalette_Pidgeot[] = INCBIN_U32("graphics/pokemon/pidgeot/shiny.gbapal.lz");
+const u8 gMonIcon_Pidgeot[] = INCBIN_U8("graphics/pokemon/pidgeot/icon.4bpp");
+const u8 gMonFootprint_Pidgeot[] = INCBIN_U8("graphics/pokemon/pidgeot/footprint.1bpp");
+
+const u32 gMonFrontPic_Rattata[] = INCBIN_U32("graphics/pokemon/rattata/front.4bpp.lz");
+const u32 gMonPalette_Rattata[] = INCBIN_U32("graphics/pokemon/rattata/normal.gbapal.lz");
+const u32 gMonBackPic_Rattata[] = INCBIN_U32("graphics/pokemon/rattata/back.4bpp.lz");
+const u32 gMonShinyPalette_Rattata[] = INCBIN_U32("graphics/pokemon/rattata/shiny.gbapal.lz");
+const u8 gMonIcon_Rattata[] = INCBIN_U8("graphics/pokemon/rattata/icon.4bpp");
+const u8 gMonFootprint_Rattata[] = INCBIN_U8("graphics/pokemon/rattata/footprint.1bpp");
+
+const u32 gMonFrontPic_Raticate[] = INCBIN_U32("graphics/pokemon/raticate/front.4bpp.lz");
+const u32 gMonPalette_Raticate[] = INCBIN_U32("graphics/pokemon/raticate/normal.gbapal.lz");
+const u32 gMonBackPic_Raticate[] = INCBIN_U32("graphics/pokemon/raticate/back.4bpp.lz");
+const u32 gMonShinyPalette_Raticate[] = INCBIN_U32("graphics/pokemon/raticate/shiny.gbapal.lz");
+const u8 gMonIcon_Raticate[] = INCBIN_U8("graphics/pokemon/raticate/icon.4bpp");
+const u8 gMonFootprint_Raticate[] = INCBIN_U8("graphics/pokemon/raticate/footprint.1bpp");
+
+const u32 gMonFrontPic_Spearow[] = INCBIN_U32("graphics/pokemon/spearow/front.4bpp.lz");
+const u32 gMonPalette_Spearow[] = INCBIN_U32("graphics/pokemon/spearow/normal.gbapal.lz");
+const u32 gMonBackPic_Spearow[] = INCBIN_U32("graphics/pokemon/spearow/back.4bpp.lz");
+const u32 gMonShinyPalette_Spearow[] = INCBIN_U32("graphics/pokemon/spearow/shiny.gbapal.lz");
+const u8 gMonIcon_Spearow[] = INCBIN_U8("graphics/pokemon/spearow/icon.4bpp");
+const u8 gMonFootprint_Spearow[] = INCBIN_U8("graphics/pokemon/spearow/footprint.1bpp");
+
+const u32 gMonFrontPic_Fearow[] = INCBIN_U32("graphics/pokemon/fearow/front.4bpp.lz");
+const u32 gMonPalette_Fearow[] = INCBIN_U32("graphics/pokemon/fearow/normal.gbapal.lz");
+const u32 gMonBackPic_Fearow[] = INCBIN_U32("graphics/pokemon/fearow/back.4bpp.lz");
+const u32 gMonShinyPalette_Fearow[] = INCBIN_U32("graphics/pokemon/fearow/shiny.gbapal.lz");
+const u8 gMonIcon_Fearow[] = INCBIN_U8("graphics/pokemon/fearow/icon.4bpp");
+const u8 gMonFootprint_Fearow[] = INCBIN_U8("graphics/pokemon/fearow/footprint.1bpp");
+
+const u32 gMonFrontPic_Ekans[] = INCBIN_U32("graphics/pokemon/ekans/front.4bpp.lz");
+const u32 gMonPalette_Ekans[] = INCBIN_U32("graphics/pokemon/ekans/normal.gbapal.lz");
+const u32 gMonBackPic_Ekans[] = INCBIN_U32("graphics/pokemon/ekans/back.4bpp.lz");
+const u32 gMonShinyPalette_Ekans[] = INCBIN_U32("graphics/pokemon/ekans/shiny.gbapal.lz");
+const u8 gMonIcon_Ekans[] = INCBIN_U8("graphics/pokemon/ekans/icon.4bpp");
+const u8 gMonFootprint_Ekans[] = INCBIN_U8("graphics/pokemon/ekans/footprint.1bpp");
+
+const u32 gMonFrontPic_Arbok[] = INCBIN_U32("graphics/pokemon/arbok/front.4bpp.lz");
+const u32 gMonPalette_Arbok[] = INCBIN_U32("graphics/pokemon/arbok/normal.gbapal.lz");
+const u32 gMonBackPic_Arbok[] = INCBIN_U32("graphics/pokemon/arbok/back.4bpp.lz");
+const u32 gMonShinyPalette_Arbok[] = INCBIN_U32("graphics/pokemon/arbok/shiny.gbapal.lz");
+const u8 gMonIcon_Arbok[] = INCBIN_U8("graphics/pokemon/arbok/icon.4bpp");
+const u8 gMonFootprint_Arbok[] = INCBIN_U8("graphics/pokemon/arbok/footprint.1bpp");
+
+const u32 gMonFrontPic_Pikachu[] = INCBIN_U32("graphics/pokemon/pikachu/front.4bpp.lz");
+const u32 gMonPalette_Pikachu[] = INCBIN_U32("graphics/pokemon/pikachu/normal.gbapal.lz");
+const u32 gMonBackPic_Pikachu[] = INCBIN_U32("graphics/pokemon/pikachu/back.4bpp.lz");
+const u32 gMonShinyPalette_Pikachu[] = INCBIN_U32("graphics/pokemon/pikachu/shiny.gbapal.lz");
+const u8 gMonIcon_Pikachu[] = INCBIN_U8("graphics/pokemon/pikachu/icon.4bpp");
+const u8 gMonFootprint_Pikachu[] = INCBIN_U8("graphics/pokemon/pikachu/footprint.1bpp");
+
+const u32 gMonFrontPic_Raichu[] = INCBIN_U32("graphics/pokemon/raichu/front.4bpp.lz");
+const u32 gMonPalette_Raichu[] = INCBIN_U32("graphics/pokemon/raichu/normal.gbapal.lz");
+const u32 gMonBackPic_Raichu[] = INCBIN_U32("graphics/pokemon/raichu/back.4bpp.lz");
+const u32 gMonShinyPalette_Raichu[] = INCBIN_U32("graphics/pokemon/raichu/shiny.gbapal.lz");
+const u8 gMonIcon_Raichu[] = INCBIN_U8("graphics/pokemon/raichu/icon.4bpp");
+const u8 gMonFootprint_Raichu[] = INCBIN_U8("graphics/pokemon/raichu/footprint.1bpp");
+
+const u32 gMonFrontPic_Sandshrew[] = INCBIN_U32("graphics/pokemon/sandshrew/front.4bpp.lz");
+const u32 gMonPalette_Sandshrew[] = INCBIN_U32("graphics/pokemon/sandshrew/normal.gbapal.lz");
+const u32 gMonBackPic_Sandshrew[] = INCBIN_U32("graphics/pokemon/sandshrew/back.4bpp.lz");
+const u32 gMonShinyPalette_Sandshrew[] = INCBIN_U32("graphics/pokemon/sandshrew/shiny.gbapal.lz");
+const u8 gMonIcon_Sandshrew[] = INCBIN_U8("graphics/pokemon/sandshrew/icon.4bpp");
+const u8 gMonFootprint_Sandshrew[] = INCBIN_U8("graphics/pokemon/sandshrew/footprint.1bpp");
+
+const u32 gMonFrontPic_Sandslash[] = INCBIN_U32("graphics/pokemon/sandslash/front.4bpp.lz");
+const u32 gMonPalette_Sandslash[] = INCBIN_U32("graphics/pokemon/sandslash/normal.gbapal.lz");
+const u32 gMonBackPic_Sandslash[] = INCBIN_U32("graphics/pokemon/sandslash/back.4bpp.lz");
+const u32 gMonShinyPalette_Sandslash[] = INCBIN_U32("graphics/pokemon/sandslash/shiny.gbapal.lz");
+const u8 gMonIcon_Sandslash[] = INCBIN_U8("graphics/pokemon/sandslash/icon.4bpp");
+const u8 gMonFootprint_Sandslash[] = INCBIN_U8("graphics/pokemon/sandslash/footprint.1bpp");
+
+const u32 gMonFrontPic_NidoranF[] = INCBIN_U32("graphics/pokemon/nidoran_f/front.4bpp.lz");
+const u32 gMonPalette_NidoranF[] = INCBIN_U32("graphics/pokemon/nidoran_f/normal.gbapal.lz");
+const u32 gMonBackPic_NidoranF[] = INCBIN_U32("graphics/pokemon/nidoran_f/back.4bpp.lz");
+const u32 gMonShinyPalette_NidoranF[] = INCBIN_U32("graphics/pokemon/nidoran_f/shiny.gbapal.lz");
+const u8 gMonIcon_NidoranF[] = INCBIN_U8("graphics/pokemon/nidoran_f/icon.4bpp");
+const u8 gMonFootprint_NidoranF[] = INCBIN_U8("graphics/pokemon/nidoran_f/footprint.1bpp");
+
+const u32 gMonFrontPic_Nidorina[] = INCBIN_U32("graphics/pokemon/nidorina/front.4bpp.lz");
+const u32 gMonPalette_Nidorina[] = INCBIN_U32("graphics/pokemon/nidorina/normal.gbapal.lz");
+const u32 gMonBackPic_Nidorina[] = INCBIN_U32("graphics/pokemon/nidorina/back.4bpp.lz");
+const u32 gMonShinyPalette_Nidorina[] = INCBIN_U32("graphics/pokemon/nidorina/shiny.gbapal.lz");
+const u8 gMonIcon_Nidorina[] = INCBIN_U8("graphics/pokemon/nidorina/icon.4bpp");
+const u8 gMonFootprint_Nidorina[] = INCBIN_U8("graphics/pokemon/nidorina/footprint.1bpp");
+
+const u32 gMonFrontPic_Nidoqueen[] = INCBIN_U32("graphics/pokemon/nidoqueen/front.4bpp.lz");
+const u32 gMonPalette_Nidoqueen[] = INCBIN_U32("graphics/pokemon/nidoqueen/normal.gbapal.lz");
+const u32 gMonBackPic_Nidoqueen[] = INCBIN_U32("graphics/pokemon/nidoqueen/back.4bpp.lz");
+const u32 gMonShinyPalette_Nidoqueen[] = INCBIN_U32("graphics/pokemon/nidoqueen/shiny.gbapal.lz");
+const u8 gMonIcon_Nidoqueen[] = INCBIN_U8("graphics/pokemon/nidoqueen/icon.4bpp");
+const u8 gMonFootprint_Nidoqueen[] = INCBIN_U8("graphics/pokemon/nidoqueen/footprint.1bpp");
+
+const u32 gMonFrontPic_NidoranM[] = INCBIN_U32("graphics/pokemon/nidoran_m/front.4bpp.lz");
+const u32 gMonPalette_NidoranM[] = INCBIN_U32("graphics/pokemon/nidoran_m/normal.gbapal.lz");
+const u32 gMonBackPic_NidoranM[] = INCBIN_U32("graphics/pokemon/nidoran_m/back.4bpp.lz");
+const u32 gMonShinyPalette_NidoranM[] = INCBIN_U32("graphics/pokemon/nidoran_m/shiny.gbapal.lz");
+const u8 gMonIcon_NidoranM[] = INCBIN_U8("graphics/pokemon/nidoran_m/icon.4bpp");
+const u8 gMonFootprint_NidoranM[] = INCBIN_U8("graphics/pokemon/nidoran_m/footprint.1bpp");
+
+const u32 gMonFrontPic_Nidorino[] = INCBIN_U32("graphics/pokemon/nidorino/front.4bpp.lz");
+const u32 gMonPalette_Nidorino[] = INCBIN_U32("graphics/pokemon/nidorino/normal.gbapal.lz");
+const u32 gMonBackPic_Nidorino[] = INCBIN_U32("graphics/pokemon/nidorino/back.4bpp.lz");
+const u32 gMonShinyPalette_Nidorino[] = INCBIN_U32("graphics/pokemon/nidorino/shiny.gbapal.lz");
+const u8 gMonIcon_Nidorino[] = INCBIN_U8("graphics/pokemon/nidorino/icon.4bpp");
+const u8 gMonFootprint_Nidorino[] = INCBIN_U8("graphics/pokemon/nidorino/footprint.1bpp");
+
+const u32 gMonFrontPic_Nidoking[] = INCBIN_U32("graphics/pokemon/nidoking/front.4bpp.lz");
+const u32 gMonPalette_Nidoking[] = INCBIN_U32("graphics/pokemon/nidoking/normal.gbapal.lz");
+const u32 gMonBackPic_Nidoking[] = INCBIN_U32("graphics/pokemon/nidoking/back.4bpp.lz");
+const u32 gMonShinyPalette_Nidoking[] = INCBIN_U32("graphics/pokemon/nidoking/shiny.gbapal.lz");
+const u8 gMonIcon_Nidoking[] = INCBIN_U8("graphics/pokemon/nidoking/icon.4bpp");
+const u8 gMonFootprint_Nidoking[] = INCBIN_U8("graphics/pokemon/nidoking/footprint.1bpp");
+
+const u32 gMonFrontPic_Clefairy[] = INCBIN_U32("graphics/pokemon/clefairy/front.4bpp.lz");
+const u32 gMonPalette_Clefairy[] = INCBIN_U32("graphics/pokemon/clefairy/normal.gbapal.lz");
+const u32 gMonBackPic_Clefairy[] = INCBIN_U32("graphics/pokemon/clefairy/back.4bpp.lz");
+const u32 gMonShinyPalette_Clefairy[] = INCBIN_U32("graphics/pokemon/clefairy/shiny.gbapal.lz");
+const u8 gMonIcon_Clefairy[] = INCBIN_U8("graphics/pokemon/clefairy/icon.4bpp");
+const u8 gMonFootprint_Clefairy[] = INCBIN_U8("graphics/pokemon/clefairy/footprint.1bpp");
+
+const u32 gMonFrontPic_Clefable[] = INCBIN_U32("graphics/pokemon/clefable/front.4bpp.lz");
+const u32 gMonPalette_Clefable[] = INCBIN_U32("graphics/pokemon/clefable/normal.gbapal.lz");
+const u32 gMonBackPic_Clefable[] = INCBIN_U32("graphics/pokemon/clefable/back.4bpp.lz");
+const u32 gMonShinyPalette_Clefable[] = INCBIN_U32("graphics/pokemon/clefable/shiny.gbapal.lz");
+const u8 gMonIcon_Clefable[] = INCBIN_U8("graphics/pokemon/clefable/icon.4bpp");
+const u8 gMonFootprint_Clefable[] = INCBIN_U8("graphics/pokemon/clefable/footprint.1bpp");
+
+const u32 gMonFrontPic_Vulpix[] = INCBIN_U32("graphics/pokemon/vulpix/front.4bpp.lz");
+const u32 gMonPalette_Vulpix[] = INCBIN_U32("graphics/pokemon/vulpix/normal.gbapal.lz");
+const u32 gMonBackPic_Vulpix[] = INCBIN_U32("graphics/pokemon/vulpix/back.4bpp.lz");
+const u32 gMonShinyPalette_Vulpix[] = INCBIN_U32("graphics/pokemon/vulpix/shiny.gbapal.lz");
+const u8 gMonIcon_Vulpix[] = INCBIN_U8("graphics/pokemon/vulpix/icon.4bpp");
+const u8 gMonFootprint_Vulpix[] = INCBIN_U8("graphics/pokemon/vulpix/footprint.1bpp");
+
+const u32 gMonFrontPic_Ninetales[] = INCBIN_U32("graphics/pokemon/ninetales/front.4bpp.lz");
+const u32 gMonPalette_Ninetales[] = INCBIN_U32("graphics/pokemon/ninetales/normal.gbapal.lz");
+const u32 gMonBackPic_Ninetales[] = INCBIN_U32("graphics/pokemon/ninetales/back.4bpp.lz");
+const u32 gMonShinyPalette_Ninetales[] = INCBIN_U32("graphics/pokemon/ninetales/shiny.gbapal.lz");
+const u8 gMonIcon_Ninetales[] = INCBIN_U8("graphics/pokemon/ninetales/icon.4bpp");
+const u8 gMonFootprint_Ninetales[] = INCBIN_U8("graphics/pokemon/ninetales/footprint.1bpp");
+
+const u32 gMonFrontPic_Jigglypuff[] = INCBIN_U32("graphics/pokemon/jigglypuff/front.4bpp.lz");
+const u32 gMonPalette_Jigglypuff[] = INCBIN_U32("graphics/pokemon/jigglypuff/normal.gbapal.lz");
+const u32 gMonBackPic_Jigglypuff[] = INCBIN_U32("graphics/pokemon/jigglypuff/back.4bpp.lz");
+const u32 gMonShinyPalette_Jigglypuff[] = INCBIN_U32("graphics/pokemon/jigglypuff/shiny.gbapal.lz");
+const u8 gMonIcon_Jigglypuff[] = INCBIN_U8("graphics/pokemon/jigglypuff/icon.4bpp");
+const u8 gMonFootprint_Jigglypuff[] = INCBIN_U8("graphics/pokemon/jigglypuff/footprint.1bpp");
+
+const u32 gMonFrontPic_Wigglytuff[] = INCBIN_U32("graphics/pokemon/wigglytuff/front.4bpp.lz");
+const u32 gMonPalette_Wigglytuff[] = INCBIN_U32("graphics/pokemon/wigglytuff/normal.gbapal.lz");
+const u32 gMonBackPic_Wigglytuff[] = INCBIN_U32("graphics/pokemon/wigglytuff/back.4bpp.lz");
+const u32 gMonShinyPalette_Wigglytuff[] = INCBIN_U32("graphics/pokemon/wigglytuff/shiny.gbapal.lz");
+const u8 gMonIcon_Wigglytuff[] = INCBIN_U8("graphics/pokemon/wigglytuff/icon.4bpp");
+const u8 gMonFootprint_Wigglytuff[] = INCBIN_U8("graphics/pokemon/wigglytuff/footprint.1bpp");
+
+const u32 gMonFrontPic_Zubat[] = INCBIN_U32("graphics/pokemon/zubat/front.4bpp.lz");
+const u32 gMonPalette_Zubat[] = INCBIN_U32("graphics/pokemon/zubat/normal.gbapal.lz");
+const u32 gMonBackPic_Zubat[] = INCBIN_U32("graphics/pokemon/zubat/back.4bpp.lz");
+const u32 gMonShinyPalette_Zubat[] = INCBIN_U32("graphics/pokemon/zubat/shiny.gbapal.lz");
+const u8 gMonIcon_Zubat[] = INCBIN_U8("graphics/pokemon/zubat/icon.4bpp");
+const u8 gMonFootprint_Zubat[] = INCBIN_U8("graphics/pokemon/zubat/footprint.1bpp");
+
+const u32 gMonFrontPic_Golbat[] = INCBIN_U32("graphics/pokemon/golbat/front.4bpp.lz");
+const u32 gMonPalette_Golbat[] = INCBIN_U32("graphics/pokemon/golbat/normal.gbapal.lz");
+const u32 gMonBackPic_Golbat[] = INCBIN_U32("graphics/pokemon/golbat/back.4bpp.lz");
+const u32 gMonShinyPalette_Golbat[] = INCBIN_U32("graphics/pokemon/golbat/shiny.gbapal.lz");
+const u8 gMonIcon_Golbat[] = INCBIN_U8("graphics/pokemon/golbat/icon.4bpp");
+const u8 gMonFootprint_Golbat[] = INCBIN_U8("graphics/pokemon/golbat/footprint.1bpp");
+
+const u32 gMonFrontPic_Oddish[] = INCBIN_U32("graphics/pokemon/oddish/front.4bpp.lz");
+const u32 gMonPalette_Oddish[] = INCBIN_U32("graphics/pokemon/oddish/normal.gbapal.lz");
+const u32 gMonBackPic_Oddish[] = INCBIN_U32("graphics/pokemon/oddish/back.4bpp.lz");
+const u32 gMonShinyPalette_Oddish[] = INCBIN_U32("graphics/pokemon/oddish/shiny.gbapal.lz");
+const u8 gMonIcon_Oddish[] = INCBIN_U8("graphics/pokemon/oddish/icon.4bpp");
+const u8 gMonFootprint_Oddish[] = INCBIN_U8("graphics/pokemon/oddish/footprint.1bpp");
+
+const u32 gMonFrontPic_Gloom[] = INCBIN_U32("graphics/pokemon/gloom/front.4bpp.lz");
+const u32 gMonPalette_Gloom[] = INCBIN_U32("graphics/pokemon/gloom/normal.gbapal.lz");
+const u32 gMonBackPic_Gloom[] = INCBIN_U32("graphics/pokemon/gloom/back.4bpp.lz");
+const u32 gMonShinyPalette_Gloom[] = INCBIN_U32("graphics/pokemon/gloom/shiny.gbapal.lz");
+const u8 gMonIcon_Gloom[] = INCBIN_U8("graphics/pokemon/gloom/icon.4bpp");
+const u8 gMonFootprint_Gloom[] = INCBIN_U8("graphics/pokemon/gloom/footprint.1bpp");
+
+const u32 gMonFrontPic_Vileplume[] = INCBIN_U32("graphics/pokemon/vileplume/front.4bpp.lz");
+const u32 gMonPalette_Vileplume[] = INCBIN_U32("graphics/pokemon/vileplume/normal.gbapal.lz");
+const u32 gMonBackPic_Vileplume[] = INCBIN_U32("graphics/pokemon/vileplume/back.4bpp.lz");
+const u32 gMonShinyPalette_Vileplume[] = INCBIN_U32("graphics/pokemon/vileplume/shiny.gbapal.lz");
+const u8 gMonIcon_Vileplume[] = INCBIN_U8("graphics/pokemon/vileplume/icon.4bpp");
+const u8 gMonFootprint_Vileplume[] = INCBIN_U8("graphics/pokemon/vileplume/footprint.1bpp");
+
+const u32 gMonFrontPic_Paras[] = INCBIN_U32("graphics/pokemon/paras/front.4bpp.lz");
+const u32 gMonPalette_Paras[] = INCBIN_U32("graphics/pokemon/paras/normal.gbapal.lz");
+const u32 gMonBackPic_Paras[] = INCBIN_U32("graphics/pokemon/paras/back.4bpp.lz");
+const u32 gMonShinyPalette_Paras[] = INCBIN_U32("graphics/pokemon/paras/shiny.gbapal.lz");
+const u8 gMonIcon_Paras[] = INCBIN_U8("graphics/pokemon/paras/icon.4bpp");
+const u8 gMonFootprint_Paras[] = INCBIN_U8("graphics/pokemon/paras/footprint.1bpp");
+
+const u32 gMonFrontPic_Parasect[] = INCBIN_U32("graphics/pokemon/parasect/front.4bpp.lz");
+const u32 gMonPalette_Parasect[] = INCBIN_U32("graphics/pokemon/parasect/normal.gbapal.lz");
+const u32 gMonBackPic_Parasect[] = INCBIN_U32("graphics/pokemon/parasect/back.4bpp.lz");
+const u32 gMonShinyPalette_Parasect[] = INCBIN_U32("graphics/pokemon/parasect/shiny.gbapal.lz");
+const u8 gMonIcon_Parasect[] = INCBIN_U8("graphics/pokemon/parasect/icon.4bpp");
+const u8 gMonFootprint_Parasect[] = INCBIN_U8("graphics/pokemon/parasect/footprint.1bpp");
+
+const u32 gMonFrontPic_Venonat[] = INCBIN_U32("graphics/pokemon/venonat/front.4bpp.lz");
+const u32 gMonPalette_Venonat[] = INCBIN_U32("graphics/pokemon/venonat/normal.gbapal.lz");
+const u32 gMonBackPic_Venonat[] = INCBIN_U32("graphics/pokemon/venonat/back.4bpp.lz");
+const u32 gMonShinyPalette_Venonat[] = INCBIN_U32("graphics/pokemon/venonat/shiny.gbapal.lz");
+const u8 gMonIcon_Venonat[] = INCBIN_U8("graphics/pokemon/venonat/icon.4bpp");
+const u8 gMonFootprint_Venonat[] = INCBIN_U8("graphics/pokemon/venonat/footprint.1bpp");
+
+const u32 gMonFrontPic_Venomoth[] = INCBIN_U32("graphics/pokemon/venomoth/front.4bpp.lz");
+const u32 gMonPalette_Venomoth[] = INCBIN_U32("graphics/pokemon/venomoth/normal.gbapal.lz");
+const u32 gMonBackPic_Venomoth[] = INCBIN_U32("graphics/pokemon/venomoth/back.4bpp.lz");
+const u32 gMonShinyPalette_Venomoth[] = INCBIN_U32("graphics/pokemon/venomoth/shiny.gbapal.lz");
+const u8 gMonIcon_Venomoth[] = INCBIN_U8("graphics/pokemon/venomoth/icon.4bpp");
+const u8 gMonFootprint_Venomoth[] = INCBIN_U8("graphics/pokemon/venomoth/footprint.1bpp");
+
+const u32 gMonFrontPic_Diglett[] = INCBIN_U32("graphics/pokemon/diglett/front.4bpp.lz");
+const u32 gMonPalette_Diglett[] = INCBIN_U32("graphics/pokemon/diglett/normal.gbapal.lz");
+const u32 gMonBackPic_Diglett[] = INCBIN_U32("graphics/pokemon/diglett/back.4bpp.lz");
+const u32 gMonShinyPalette_Diglett[] = INCBIN_U32("graphics/pokemon/diglett/shiny.gbapal.lz");
+const u8 gMonIcon_Diglett[] = INCBIN_U8("graphics/pokemon/diglett/icon.4bpp");
+const u8 gMonFootprint_Diglett[] = INCBIN_U8("graphics/pokemon/diglett/footprint.1bpp");
+
+const u32 gMonFrontPic_Dugtrio[] = INCBIN_U32("graphics/pokemon/dugtrio/front.4bpp.lz");
+const u32 gMonPalette_Dugtrio[] = INCBIN_U32("graphics/pokemon/dugtrio/normal.gbapal.lz");
+const u32 gMonBackPic_Dugtrio[] = INCBIN_U32("graphics/pokemon/dugtrio/back.4bpp.lz");
+const u32 gMonShinyPalette_Dugtrio[] = INCBIN_U32("graphics/pokemon/dugtrio/shiny.gbapal.lz");
+const u8 gMonIcon_Dugtrio[] = INCBIN_U8("graphics/pokemon/dugtrio/icon.4bpp");
+const u8 gMonFootprint_Dugtrio[] = INCBIN_U8("graphics/pokemon/dugtrio/footprint.1bpp");
+
+const u32 gMonFrontPic_Meowth[] = INCBIN_U32("graphics/pokemon/meowth/front.4bpp.lz");
+const u32 gMonPalette_Meowth[] = INCBIN_U32("graphics/pokemon/meowth/normal.gbapal.lz");
+const u32 gMonBackPic_Meowth[] = INCBIN_U32("graphics/pokemon/meowth/back.4bpp.lz");
+const u32 gMonShinyPalette_Meowth[] = INCBIN_U32("graphics/pokemon/meowth/shiny.gbapal.lz");
+const u8 gMonIcon_Meowth[] = INCBIN_U8("graphics/pokemon/meowth/icon.4bpp");
+const u8 gMonFootprint_Meowth[] = INCBIN_U8("graphics/pokemon/meowth/footprint.1bpp");
+
+const u32 gMonFrontPic_Persian[] = INCBIN_U32("graphics/pokemon/persian/front.4bpp.lz");
+const u32 gMonPalette_Persian[] = INCBIN_U32("graphics/pokemon/persian/normal.gbapal.lz");
+const u32 gMonBackPic_Persian[] = INCBIN_U32("graphics/pokemon/persian/back.4bpp.lz");
+const u32 gMonShinyPalette_Persian[] = INCBIN_U32("graphics/pokemon/persian/shiny.gbapal.lz");
+const u8 gMonIcon_Persian[] = INCBIN_U8("graphics/pokemon/persian/icon.4bpp");
+const u8 gMonFootprint_Persian[] = INCBIN_U8("graphics/pokemon/persian/footprint.1bpp");
+
+const u32 gMonFrontPic_Psyduck[] = INCBIN_U32("graphics/pokemon/psyduck/front.4bpp.lz");
+const u32 gMonPalette_Psyduck[] = INCBIN_U32("graphics/pokemon/psyduck/normal.gbapal.lz");
+const u32 gMonBackPic_Psyduck[] = INCBIN_U32("graphics/pokemon/psyduck/back.4bpp.lz");
+const u32 gMonShinyPalette_Psyduck[] = INCBIN_U32("graphics/pokemon/psyduck/shiny.gbapal.lz");
+const u8 gMonIcon_Psyduck[] = INCBIN_U8("graphics/pokemon/psyduck/icon.4bpp");
+const u8 gMonFootprint_Psyduck[] = INCBIN_U8("graphics/pokemon/psyduck/footprint.1bpp");
+
+const u32 gMonFrontPic_Golduck[] = INCBIN_U32("graphics/pokemon/golduck/front.4bpp.lz");
+const u32 gMonPalette_Golduck[] = INCBIN_U32("graphics/pokemon/golduck/normal.gbapal.lz");
+const u32 gMonBackPic_Golduck[] = INCBIN_U32("graphics/pokemon/golduck/back.4bpp.lz");
+const u32 gMonShinyPalette_Golduck[] = INCBIN_U32("graphics/pokemon/golduck/shiny.gbapal.lz");
+const u8 gMonIcon_Golduck[] = INCBIN_U8("graphics/pokemon/golduck/icon.4bpp");
+const u8 gMonFootprint_Golduck[] = INCBIN_U8("graphics/pokemon/golduck/footprint.1bpp");
+
+const u32 gMonFrontPic_Mankey[] = INCBIN_U32("graphics/pokemon/mankey/front.4bpp.lz");
+const u32 gMonPalette_Mankey[] = INCBIN_U32("graphics/pokemon/mankey/normal.gbapal.lz");
+const u32 gMonBackPic_Mankey[] = INCBIN_U32("graphics/pokemon/mankey/back.4bpp.lz");
+const u32 gMonShinyPalette_Mankey[] = INCBIN_U32("graphics/pokemon/mankey/shiny.gbapal.lz");
+const u8 gMonIcon_Mankey[] = INCBIN_U8("graphics/pokemon/mankey/icon.4bpp");
+const u8 gMonFootprint_Mankey[] = INCBIN_U8("graphics/pokemon/mankey/footprint.1bpp");
+
+const u32 gMonFrontPic_Primeape[] = INCBIN_U32("graphics/pokemon/primeape/front.4bpp.lz");
+const u32 gMonPalette_Primeape[] = INCBIN_U32("graphics/pokemon/primeape/normal.gbapal.lz");
+const u32 gMonBackPic_Primeape[] = INCBIN_U32("graphics/pokemon/primeape/back.4bpp.lz");
+const u32 gMonShinyPalette_Primeape[] = INCBIN_U32("graphics/pokemon/primeape/shiny.gbapal.lz");
+const u8 gMonIcon_Primeape[] = INCBIN_U8("graphics/pokemon/primeape/icon.4bpp");
+const u8 gMonFootprint_Primeape[] = INCBIN_U8("graphics/pokemon/primeape/footprint.1bpp");
+
+const u32 gMonFrontPic_Growlithe[] = INCBIN_U32("graphics/pokemon/growlithe/front.4bpp.lz");
+const u32 gMonPalette_Growlithe[] = INCBIN_U32("graphics/pokemon/growlithe/normal.gbapal.lz");
+const u32 gMonBackPic_Growlithe[] = INCBIN_U32("graphics/pokemon/growlithe/back.4bpp.lz");
+const u32 gMonShinyPalette_Growlithe[] = INCBIN_U32("graphics/pokemon/growlithe/shiny.gbapal.lz");
+const u8 gMonIcon_Growlithe[] = INCBIN_U8("graphics/pokemon/growlithe/icon.4bpp");
+const u8 gMonFootprint_Growlithe[] = INCBIN_U8("graphics/pokemon/growlithe/footprint.1bpp");
+
+const u32 gMonFrontPic_Arcanine[] = INCBIN_U32("graphics/pokemon/arcanine/front.4bpp.lz");
+const u32 gMonPalette_Arcanine[] = INCBIN_U32("graphics/pokemon/arcanine/normal.gbapal.lz");
+const u32 gMonBackPic_Arcanine[] = INCBIN_U32("graphics/pokemon/arcanine/back.4bpp.lz");
+const u32 gMonShinyPalette_Arcanine[] = INCBIN_U32("graphics/pokemon/arcanine/shiny.gbapal.lz");
+const u8 gMonIcon_Arcanine[] = INCBIN_U8("graphics/pokemon/arcanine/icon.4bpp");
+const u8 gMonFootprint_Arcanine[] = INCBIN_U8("graphics/pokemon/arcanine/footprint.1bpp");
+
+const u32 gMonFrontPic_Poliwag[] = INCBIN_U32("graphics/pokemon/poliwag/front.4bpp.lz");
+const u32 gMonPalette_Poliwag[] = INCBIN_U32("graphics/pokemon/poliwag/normal.gbapal.lz");
+const u32 gMonBackPic_Poliwag[] = INCBIN_U32("graphics/pokemon/poliwag/back.4bpp.lz");
+const u32 gMonShinyPalette_Poliwag[] = INCBIN_U32("graphics/pokemon/poliwag/shiny.gbapal.lz");
+const u8 gMonIcon_Poliwag[] = INCBIN_U8("graphics/pokemon/poliwag/icon.4bpp");
+const u8 gMonFootprint_Poliwag[] = INCBIN_U8("graphics/pokemon/poliwag/footprint.1bpp");
+
+const u32 gMonFrontPic_Poliwhirl[] = INCBIN_U32("graphics/pokemon/poliwhirl/front.4bpp.lz");
+const u32 gMonPalette_Poliwhirl[] = INCBIN_U32("graphics/pokemon/poliwhirl/normal.gbapal.lz");
+const u32 gMonBackPic_Poliwhirl[] = INCBIN_U32("graphics/pokemon/poliwhirl/back.4bpp.lz");
+const u32 gMonShinyPalette_Poliwhirl[] = INCBIN_U32("graphics/pokemon/poliwhirl/shiny.gbapal.lz");
+const u8 gMonIcon_Poliwhirl[] = INCBIN_U8("graphics/pokemon/poliwhirl/icon.4bpp");
+const u8 gMonFootprint_Poliwhirl[] = INCBIN_U8("graphics/pokemon/poliwhirl/footprint.1bpp");
+
+const u32 gMonFrontPic_Poliwrath[] = INCBIN_U32("graphics/pokemon/poliwrath/front.4bpp.lz");
+const u32 gMonPalette_Poliwrath[] = INCBIN_U32("graphics/pokemon/poliwrath/normal.gbapal.lz");
+const u32 gMonBackPic_Poliwrath[] = INCBIN_U32("graphics/pokemon/poliwrath/back.4bpp.lz");
+const u32 gMonShinyPalette_Poliwrath[] = INCBIN_U32("graphics/pokemon/poliwrath/shiny.gbapal.lz");
+const u8 gMonIcon_Poliwrath[] = INCBIN_U8("graphics/pokemon/poliwrath/icon.4bpp");
+const u8 gMonFootprint_Poliwrath[] = INCBIN_U8("graphics/pokemon/poliwrath/footprint.1bpp");
+
+const u32 gMonFrontPic_Abra[] = INCBIN_U32("graphics/pokemon/abra/front.4bpp.lz");
+const u32 gMonPalette_Abra[] = INCBIN_U32("graphics/pokemon/abra/normal.gbapal.lz");
+const u32 gMonBackPic_Abra[] = INCBIN_U32("graphics/pokemon/abra/back.4bpp.lz");
+const u32 gMonShinyPalette_Abra[] = INCBIN_U32("graphics/pokemon/abra/shiny.gbapal.lz");
+const u8 gMonIcon_Abra[] = INCBIN_U8("graphics/pokemon/abra/icon.4bpp");
+const u8 gMonFootprint_Abra[] = INCBIN_U8("graphics/pokemon/abra/footprint.1bpp");
+
+const u32 gMonFrontPic_Kadabra[] = INCBIN_U32("graphics/pokemon/kadabra/front.4bpp.lz");
+const u32 gMonPalette_Kadabra[] = INCBIN_U32("graphics/pokemon/kadabra/normal.gbapal.lz");
+const u32 gMonBackPic_Kadabra[] = INCBIN_U32("graphics/pokemon/kadabra/back.4bpp.lz");
+const u32 gMonShinyPalette_Kadabra[] = INCBIN_U32("graphics/pokemon/kadabra/shiny.gbapal.lz");
+const u8 gMonIcon_Kadabra[] = INCBIN_U8("graphics/pokemon/kadabra/icon.4bpp");
+const u8 gMonFootprint_Kadabra[] = INCBIN_U8("graphics/pokemon/kadabra/footprint.1bpp");
+
+const u32 gMonFrontPic_Alakazam[] = INCBIN_U32("graphics/pokemon/alakazam/front.4bpp.lz");
+const u32 gMonPalette_Alakazam[] = INCBIN_U32("graphics/pokemon/alakazam/normal.gbapal.lz");
+const u32 gMonBackPic_Alakazam[] = INCBIN_U32("graphics/pokemon/alakazam/back.4bpp.lz");
+const u32 gMonShinyPalette_Alakazam[] = INCBIN_U32("graphics/pokemon/alakazam/shiny.gbapal.lz");
+const u8 gMonIcon_Alakazam[] = INCBIN_U8("graphics/pokemon/alakazam/icon.4bpp");
+const u8 gMonFootprint_Alakazam[] = INCBIN_U8("graphics/pokemon/alakazam/footprint.1bpp");
+
+const u32 gMonFrontPic_Machop[] = INCBIN_U32("graphics/pokemon/machop/front.4bpp.lz");
+const u32 gMonPalette_Machop[] = INCBIN_U32("graphics/pokemon/machop/normal.gbapal.lz");
+const u32 gMonBackPic_Machop[] = INCBIN_U32("graphics/pokemon/machop/back.4bpp.lz");
+const u32 gMonShinyPalette_Machop[] = INCBIN_U32("graphics/pokemon/machop/shiny.gbapal.lz");
+const u8 gMonIcon_Machop[] = INCBIN_U8("graphics/pokemon/machop/icon.4bpp");
+const u8 gMonFootprint_Machop[] = INCBIN_U8("graphics/pokemon/machop/footprint.1bpp");
+
+const u32 gMonFrontPic_Machoke[] = INCBIN_U32("graphics/pokemon/machoke/front.4bpp.lz");
+const u32 gMonPalette_Machoke[] = INCBIN_U32("graphics/pokemon/machoke/normal.gbapal.lz");
+const u32 gMonBackPic_Machoke[] = INCBIN_U32("graphics/pokemon/machoke/back.4bpp.lz");
+const u32 gMonShinyPalette_Machoke[] = INCBIN_U32("graphics/pokemon/machoke/shiny.gbapal.lz");
+const u8 gMonIcon_Machoke[] = INCBIN_U8("graphics/pokemon/machoke/icon.4bpp");
+const u8 gMonFootprint_Machoke[] = INCBIN_U8("graphics/pokemon/machoke/footprint.1bpp");
+
+const u32 gMonFrontPic_Machamp[] = INCBIN_U32("graphics/pokemon/machamp/front.4bpp.lz");
+const u32 gMonPalette_Machamp[] = INCBIN_U32("graphics/pokemon/machamp/normal.gbapal.lz");
+const u32 gMonBackPic_Machamp[] = INCBIN_U32("graphics/pokemon/machamp/back.4bpp.lz");
+const u32 gMonShinyPalette_Machamp[] = INCBIN_U32("graphics/pokemon/machamp/shiny.gbapal.lz");
+const u8 gMonIcon_Machamp[] = INCBIN_U8("graphics/pokemon/machamp/icon.4bpp");
+const u8 gMonFootprint_Machamp[] = INCBIN_U8("graphics/pokemon/machamp/footprint.1bpp");
+
+const u32 gMonFrontPic_Bellsprout[] = INCBIN_U32("graphics/pokemon/bellsprout/front.4bpp.lz");
+const u32 gMonPalette_Bellsprout[] = INCBIN_U32("graphics/pokemon/bellsprout/normal.gbapal.lz");
+const u32 gMonBackPic_Bellsprout[] = INCBIN_U32("graphics/pokemon/bellsprout/back.4bpp.lz");
+const u32 gMonShinyPalette_Bellsprout[] = INCBIN_U32("graphics/pokemon/bellsprout/shiny.gbapal.lz");
+const u8 gMonIcon_Bellsprout[] = INCBIN_U8("graphics/pokemon/bellsprout/icon.4bpp");
+const u8 gMonFootprint_Bellsprout[] = INCBIN_U8("graphics/pokemon/bellsprout/footprint.1bpp");
+
+const u32 gMonFrontPic_Weepinbell[] = INCBIN_U32("graphics/pokemon/weepinbell/front.4bpp.lz");
+const u32 gMonPalette_Weepinbell[] = INCBIN_U32("graphics/pokemon/weepinbell/normal.gbapal.lz");
+const u32 gMonBackPic_Weepinbell[] = INCBIN_U32("graphics/pokemon/weepinbell/back.4bpp.lz");
+const u32 gMonShinyPalette_Weepinbell[] = INCBIN_U32("graphics/pokemon/weepinbell/shiny.gbapal.lz");
+const u8 gMonIcon_Weepinbell[] = INCBIN_U8("graphics/pokemon/weepinbell/icon.4bpp");
+const u8 gMonFootprint_Weepinbell[] = INCBIN_U8("graphics/pokemon/weepinbell/footprint.1bpp");
+
+const u32 gMonFrontPic_Victreebel[] = INCBIN_U32("graphics/pokemon/victreebel/front.4bpp.lz");
+const u32 gMonPalette_Victreebel[] = INCBIN_U32("graphics/pokemon/victreebel/normal.gbapal.lz");
+const u32 gMonBackPic_Victreebel[] = INCBIN_U32("graphics/pokemon/victreebel/back.4bpp.lz");
+const u32 gMonShinyPalette_Victreebel[] = INCBIN_U32("graphics/pokemon/victreebel/shiny.gbapal.lz");
+const u8 gMonIcon_Victreebel[] = INCBIN_U8("graphics/pokemon/victreebel/icon.4bpp");
+const u8 gMonFootprint_Victreebel[] = INCBIN_U8("graphics/pokemon/victreebel/footprint.1bpp");
+
+const u32 gMonFrontPic_Tentacool[] = INCBIN_U32("graphics/pokemon/tentacool/front.4bpp.lz");
+const u32 gMonPalette_Tentacool[] = INCBIN_U32("graphics/pokemon/tentacool/normal.gbapal.lz");
+const u32 gMonBackPic_Tentacool[] = INCBIN_U32("graphics/pokemon/tentacool/back.4bpp.lz");
+const u32 gMonShinyPalette_Tentacool[] = INCBIN_U32("graphics/pokemon/tentacool/shiny.gbapal.lz");
+const u8 gMonIcon_Tentacool[] = INCBIN_U8("graphics/pokemon/tentacool/icon.4bpp");
+const u8 gMonFootprint_Tentacool[] = INCBIN_U8("graphics/pokemon/tentacool/footprint.1bpp");
+
+const u32 gMonFrontPic_Tentacruel[] = INCBIN_U32("graphics/pokemon/tentacruel/front.4bpp.lz");
+const u32 gMonPalette_Tentacruel[] = INCBIN_U32("graphics/pokemon/tentacruel/normal.gbapal.lz");
+const u32 gMonBackPic_Tentacruel[] = INCBIN_U32("graphics/pokemon/tentacruel/back.4bpp.lz");
+const u32 gMonShinyPalette_Tentacruel[] = INCBIN_U32("graphics/pokemon/tentacruel/shiny.gbapal.lz");
+const u8 gMonIcon_Tentacruel[] = INCBIN_U8("graphics/pokemon/tentacruel/icon.4bpp");
+const u8 gMonFootprint_Tentacruel[] = INCBIN_U8("graphics/pokemon/tentacruel/footprint.1bpp");
+
+const u32 gMonFrontPic_Geodude[] = INCBIN_U32("graphics/pokemon/geodude/front.4bpp.lz");
+const u32 gMonPalette_Geodude[] = INCBIN_U32("graphics/pokemon/geodude/normal.gbapal.lz");
+const u32 gMonBackPic_Geodude[] = INCBIN_U32("graphics/pokemon/geodude/back.4bpp.lz");
+const u32 gMonShinyPalette_Geodude[] = INCBIN_U32("graphics/pokemon/geodude/shiny.gbapal.lz");
+const u8 gMonIcon_Geodude[] = INCBIN_U8("graphics/pokemon/geodude/icon.4bpp");
+const u8 gMonFootprint_Geodude[] = INCBIN_U8("graphics/pokemon/geodude/footprint.1bpp");
+
+const u32 gMonFrontPic_Graveler[] = INCBIN_U32("graphics/pokemon/graveler/front.4bpp.lz");
+const u32 gMonPalette_Graveler[] = INCBIN_U32("graphics/pokemon/graveler/normal.gbapal.lz");
+const u32 gMonBackPic_Graveler[] = INCBIN_U32("graphics/pokemon/graveler/back.4bpp.lz");
+const u32 gMonShinyPalette_Graveler[] = INCBIN_U32("graphics/pokemon/graveler/shiny.gbapal.lz");
+const u8 gMonIcon_Graveler[] = INCBIN_U8("graphics/pokemon/graveler/icon.4bpp");
+const u8 gMonFootprint_Graveler[] = INCBIN_U8("graphics/pokemon/graveler/footprint.1bpp");
+
+const u32 gMonFrontPic_Golem[] = INCBIN_U32("graphics/pokemon/golem/front.4bpp.lz");
+const u32 gMonPalette_Golem[] = INCBIN_U32("graphics/pokemon/golem/normal.gbapal.lz");
+const u32 gMonBackPic_Golem[] = INCBIN_U32("graphics/pokemon/golem/back.4bpp.lz");
+const u32 gMonShinyPalette_Golem[] = INCBIN_U32("graphics/pokemon/golem/shiny.gbapal.lz");
+const u8 gMonIcon_Golem[] = INCBIN_U8("graphics/pokemon/golem/icon.4bpp");
+const u8 gMonFootprint_Golem[] = INCBIN_U8("graphics/pokemon/golem/footprint.1bpp");
+
+const u32 gMonFrontPic_Ponyta[] = INCBIN_U32("graphics/pokemon/ponyta/front.4bpp.lz");
+const u32 gMonPalette_Ponyta[] = INCBIN_U32("graphics/pokemon/ponyta/normal.gbapal.lz");
+const u32 gMonBackPic_Ponyta[] = INCBIN_U32("graphics/pokemon/ponyta/back.4bpp.lz");
+const u32 gMonShinyPalette_Ponyta[] = INCBIN_U32("graphics/pokemon/ponyta/shiny.gbapal.lz");
+const u8 gMonIcon_Ponyta[] = INCBIN_U8("graphics/pokemon/ponyta/icon.4bpp");
+const u8 gMonFootprint_Ponyta[] = INCBIN_U8("graphics/pokemon/ponyta/footprint.1bpp");
+
+const u32 gMonFrontPic_Rapidash[] = INCBIN_U32("graphics/pokemon/rapidash/front.4bpp.lz");
+const u32 gMonPalette_Rapidash[] = INCBIN_U32("graphics/pokemon/rapidash/normal.gbapal.lz");
+const u32 gMonBackPic_Rapidash[] = INCBIN_U32("graphics/pokemon/rapidash/back.4bpp.lz");
+const u32 gMonShinyPalette_Rapidash[] = INCBIN_U32("graphics/pokemon/rapidash/shiny.gbapal.lz");
+const u8 gMonIcon_Rapidash[] = INCBIN_U8("graphics/pokemon/rapidash/icon.4bpp");
+const u8 gMonFootprint_Rapidash[] = INCBIN_U8("graphics/pokemon/rapidash/footprint.1bpp");
+
+const u32 gMonFrontPic_Slowpoke[] = INCBIN_U32("graphics/pokemon/slowpoke/front.4bpp.lz");
+const u32 gMonPalette_Slowpoke[] = INCBIN_U32("graphics/pokemon/slowpoke/normal.gbapal.lz");
+const u32 gMonBackPic_Slowpoke[] = INCBIN_U32("graphics/pokemon/slowpoke/back.4bpp.lz");
+const u32 gMonShinyPalette_Slowpoke[] = INCBIN_U32("graphics/pokemon/slowpoke/shiny.gbapal.lz");
+const u8 gMonIcon_Slowpoke[] = INCBIN_U8("graphics/pokemon/slowpoke/icon.4bpp");
+const u8 gMonFootprint_Slowpoke[] = INCBIN_U8("graphics/pokemon/slowpoke/footprint.1bpp");
+
+const u32 gMonFrontPic_Slowbro[] = INCBIN_U32("graphics/pokemon/slowbro/front.4bpp.lz");
+const u32 gMonPalette_Slowbro[] = INCBIN_U32("graphics/pokemon/slowbro/normal.gbapal.lz");
+const u32 gMonBackPic_Slowbro[] = INCBIN_U32("graphics/pokemon/slowbro/back.4bpp.lz");
+const u32 gMonShinyPalette_Slowbro[] = INCBIN_U32("graphics/pokemon/slowbro/shiny.gbapal.lz");
+const u8 gMonIcon_Slowbro[] = INCBIN_U8("graphics/pokemon/slowbro/icon.4bpp");
+const u8 gMonFootprint_Slowbro[] = INCBIN_U8("graphics/pokemon/slowbro/footprint.1bpp");
+
+const u32 gMonFrontPic_Magnemite[] = INCBIN_U32("graphics/pokemon/magnemite/front.4bpp.lz");
+const u32 gMonPalette_Magnemite[] = INCBIN_U32("graphics/pokemon/magnemite/normal.gbapal.lz");
+const u32 gMonBackPic_Magnemite[] = INCBIN_U32("graphics/pokemon/magnemite/back.4bpp.lz");
+const u32 gMonShinyPalette_Magnemite[] = INCBIN_U32("graphics/pokemon/magnemite/shiny.gbapal.lz");
+const u8 gMonIcon_Magnemite[] = INCBIN_U8("graphics/pokemon/magnemite/icon.4bpp");
+const u8 gMonFootprint_Magnemite[] = INCBIN_U8("graphics/pokemon/magnemite/footprint.1bpp");
+
+const u32 gMonFrontPic_Magneton[] = INCBIN_U32("graphics/pokemon/magneton/front.4bpp.lz");
+const u32 gMonPalette_Magneton[] = INCBIN_U32("graphics/pokemon/magneton/normal.gbapal.lz");
+const u32 gMonBackPic_Magneton[] = INCBIN_U32("graphics/pokemon/magneton/back.4bpp.lz");
+const u32 gMonShinyPalette_Magneton[] = INCBIN_U32("graphics/pokemon/magneton/shiny.gbapal.lz");
+const u8 gMonIcon_Magneton[] = INCBIN_U8("graphics/pokemon/magneton/icon.4bpp");
+const u8 gMonFootprint_Magneton[] = INCBIN_U8("graphics/pokemon/magneton/footprint.1bpp");
+
+const u32 gMonFrontPic_Farfetchd[] = INCBIN_U32("graphics/pokemon/farfetch_d/front.4bpp.lz");
+const u32 gMonPalette_Farfetchd[] = INCBIN_U32("graphics/pokemon/farfetch_d/normal.gbapal.lz");
+const u32 gMonBackPic_Farfetchd[] = INCBIN_U32("graphics/pokemon/farfetch_d/back.4bpp.lz");
+const u32 gMonShinyPalette_Farfetchd[] = INCBIN_U32("graphics/pokemon/farfetch_d/shiny.gbapal.lz");
+const u8 gMonIcon_Farfetchd[] = INCBIN_U8("graphics/pokemon/farfetch_d/icon.4bpp");
+const u8 gMonFootprint_Farfetchd[] = INCBIN_U8("graphics/pokemon/farfetch_d/footprint.1bpp");
+
+const u32 gMonFrontPic_Doduo[] = INCBIN_U32("graphics/pokemon/doduo/front.4bpp.lz");
+const u32 gMonPalette_Doduo[] = INCBIN_U32("graphics/pokemon/doduo/normal.gbapal.lz");
+const u32 gMonBackPic_Doduo[] = INCBIN_U32("graphics/pokemon/doduo/back.4bpp.lz");
+const u32 gMonShinyPalette_Doduo[] = INCBIN_U32("graphics/pokemon/doduo/shiny.gbapal.lz");
+const u8 gMonIcon_Doduo[] = INCBIN_U8("graphics/pokemon/doduo/icon.4bpp");
+const u8 gMonFootprint_Doduo[] = INCBIN_U8("graphics/pokemon/doduo/footprint.1bpp");
+
+const u32 gMonFrontPic_Dodrio[] = INCBIN_U32("graphics/pokemon/dodrio/front.4bpp.lz");
+const u32 gMonPalette_Dodrio[] = INCBIN_U32("graphics/pokemon/dodrio/normal.gbapal.lz");
+const u32 gMonBackPic_Dodrio[] = INCBIN_U32("graphics/pokemon/dodrio/back.4bpp.lz");
+const u32 gMonShinyPalette_Dodrio[] = INCBIN_U32("graphics/pokemon/dodrio/shiny.gbapal.lz");
+const u8 gMonIcon_Dodrio[] = INCBIN_U8("graphics/pokemon/dodrio/icon.4bpp");
+const u8 gMonFootprint_Dodrio[] = INCBIN_U8("graphics/pokemon/dodrio/footprint.1bpp");
+
+const u32 gMonFrontPic_Seel[] = INCBIN_U32("graphics/pokemon/seel/front.4bpp.lz");
+const u32 gMonPalette_Seel[] = INCBIN_U32("graphics/pokemon/seel/normal.gbapal.lz");
+const u32 gMonBackPic_Seel[] = INCBIN_U32("graphics/pokemon/seel/back.4bpp.lz");
+const u32 gMonShinyPalette_Seel[] = INCBIN_U32("graphics/pokemon/seel/shiny.gbapal.lz");
+const u8 gMonIcon_Seel[] = INCBIN_U8("graphics/pokemon/seel/icon.4bpp");
+const u8 gMonFootprint_Seel[] = INCBIN_U8("graphics/pokemon/seel/footprint.1bpp");
+
+const u32 gMonFrontPic_Dewgong[] = INCBIN_U32("graphics/pokemon/dewgong/front.4bpp.lz");
+const u32 gMonPalette_Dewgong[] = INCBIN_U32("graphics/pokemon/dewgong/normal.gbapal.lz");
+const u32 gMonBackPic_Dewgong[] = INCBIN_U32("graphics/pokemon/dewgong/back.4bpp.lz");
+const u32 gMonShinyPalette_Dewgong[] = INCBIN_U32("graphics/pokemon/dewgong/shiny.gbapal.lz");
+const u8 gMonIcon_Dewgong[] = INCBIN_U8("graphics/pokemon/dewgong/icon.4bpp");
+const u8 gMonFootprint_Dewgong[] = INCBIN_U8("graphics/pokemon/dewgong/footprint.1bpp");
+
+const u32 gMonFrontPic_Grimer[] = INCBIN_U32("graphics/pokemon/grimer/front.4bpp.lz");
+const u32 gMonPalette_Grimer[] = INCBIN_U32("graphics/pokemon/grimer/normal.gbapal.lz");
+const u32 gMonBackPic_Grimer[] = INCBIN_U32("graphics/pokemon/grimer/back.4bpp.lz");
+const u32 gMonShinyPalette_Grimer[] = INCBIN_U32("graphics/pokemon/grimer/shiny.gbapal.lz");
+const u8 gMonIcon_Grimer[] = INCBIN_U8("graphics/pokemon/grimer/icon.4bpp");
+const u8 gMonFootprint_Grimer[] = INCBIN_U8("graphics/pokemon/grimer/footprint.1bpp");
+
+const u32 gMonFrontPic_Muk[] = INCBIN_U32("graphics/pokemon/muk/front.4bpp.lz");
+const u32 gMonPalette_Muk[] = INCBIN_U32("graphics/pokemon/muk/normal.gbapal.lz");
+const u32 gMonBackPic_Muk[] = INCBIN_U32("graphics/pokemon/muk/back.4bpp.lz");
+const u32 gMonShinyPalette_Muk[] = INCBIN_U32("graphics/pokemon/muk/shiny.gbapal.lz");
+const u8 gMonIcon_Muk[] = INCBIN_U8("graphics/pokemon/muk/icon.4bpp");
+const u8 gMonFootprint_Muk[] = INCBIN_U8("graphics/pokemon/muk/footprint.1bpp");
+
+const u32 gMonFrontPic_Shellder[] = INCBIN_U32("graphics/pokemon/shellder/front.4bpp.lz");
+const u32 gMonPalette_Shellder[] = INCBIN_U32("graphics/pokemon/shellder/normal.gbapal.lz");
+const u32 gMonBackPic_Shellder[] = INCBIN_U32("graphics/pokemon/shellder/back.4bpp.lz");
+const u32 gMonShinyPalette_Shellder[] = INCBIN_U32("graphics/pokemon/shellder/shiny.gbapal.lz");
+const u8 gMonIcon_Shellder[] = INCBIN_U8("graphics/pokemon/shellder/icon.4bpp");
+const u8 gMonFootprint_Shellder[] = INCBIN_U8("graphics/pokemon/shellder/footprint.1bpp");
+
+const u32 gMonFrontPic_Cloyster[] = INCBIN_U32("graphics/pokemon/cloyster/front.4bpp.lz");
+const u32 gMonPalette_Cloyster[] = INCBIN_U32("graphics/pokemon/cloyster/normal.gbapal.lz");
+const u32 gMonBackPic_Cloyster[] = INCBIN_U32("graphics/pokemon/cloyster/back.4bpp.lz");
+const u32 gMonShinyPalette_Cloyster[] = INCBIN_U32("graphics/pokemon/cloyster/shiny.gbapal.lz");
+const u8 gMonIcon_Cloyster[] = INCBIN_U8("graphics/pokemon/cloyster/icon.4bpp");
+const u8 gMonFootprint_Cloyster[] = INCBIN_U8("graphics/pokemon/cloyster/footprint.1bpp");
+
+const u32 gMonFrontPic_Gastly[] = INCBIN_U32("graphics/pokemon/gastly/front.4bpp.lz");
+const u32 gMonPalette_Gastly[] = INCBIN_U32("graphics/pokemon/gastly/normal.gbapal.lz");
+const u32 gMonBackPic_Gastly[] = INCBIN_U32("graphics/pokemon/gastly/back.4bpp.lz");
+const u32 gMonShinyPalette_Gastly[] = INCBIN_U32("graphics/pokemon/gastly/shiny.gbapal.lz");
+const u8 gMonIcon_Gastly[] = INCBIN_U8("graphics/pokemon/gastly/icon.4bpp");
+const u8 gMonFootprint_Gastly[] = INCBIN_U8("graphics/pokemon/gastly/footprint.1bpp");
+
+const u32 gMonFrontPic_Haunter[] = INCBIN_U32("graphics/pokemon/haunter/front.4bpp.lz");
+const u32 gMonPalette_Haunter[] = INCBIN_U32("graphics/pokemon/haunter/normal.gbapal.lz");
+const u32 gMonBackPic_Haunter[] = INCBIN_U32("graphics/pokemon/haunter/back.4bpp.lz");
+const u32 gMonShinyPalette_Haunter[] = INCBIN_U32("graphics/pokemon/haunter/shiny.gbapal.lz");
+const u8 gMonIcon_Haunter[] = INCBIN_U8("graphics/pokemon/haunter/icon.4bpp");
+const u8 gMonFootprint_Haunter[] = INCBIN_U8("graphics/pokemon/haunter/footprint.1bpp");
+
+const u32 gMonFrontPic_Gengar[] = INCBIN_U32("graphics/pokemon/gengar/front.4bpp.lz");
+const u32 gMonPalette_Gengar[] = INCBIN_U32("graphics/pokemon/gengar/normal.gbapal.lz");
+const u32 gMonBackPic_Gengar[] = INCBIN_U32("graphics/pokemon/gengar/back.4bpp.lz");
+const u32 gMonShinyPalette_Gengar[] = INCBIN_U32("graphics/pokemon/gengar/shiny.gbapal.lz");
+const u8 gMonIcon_Gengar[] = INCBIN_U8("graphics/pokemon/gengar/icon.4bpp");
+const u8 gMonFootprint_Gengar[] = INCBIN_U8("graphics/pokemon/gengar/footprint.1bpp");
+
+const u32 gMonFrontPic_Onix[] = INCBIN_U32("graphics/pokemon/onix/front.4bpp.lz");
+const u32 gMonPalette_Onix[] = INCBIN_U32("graphics/pokemon/onix/normal.gbapal.lz");
+const u32 gMonBackPic_Onix[] = INCBIN_U32("graphics/pokemon/onix/back.4bpp.lz");
+const u32 gMonShinyPalette_Onix[] = INCBIN_U32("graphics/pokemon/onix/shiny.gbapal.lz");
+const u8 gMonIcon_Onix[] = INCBIN_U8("graphics/pokemon/onix/icon.4bpp");
+const u8 gMonFootprint_Onix[] = INCBIN_U8("graphics/pokemon/onix/footprint.1bpp");
+
+const u32 gMonFrontPic_Drowzee[] = INCBIN_U32("graphics/pokemon/drowzee/front.4bpp.lz");
+const u32 gMonPalette_Drowzee[] = INCBIN_U32("graphics/pokemon/drowzee/normal.gbapal.lz");
+const u32 gMonBackPic_Drowzee[] = INCBIN_U32("graphics/pokemon/drowzee/back.4bpp.lz");
+const u32 gMonShinyPalette_Drowzee[] = INCBIN_U32("graphics/pokemon/drowzee/shiny.gbapal.lz");
+const u8 gMonIcon_Drowzee[] = INCBIN_U8("graphics/pokemon/drowzee/icon.4bpp");
+const u8 gMonFootprint_Drowzee[] = INCBIN_U8("graphics/pokemon/drowzee/footprint.1bpp");
+
+const u32 gMonFrontPic_Hypno[] = INCBIN_U32("graphics/pokemon/hypno/front.4bpp.lz");
+const u32 gMonPalette_Hypno[] = INCBIN_U32("graphics/pokemon/hypno/normal.gbapal.lz");
+const u32 gMonBackPic_Hypno[] = INCBIN_U32("graphics/pokemon/hypno/back.4bpp.lz");
+const u32 gMonShinyPalette_Hypno[] = INCBIN_U32("graphics/pokemon/hypno/shiny.gbapal.lz");
+const u8 gMonIcon_Hypno[] = INCBIN_U8("graphics/pokemon/hypno/icon.4bpp");
+const u8 gMonFootprint_Hypno[] = INCBIN_U8("graphics/pokemon/hypno/footprint.1bpp");
+
+const u32 gMonFrontPic_Krabby[] = INCBIN_U32("graphics/pokemon/krabby/front.4bpp.lz");
+const u32 gMonPalette_Krabby[] = INCBIN_U32("graphics/pokemon/krabby/normal.gbapal.lz");
+const u32 gMonBackPic_Krabby[] = INCBIN_U32("graphics/pokemon/krabby/back.4bpp.lz");
+const u32 gMonShinyPalette_Krabby[] = INCBIN_U32("graphics/pokemon/krabby/shiny.gbapal.lz");
+const u8 gMonIcon_Krabby[] = INCBIN_U8("graphics/pokemon/krabby/icon.4bpp");
+const u8 gMonFootprint_Krabby[] = INCBIN_U8("graphics/pokemon/krabby/footprint.1bpp");
+
+const u32 gMonFrontPic_Kingler[] = INCBIN_U32("graphics/pokemon/kingler/front.4bpp.lz");
+const u32 gMonPalette_Kingler[] = INCBIN_U32("graphics/pokemon/kingler/normal.gbapal.lz");
+const u32 gMonBackPic_Kingler[] = INCBIN_U32("graphics/pokemon/kingler/back.4bpp.lz");
+const u32 gMonShinyPalette_Kingler[] = INCBIN_U32("graphics/pokemon/kingler/shiny.gbapal.lz");
+const u8 gMonIcon_Kingler[] = INCBIN_U8("graphics/pokemon/kingler/icon.4bpp");
+const u8 gMonFootprint_Kingler[] = INCBIN_U8("graphics/pokemon/kingler/footprint.1bpp");
+
+const u32 gMonFrontPic_Voltorb[] = INCBIN_U32("graphics/pokemon/voltorb/front.4bpp.lz");
+const u32 gMonPalette_Voltorb[] = INCBIN_U32("graphics/pokemon/voltorb/normal.gbapal.lz");
+const u32 gMonBackPic_Voltorb[] = INCBIN_U32("graphics/pokemon/voltorb/back.4bpp.lz");
+const u32 gMonShinyPalette_Voltorb[] = INCBIN_U32("graphics/pokemon/voltorb/shiny.gbapal.lz");
+const u8 gMonIcon_Voltorb[] = INCBIN_U8("graphics/pokemon/voltorb/icon.4bpp");
+const u8 gMonFootprint_Voltorb[] = INCBIN_U8("graphics/pokemon/voltorb/footprint.1bpp");
+
+const u32 gMonFrontPic_Electrode[] = INCBIN_U32("graphics/pokemon/electrode/front.4bpp.lz");
+const u32 gMonPalette_Electrode[] = INCBIN_U32("graphics/pokemon/electrode/normal.gbapal.lz");
+const u32 gMonBackPic_Electrode[] = INCBIN_U32("graphics/pokemon/electrode/back.4bpp.lz");
+const u32 gMonShinyPalette_Electrode[] = INCBIN_U32("graphics/pokemon/electrode/shiny.gbapal.lz");
+const u8 gMonIcon_Electrode[] = INCBIN_U8("graphics/pokemon/electrode/icon.4bpp");
+const u8 gMonFootprint_Electrode[] = INCBIN_U8("graphics/pokemon/electrode/footprint.1bpp");
+
+const u32 gMonFrontPic_Exeggcute[] = INCBIN_U32("graphics/pokemon/exeggcute/front.4bpp.lz");
+const u32 gMonPalette_Exeggcute[] = INCBIN_U32("graphics/pokemon/exeggcute/normal.gbapal.lz");
+const u32 gMonBackPic_Exeggcute[] = INCBIN_U32("graphics/pokemon/exeggcute/back.4bpp.lz");
+const u32 gMonShinyPalette_Exeggcute[] = INCBIN_U32("graphics/pokemon/exeggcute/shiny.gbapal.lz");
+const u8 gMonIcon_Exeggcute[] = INCBIN_U8("graphics/pokemon/exeggcute/icon.4bpp");
+const u8 gMonFootprint_Exeggcute[] = INCBIN_U8("graphics/pokemon/exeggcute/footprint.1bpp");
+
+const u32 gMonFrontPic_Exeggutor[] = INCBIN_U32("graphics/pokemon/exeggutor/front.4bpp.lz");
+const u32 gMonPalette_Exeggutor[] = INCBIN_U32("graphics/pokemon/exeggutor/normal.gbapal.lz");
+const u32 gMonBackPic_Exeggutor[] = INCBIN_U32("graphics/pokemon/exeggutor/back.4bpp.lz");
+const u32 gMonShinyPalette_Exeggutor[] = INCBIN_U32("graphics/pokemon/exeggutor/shiny.gbapal.lz");
+const u8 gMonIcon_Exeggutor[] = INCBIN_U8("graphics/pokemon/exeggutor/icon.4bpp");
+const u8 gMonFootprint_Exeggutor[] = INCBIN_U8("graphics/pokemon/exeggutor/footprint.1bpp");
+
+const u32 gMonFrontPic_Cubone[] = INCBIN_U32("graphics/pokemon/cubone/front.4bpp.lz");
+const u32 gMonPalette_Cubone[] = INCBIN_U32("graphics/pokemon/cubone/normal.gbapal.lz");
+const u32 gMonBackPic_Cubone[] = INCBIN_U32("graphics/pokemon/cubone/back.4bpp.lz");
+const u32 gMonShinyPalette_Cubone[] = INCBIN_U32("graphics/pokemon/cubone/shiny.gbapal.lz");
+const u8 gMonIcon_Cubone[] = INCBIN_U8("graphics/pokemon/cubone/icon.4bpp");
+const u8 gMonFootprint_Cubone[] = INCBIN_U8("graphics/pokemon/cubone/footprint.1bpp");
+
+const u32 gMonFrontPic_Marowak[] = INCBIN_U32("graphics/pokemon/marowak/front.4bpp.lz");
+const u32 gMonPalette_Marowak[] = INCBIN_U32("graphics/pokemon/marowak/normal.gbapal.lz");
+const u32 gMonBackPic_Marowak[] = INCBIN_U32("graphics/pokemon/marowak/back.4bpp.lz");
+const u32 gMonShinyPalette_Marowak[] = INCBIN_U32("graphics/pokemon/marowak/shiny.gbapal.lz");
+const u8 gMonIcon_Marowak[] = INCBIN_U8("graphics/pokemon/marowak/icon.4bpp");
+const u8 gMonFootprint_Marowak[] = INCBIN_U8("graphics/pokemon/marowak/footprint.1bpp");
+
+const u32 gMonFrontPic_Hitmonlee[] = INCBIN_U32("graphics/pokemon/hitmonlee/front.4bpp.lz");
+const u32 gMonPalette_Hitmonlee[] = INCBIN_U32("graphics/pokemon/hitmonlee/normal.gbapal.lz");
+const u32 gMonBackPic_Hitmonlee[] = INCBIN_U32("graphics/pokemon/hitmonlee/back.4bpp.lz");
+const u32 gMonShinyPalette_Hitmonlee[] = INCBIN_U32("graphics/pokemon/hitmonlee/shiny.gbapal.lz");
+const u8 gMonIcon_Hitmonlee[] = INCBIN_U8("graphics/pokemon/hitmonlee/icon.4bpp");
+const u8 gMonFootprint_Hitmonlee[] = INCBIN_U8("graphics/pokemon/hitmonlee/footprint.1bpp");
+
+const u32 gMonFrontPic_Hitmonchan[] = INCBIN_U32("graphics/pokemon/hitmonchan/front.4bpp.lz");
+const u32 gMonPalette_Hitmonchan[] = INCBIN_U32("graphics/pokemon/hitmonchan/normal.gbapal.lz");
+const u32 gMonBackPic_Hitmonchan[] = INCBIN_U32("graphics/pokemon/hitmonchan/back.4bpp.lz");
+const u32 gMonShinyPalette_Hitmonchan[] = INCBIN_U32("graphics/pokemon/hitmonchan/shiny.gbapal.lz");
+const u8 gMonIcon_Hitmonchan[] = INCBIN_U8("graphics/pokemon/hitmonchan/icon.4bpp");
+const u8 gMonFootprint_Hitmonchan[] = INCBIN_U8("graphics/pokemon/hitmonchan/footprint.1bpp");
+
+const u32 gMonFrontPic_Lickitung[] = INCBIN_U32("graphics/pokemon/lickitung/front.4bpp.lz");
+const u32 gMonPalette_Lickitung[] = INCBIN_U32("graphics/pokemon/lickitung/normal.gbapal.lz");
+const u32 gMonBackPic_Lickitung[] = INCBIN_U32("graphics/pokemon/lickitung/back.4bpp.lz");
+const u32 gMonShinyPalette_Lickitung[] = INCBIN_U32("graphics/pokemon/lickitung/shiny.gbapal.lz");
+const u8 gMonIcon_Lickitung[] = INCBIN_U8("graphics/pokemon/lickitung/icon.4bpp");
+const u8 gMonFootprint_Lickitung[] = INCBIN_U8("graphics/pokemon/lickitung/footprint.1bpp");
+
+const u32 gMonFrontPic_Koffing[] = INCBIN_U32("graphics/pokemon/koffing/front.4bpp.lz");
+const u32 gMonPalette_Koffing[] = INCBIN_U32("graphics/pokemon/koffing/normal.gbapal.lz");
+const u32 gMonBackPic_Koffing[] = INCBIN_U32("graphics/pokemon/koffing/back.4bpp.lz");
+const u32 gMonShinyPalette_Koffing[] = INCBIN_U32("graphics/pokemon/koffing/shiny.gbapal.lz");
+const u8 gMonIcon_Koffing[] = INCBIN_U8("graphics/pokemon/koffing/icon.4bpp");
+const u8 gMonFootprint_Koffing[] = INCBIN_U8("graphics/pokemon/koffing/footprint.1bpp");
+
+const u32 gMonFrontPic_Weezing[] = INCBIN_U32("graphics/pokemon/weezing/front.4bpp.lz");
+const u32 gMonPalette_Weezing[] = INCBIN_U32("graphics/pokemon/weezing/normal.gbapal.lz");
+const u32 gMonBackPic_Weezing[] = INCBIN_U32("graphics/pokemon/weezing/back.4bpp.lz");
+const u32 gMonShinyPalette_Weezing[] = INCBIN_U32("graphics/pokemon/weezing/shiny.gbapal.lz");
+const u8 gMonIcon_Weezing[] = INCBIN_U8("graphics/pokemon/weezing/icon.4bpp");
+const u8 gMonFootprint_Weezing[] = INCBIN_U8("graphics/pokemon/weezing/footprint.1bpp");
+
+const u32 gMonFrontPic_Rhyhorn[] = INCBIN_U32("graphics/pokemon/rhyhorn/front.4bpp.lz");
+const u32 gMonPalette_Rhyhorn[] = INCBIN_U32("graphics/pokemon/rhyhorn/normal.gbapal.lz");
+const u32 gMonBackPic_Rhyhorn[] = INCBIN_U32("graphics/pokemon/rhyhorn/back.4bpp.lz");
+const u32 gMonShinyPalette_Rhyhorn[] = INCBIN_U32("graphics/pokemon/rhyhorn/shiny.gbapal.lz");
+const u8 gMonIcon_Rhyhorn[] = INCBIN_U8("graphics/pokemon/rhyhorn/icon.4bpp");
+const u8 gMonFootprint_Rhyhorn[] = INCBIN_U8("graphics/pokemon/rhyhorn/footprint.1bpp");
+
+const u32 gMonFrontPic_Rhydon[] = INCBIN_U32("graphics/pokemon/rhydon/front.4bpp.lz");
+const u32 gMonPalette_Rhydon[] = INCBIN_U32("graphics/pokemon/rhydon/normal.gbapal.lz");
+const u32 gMonBackPic_Rhydon[] = INCBIN_U32("graphics/pokemon/rhydon/back.4bpp.lz");
+const u32 gMonShinyPalette_Rhydon[] = INCBIN_U32("graphics/pokemon/rhydon/shiny.gbapal.lz");
+const u8 gMonIcon_Rhydon[] = INCBIN_U8("graphics/pokemon/rhydon/icon.4bpp");
+const u8 gMonFootprint_Rhydon[] = INCBIN_U8("graphics/pokemon/rhydon/footprint.1bpp");
+
+const u32 gMonFrontPic_Chansey[] = INCBIN_U32("graphics/pokemon/chansey/front.4bpp.lz");
+const u32 gMonPalette_Chansey[] = INCBIN_U32("graphics/pokemon/chansey/normal.gbapal.lz");
+const u32 gMonBackPic_Chansey[] = INCBIN_U32("graphics/pokemon/chansey/back.4bpp.lz");
+const u32 gMonShinyPalette_Chansey[] = INCBIN_U32("graphics/pokemon/chansey/shiny.gbapal.lz");
+const u8 gMonIcon_Chansey[] = INCBIN_U8("graphics/pokemon/chansey/icon.4bpp");
+const u8 gMonFootprint_Chansey[] = INCBIN_U8("graphics/pokemon/chansey/footprint.1bpp");
+
+const u32 gMonFrontPic_Tangela[] = INCBIN_U32("graphics/pokemon/tangela/front.4bpp.lz");
+const u32 gMonPalette_Tangela[] = INCBIN_U32("graphics/pokemon/tangela/normal.gbapal.lz");
+const u32 gMonBackPic_Tangela[] = INCBIN_U32("graphics/pokemon/tangela/back.4bpp.lz");
+const u32 gMonShinyPalette_Tangela[] = INCBIN_U32("graphics/pokemon/tangela/shiny.gbapal.lz");
+const u8 gMonIcon_Tangela[] = INCBIN_U8("graphics/pokemon/tangela/icon.4bpp");
+const u8 gMonFootprint_Tangela[] = INCBIN_U8("graphics/pokemon/tangela/footprint.1bpp");
+
+const u32 gMonFrontPic_Kangaskhan[] = INCBIN_U32("graphics/pokemon/kangaskhan/front.4bpp.lz");
+const u32 gMonPalette_Kangaskhan[] = INCBIN_U32("graphics/pokemon/kangaskhan/normal.gbapal.lz");
+const u32 gMonBackPic_Kangaskhan[] = INCBIN_U32("graphics/pokemon/kangaskhan/back.4bpp.lz");
+const u32 gMonShinyPalette_Kangaskhan[] = INCBIN_U32("graphics/pokemon/kangaskhan/shiny.gbapal.lz");
+const u8 gMonIcon_Kangaskhan[] = INCBIN_U8("graphics/pokemon/kangaskhan/icon.4bpp");
+const u8 gMonFootprint_Kangaskhan[] = INCBIN_U8("graphics/pokemon/kangaskhan/footprint.1bpp");
+
+const u32 gMonFrontPic_Horsea[] = INCBIN_U32("graphics/pokemon/horsea/front.4bpp.lz");
+const u32 gMonPalette_Horsea[] = INCBIN_U32("graphics/pokemon/horsea/normal.gbapal.lz");
+const u32 gMonBackPic_Horsea[] = INCBIN_U32("graphics/pokemon/horsea/back.4bpp.lz");
+const u32 gMonShinyPalette_Horsea[] = INCBIN_U32("graphics/pokemon/horsea/shiny.gbapal.lz");
+const u8 gMonIcon_Horsea[] = INCBIN_U8("graphics/pokemon/horsea/icon.4bpp");
+const u8 gMonFootprint_Horsea[] = INCBIN_U8("graphics/pokemon/horsea/footprint.1bpp");
+
+const u32 gMonFrontPic_Seadra[] = INCBIN_U32("graphics/pokemon/seadra/front.4bpp.lz");
+const u32 gMonPalette_Seadra[] = INCBIN_U32("graphics/pokemon/seadra/normal.gbapal.lz");
+const u32 gMonBackPic_Seadra[] = INCBIN_U32("graphics/pokemon/seadra/back.4bpp.lz");
+const u32 gMonShinyPalette_Seadra[] = INCBIN_U32("graphics/pokemon/seadra/shiny.gbapal.lz");
+const u8 gMonIcon_Seadra[] = INCBIN_U8("graphics/pokemon/seadra/icon.4bpp");
+const u8 gMonFootprint_Seadra[] = INCBIN_U8("graphics/pokemon/seadra/footprint.1bpp");
+
+const u32 gMonFrontPic_Goldeen[] = INCBIN_U32("graphics/pokemon/goldeen/front.4bpp.lz");
+const u32 gMonPalette_Goldeen[] = INCBIN_U32("graphics/pokemon/goldeen/normal.gbapal.lz");
+const u32 gMonBackPic_Goldeen[] = INCBIN_U32("graphics/pokemon/goldeen/back.4bpp.lz");
+const u32 gMonShinyPalette_Goldeen[] = INCBIN_U32("graphics/pokemon/goldeen/shiny.gbapal.lz");
+const u8 gMonIcon_Goldeen[] = INCBIN_U8("graphics/pokemon/goldeen/icon.4bpp");
+const u8 gMonFootprint_Goldeen[] = INCBIN_U8("graphics/pokemon/goldeen/footprint.1bpp");
+
+const u32 gMonFrontPic_Seaking[] = INCBIN_U32("graphics/pokemon/seaking/front.4bpp.lz");
+const u32 gMonPalette_Seaking[] = INCBIN_U32("graphics/pokemon/seaking/normal.gbapal.lz");
+const u32 gMonBackPic_Seaking[] = INCBIN_U32("graphics/pokemon/seaking/back.4bpp.lz");
+const u32 gMonShinyPalette_Seaking[] = INCBIN_U32("graphics/pokemon/seaking/shiny.gbapal.lz");
+const u8 gMonIcon_Seaking[] = INCBIN_U8("graphics/pokemon/seaking/icon.4bpp");
+const u8 gMonFootprint_Seaking[] = INCBIN_U8("graphics/pokemon/seaking/footprint.1bpp");
+
+const u32 gMonFrontPic_Staryu[] = INCBIN_U32("graphics/pokemon/staryu/front.4bpp.lz");
+const u32 gMonPalette_Staryu[] = INCBIN_U32("graphics/pokemon/staryu/normal.gbapal.lz");
+const u32 gMonBackPic_Staryu[] = INCBIN_U32("graphics/pokemon/staryu/back.4bpp.lz");
+const u32 gMonShinyPalette_Staryu[] = INCBIN_U32("graphics/pokemon/staryu/shiny.gbapal.lz");
+const u8 gMonIcon_Staryu[] = INCBIN_U8("graphics/pokemon/staryu/icon.4bpp");
+const u8 gMonFootprint_Staryu[] = INCBIN_U8("graphics/pokemon/staryu/footprint.1bpp");
+
+const u32 gMonFrontPic_Starmie[] = INCBIN_U32("graphics/pokemon/starmie/front.4bpp.lz");
+const u32 gMonPalette_Starmie[] = INCBIN_U32("graphics/pokemon/starmie/normal.gbapal.lz");
+const u32 gMonBackPic_Starmie[] = INCBIN_U32("graphics/pokemon/starmie/back.4bpp.lz");
+const u32 gMonShinyPalette_Starmie[] = INCBIN_U32("graphics/pokemon/starmie/shiny.gbapal.lz");
+const u8 gMonIcon_Starmie[] = INCBIN_U8("graphics/pokemon/starmie/icon.4bpp");
+const u8 gMonFootprint_Starmie[] = INCBIN_U8("graphics/pokemon/starmie/footprint.1bpp");
+
+const u32 gMonFrontPic_Mrmime[] = INCBIN_U32("graphics/pokemon/mr_mime/front.4bpp.lz");
+const u32 gMonPalette_Mrmime[] = INCBIN_U32("graphics/pokemon/mr_mime/normal.gbapal.lz");
+const u32 gMonBackPic_Mrmime[] = INCBIN_U32("graphics/pokemon/mr_mime/back.4bpp.lz");
+const u32 gMonShinyPalette_Mrmime[] = INCBIN_U32("graphics/pokemon/mr_mime/shiny.gbapal.lz");
+const u8 gMonIcon_Mrmime[] = INCBIN_U8("graphics/pokemon/mr_mime/icon.4bpp");
+const u8 gMonFootprint_Mrmime[] = INCBIN_U8("graphics/pokemon/mr_mime/footprint.1bpp");
+
+const u32 gMonFrontPic_Scyther[] = INCBIN_U32("graphics/pokemon/scyther/front.4bpp.lz");
+const u32 gMonPalette_Scyther[] = INCBIN_U32("graphics/pokemon/scyther/normal.gbapal.lz");
+const u32 gMonBackPic_Scyther[] = INCBIN_U32("graphics/pokemon/scyther/back.4bpp.lz");
+const u32 gMonShinyPalette_Scyther[] = INCBIN_U32("graphics/pokemon/scyther/shiny.gbapal.lz");
+const u8 gMonIcon_Scyther[] = INCBIN_U8("graphics/pokemon/scyther/icon.4bpp");
+const u8 gMonFootprint_Scyther[] = INCBIN_U8("graphics/pokemon/scyther/footprint.1bpp");
+
+const u32 gMonFrontPic_Jynx[] = INCBIN_U32("graphics/pokemon/jynx/front.4bpp.lz");
+const u32 gMonPalette_Jynx[] = INCBIN_U32("graphics/pokemon/jynx/normal.gbapal.lz");
+const u32 gMonBackPic_Jynx[] = INCBIN_U32("graphics/pokemon/jynx/back.4bpp.lz");
+const u32 gMonShinyPalette_Jynx[] = INCBIN_U32("graphics/pokemon/jynx/shiny.gbapal.lz");
+const u8 gMonIcon_Jynx[] = INCBIN_U8("graphics/pokemon/jynx/icon.4bpp");
+const u8 gMonFootprint_Jynx[] = INCBIN_U8("graphics/pokemon/jynx/footprint.1bpp");
+
+const u32 gMonFrontPic_Electabuzz[] = INCBIN_U32("graphics/pokemon/electabuzz/front.4bpp.lz");
+const u32 gMonPalette_Electabuzz[] = INCBIN_U32("graphics/pokemon/electabuzz/normal.gbapal.lz");
+const u32 gMonBackPic_Electabuzz[] = INCBIN_U32("graphics/pokemon/electabuzz/back.4bpp.lz");
+const u32 gMonShinyPalette_Electabuzz[] = INCBIN_U32("graphics/pokemon/electabuzz/shiny.gbapal.lz");
+const u8 gMonIcon_Electabuzz[] = INCBIN_U8("graphics/pokemon/electabuzz/icon.4bpp");
+const u8 gMonFootprint_Electabuzz[] = INCBIN_U8("graphics/pokemon/electabuzz/footprint.1bpp");
+
+const u32 gMonFrontPic_Magmar[] = INCBIN_U32("graphics/pokemon/magmar/front.4bpp.lz");
+const u32 gMonPalette_Magmar[] = INCBIN_U32("graphics/pokemon/magmar/normal.gbapal.lz");
+const u32 gMonBackPic_Magmar[] = INCBIN_U32("graphics/pokemon/magmar/back.4bpp.lz");
+const u32 gMonShinyPalette_Magmar[] = INCBIN_U32("graphics/pokemon/magmar/shiny.gbapal.lz");
+const u8 gMonIcon_Magmar[] = INCBIN_U8("graphics/pokemon/magmar/icon.4bpp");
+const u8 gMonFootprint_Magmar[] = INCBIN_U8("graphics/pokemon/magmar/footprint.1bpp");
+
+const u32 gMonFrontPic_Pinsir[] = INCBIN_U32("graphics/pokemon/pinsir/front.4bpp.lz");
+const u32 gMonPalette_Pinsir[] = INCBIN_U32("graphics/pokemon/pinsir/normal.gbapal.lz");
+const u32 gMonBackPic_Pinsir[] = INCBIN_U32("graphics/pokemon/pinsir/back.4bpp.lz");
+const u32 gMonShinyPalette_Pinsir[] = INCBIN_U32("graphics/pokemon/pinsir/shiny.gbapal.lz");
+const u8 gMonIcon_Pinsir[] = INCBIN_U8("graphics/pokemon/pinsir/icon.4bpp");
+const u8 gMonFootprint_Pinsir[] = INCBIN_U8("graphics/pokemon/pinsir/footprint.1bpp");
+
+const u32 gMonFrontPic_Tauros[] = INCBIN_U32("graphics/pokemon/tauros/front.4bpp.lz");
+const u32 gMonPalette_Tauros[] = INCBIN_U32("graphics/pokemon/tauros/normal.gbapal.lz");
+const u32 gMonBackPic_Tauros[] = INCBIN_U32("graphics/pokemon/tauros/back.4bpp.lz");
+const u32 gMonShinyPalette_Tauros[] = INCBIN_U32("graphics/pokemon/tauros/shiny.gbapal.lz");
+const u8 gMonIcon_Tauros[] = INCBIN_U8("graphics/pokemon/tauros/icon.4bpp");
+const u8 gMonFootprint_Tauros[] = INCBIN_U8("graphics/pokemon/tauros/footprint.1bpp");
+
+const u32 gMonFrontPic_Magikarp[] = INCBIN_U32("graphics/pokemon/magikarp/front.4bpp.lz");
+const u32 gMonPalette_Magikarp[] = INCBIN_U32("graphics/pokemon/magikarp/normal.gbapal.lz");
+const u32 gMonBackPic_Magikarp[] = INCBIN_U32("graphics/pokemon/magikarp/back.4bpp.lz");
+const u32 gMonShinyPalette_Magikarp[] = INCBIN_U32("graphics/pokemon/magikarp/shiny.gbapal.lz");
+const u8 gMonIcon_Magikarp[] = INCBIN_U8("graphics/pokemon/magikarp/icon.4bpp");
+const u8 gMonFootprint_Magikarp[] = INCBIN_U8("graphics/pokemon/magikarp/footprint.1bpp");
+
+const u32 gMonFrontPic_Gyarados[] = INCBIN_U32("graphics/pokemon/gyarados/front.4bpp.lz");
+const u32 gMonPalette_Gyarados[] = INCBIN_U32("graphics/pokemon/gyarados/normal.gbapal.lz");
+const u32 gMonBackPic_Gyarados[] = INCBIN_U32("graphics/pokemon/gyarados/back.4bpp.lz");
+const u32 gMonShinyPalette_Gyarados[] = INCBIN_U32("graphics/pokemon/gyarados/shiny.gbapal.lz");
+const u8 gMonIcon_Gyarados[] = INCBIN_U8("graphics/pokemon/gyarados/icon.4bpp");
+const u8 gMonFootprint_Gyarados[] = INCBIN_U8("graphics/pokemon/gyarados/footprint.1bpp");
+
+const u32 gMonFrontPic_Lapras[] = INCBIN_U32("graphics/pokemon/lapras/front.4bpp.lz");
+const u32 gMonPalette_Lapras[] = INCBIN_U32("graphics/pokemon/lapras/normal.gbapal.lz");
+const u32 gMonBackPic_Lapras[] = INCBIN_U32("graphics/pokemon/lapras/back.4bpp.lz");
+const u32 gMonShinyPalette_Lapras[] = INCBIN_U32("graphics/pokemon/lapras/shiny.gbapal.lz");
+const u8 gMonIcon_Lapras[] = INCBIN_U8("graphics/pokemon/lapras/icon.4bpp");
+const u8 gMonFootprint_Lapras[] = INCBIN_U8("graphics/pokemon/lapras/footprint.1bpp");
+
+const u32 gMonFrontPic_Ditto[] = INCBIN_U32("graphics/pokemon/ditto/front.4bpp.lz");
+const u32 gMonPalette_Ditto[] = INCBIN_U32("graphics/pokemon/ditto/normal.gbapal.lz");
+const u32 gMonBackPic_Ditto[] = INCBIN_U32("graphics/pokemon/ditto/back.4bpp.lz");
+const u32 gMonShinyPalette_Ditto[] = INCBIN_U32("graphics/pokemon/ditto/shiny.gbapal.lz");
+const u8 gMonIcon_Ditto[] = INCBIN_U8("graphics/pokemon/ditto/icon.4bpp");
+const u8 gMonFootprint_Ditto[] = INCBIN_U8("graphics/pokemon/ditto/footprint.1bpp");
+
+const u32 gMonFrontPic_Eevee[] = INCBIN_U32("graphics/pokemon/eevee/front.4bpp.lz");
+const u32 gMonPalette_Eevee[] = INCBIN_U32("graphics/pokemon/eevee/normal.gbapal.lz");
+const u32 gMonBackPic_Eevee[] = INCBIN_U32("graphics/pokemon/eevee/back.4bpp.lz");
+const u32 gMonShinyPalette_Eevee[] = INCBIN_U32("graphics/pokemon/eevee/shiny.gbapal.lz");
+const u8 gMonIcon_Eevee[] = INCBIN_U8("graphics/pokemon/eevee/icon.4bpp");
+const u8 gMonFootprint_Eevee[] = INCBIN_U8("graphics/pokemon/eevee/footprint.1bpp");
+
+const u32 gMonFrontPic_Vaporeon[] = INCBIN_U32("graphics/pokemon/vaporeon/front.4bpp.lz");
+const u32 gMonPalette_Vaporeon[] = INCBIN_U32("graphics/pokemon/vaporeon/normal.gbapal.lz");
+const u32 gMonBackPic_Vaporeon[] = INCBIN_U32("graphics/pokemon/vaporeon/back.4bpp.lz");
+const u32 gMonShinyPalette_Vaporeon[] = INCBIN_U32("graphics/pokemon/vaporeon/shiny.gbapal.lz");
+const u8 gMonIcon_Vaporeon[] = INCBIN_U8("graphics/pokemon/vaporeon/icon.4bpp");
+const u8 gMonFootprint_Vaporeon[] = INCBIN_U8("graphics/pokemon/vaporeon/footprint.1bpp");
+
+const u32 gMonFrontPic_Jolteon[] = INCBIN_U32("graphics/pokemon/jolteon/front.4bpp.lz");
+const u32 gMonPalette_Jolteon[] = INCBIN_U32("graphics/pokemon/jolteon/normal.gbapal.lz");
+const u32 gMonBackPic_Jolteon[] = INCBIN_U32("graphics/pokemon/jolteon/back.4bpp.lz");
+const u32 gMonShinyPalette_Jolteon[] = INCBIN_U32("graphics/pokemon/jolteon/shiny.gbapal.lz");
+const u8 gMonIcon_Jolteon[] = INCBIN_U8("graphics/pokemon/jolteon/icon.4bpp");
+const u8 gMonFootprint_Jolteon[] = INCBIN_U8("graphics/pokemon/jolteon/footprint.1bpp");
+
+const u32 gMonFrontPic_Flareon[] = INCBIN_U32("graphics/pokemon/flareon/front.4bpp.lz");
+const u32 gMonPalette_Flareon[] = INCBIN_U32("graphics/pokemon/flareon/normal.gbapal.lz");
+const u32 gMonBackPic_Flareon[] = INCBIN_U32("graphics/pokemon/flareon/back.4bpp.lz");
+const u32 gMonShinyPalette_Flareon[] = INCBIN_U32("graphics/pokemon/flareon/shiny.gbapal.lz");
+const u8 gMonIcon_Flareon[] = INCBIN_U8("graphics/pokemon/flareon/icon.4bpp");
+const u8 gMonFootprint_Flareon[] = INCBIN_U8("graphics/pokemon/flareon/footprint.1bpp");
+
+const u32 gMonFrontPic_Porygon[] = INCBIN_U32("graphics/pokemon/porygon/front.4bpp.lz");
+const u32 gMonPalette_Porygon[] = INCBIN_U32("graphics/pokemon/porygon/normal.gbapal.lz");
+const u32 gMonBackPic_Porygon[] = INCBIN_U32("graphics/pokemon/porygon/back.4bpp.lz");
+const u32 gMonShinyPalette_Porygon[] = INCBIN_U32("graphics/pokemon/porygon/shiny.gbapal.lz");
+const u8 gMonIcon_Porygon[] = INCBIN_U8("graphics/pokemon/porygon/icon.4bpp");
+const u8 gMonFootprint_Porygon[] = INCBIN_U8("graphics/pokemon/porygon/footprint.1bpp");
+
+const u32 gMonFrontPic_Omanyte[] = INCBIN_U32("graphics/pokemon/omanyte/front.4bpp.lz");
+const u32 gMonPalette_Omanyte[] = INCBIN_U32("graphics/pokemon/omanyte/normal.gbapal.lz");
+const u32 gMonBackPic_Omanyte[] = INCBIN_U32("graphics/pokemon/omanyte/back.4bpp.lz");
+const u32 gMonShinyPalette_Omanyte[] = INCBIN_U32("graphics/pokemon/omanyte/shiny.gbapal.lz");
+const u8 gMonIcon_Omanyte[] = INCBIN_U8("graphics/pokemon/omanyte/icon.4bpp");
+const u8 gMonFootprint_Omanyte[] = INCBIN_U8("graphics/pokemon/omanyte/footprint.1bpp");
+
+const u32 gMonFrontPic_Omastar[] = INCBIN_U32("graphics/pokemon/omastar/front.4bpp.lz");
+const u32 gMonPalette_Omastar[] = INCBIN_U32("graphics/pokemon/omastar/normal.gbapal.lz");
+const u32 gMonBackPic_Omastar[] = INCBIN_U32("graphics/pokemon/omastar/back.4bpp.lz");
+const u32 gMonShinyPalette_Omastar[] = INCBIN_U32("graphics/pokemon/omastar/shiny.gbapal.lz");
+const u8 gMonIcon_Omastar[] = INCBIN_U8("graphics/pokemon/omastar/icon.4bpp");
+const u8 gMonFootprint_Omastar[] = INCBIN_U8("graphics/pokemon/omastar/footprint.1bpp");
+
+const u32 gMonFrontPic_Kabuto[] = INCBIN_U32("graphics/pokemon/kabuto/front.4bpp.lz");
+const u32 gMonPalette_Kabuto[] = INCBIN_U32("graphics/pokemon/kabuto/normal.gbapal.lz");
+const u32 gMonBackPic_Kabuto[] = INCBIN_U32("graphics/pokemon/kabuto/back.4bpp.lz");
+const u32 gMonShinyPalette_Kabuto[] = INCBIN_U32("graphics/pokemon/kabuto/shiny.gbapal.lz");
+const u8 gMonIcon_Kabuto[] = INCBIN_U8("graphics/pokemon/kabuto/icon.4bpp");
+const u8 gMonFootprint_Kabuto[] = INCBIN_U8("graphics/pokemon/kabuto/footprint.1bpp");
+
+const u32 gMonFrontPic_Kabutops[] = INCBIN_U32("graphics/pokemon/kabutops/front.4bpp.lz");
+const u32 gMonPalette_Kabutops[] = INCBIN_U32("graphics/pokemon/kabutops/normal.gbapal.lz");
+const u32 gMonBackPic_Kabutops[] = INCBIN_U32("graphics/pokemon/kabutops/back.4bpp.lz");
+const u32 gMonShinyPalette_Kabutops[] = INCBIN_U32("graphics/pokemon/kabutops/shiny.gbapal.lz");
+const u8 gMonIcon_Kabutops[] = INCBIN_U8("graphics/pokemon/kabutops/icon.4bpp");
+const u8 gMonFootprint_Kabutops[] = INCBIN_U8("graphics/pokemon/kabutops/footprint.1bpp");
+
+const u32 gMonFrontPic_Aerodactyl[] = INCBIN_U32("graphics/pokemon/aerodactyl/front.4bpp.lz");
+const u32 gMonPalette_Aerodactyl[] = INCBIN_U32("graphics/pokemon/aerodactyl/normal.gbapal.lz");
+const u32 gMonBackPic_Aerodactyl[] = INCBIN_U32("graphics/pokemon/aerodactyl/back.4bpp.lz");
+const u32 gMonShinyPalette_Aerodactyl[] = INCBIN_U32("graphics/pokemon/aerodactyl/shiny.gbapal.lz");
+const u8 gMonIcon_Aerodactyl[] = INCBIN_U8("graphics/pokemon/aerodactyl/icon.4bpp");
+const u8 gMonFootprint_Aerodactyl[] = INCBIN_U8("graphics/pokemon/aerodactyl/footprint.1bpp");
+
+const u32 gMonFrontPic_Snorlax[] = INCBIN_U32("graphics/pokemon/snorlax/front.4bpp.lz");
+const u32 gMonPalette_Snorlax[] = INCBIN_U32("graphics/pokemon/snorlax/normal.gbapal.lz");
+const u32 gMonBackPic_Snorlax[] = INCBIN_U32("graphics/pokemon/snorlax/back.4bpp.lz");
+const u32 gMonShinyPalette_Snorlax[] = INCBIN_U32("graphics/pokemon/snorlax/shiny.gbapal.lz");
+const u8 gMonIcon_Snorlax[] = INCBIN_U8("graphics/pokemon/snorlax/icon.4bpp");
+const u8 gMonFootprint_Snorlax[] = INCBIN_U8("graphics/pokemon/snorlax/footprint.1bpp");
+
+const u32 gMonFrontPic_Articuno[] = INCBIN_U32("graphics/pokemon/articuno/front.4bpp.lz");
+const u32 gMonPalette_Articuno[] = INCBIN_U32("graphics/pokemon/articuno/normal.gbapal.lz");
+const u32 gMonBackPic_Articuno[] = INCBIN_U32("graphics/pokemon/articuno/back.4bpp.lz");
+const u32 gMonShinyPalette_Articuno[] = INCBIN_U32("graphics/pokemon/articuno/shiny.gbapal.lz");
+const u8 gMonIcon_Articuno[] = INCBIN_U8("graphics/pokemon/articuno/icon.4bpp");
+const u8 gMonFootprint_Articuno[] = INCBIN_U8("graphics/pokemon/articuno/footprint.1bpp");
+
+const u32 gMonFrontPic_Zapdos[] = INCBIN_U32("graphics/pokemon/zapdos/front.4bpp.lz");
+const u32 gMonPalette_Zapdos[] = INCBIN_U32("graphics/pokemon/zapdos/normal.gbapal.lz");
+const u32 gMonBackPic_Zapdos[] = INCBIN_U32("graphics/pokemon/zapdos/back.4bpp.lz");
+const u32 gMonShinyPalette_Zapdos[] = INCBIN_U32("graphics/pokemon/zapdos/shiny.gbapal.lz");
+const u8 gMonIcon_Zapdos[] = INCBIN_U8("graphics/pokemon/zapdos/icon.4bpp");
+const u8 gMonFootprint_Zapdos[] = INCBIN_U8("graphics/pokemon/zapdos/footprint.1bpp");
+
+const u32 gMonFrontPic_Moltres[] = INCBIN_U32("graphics/pokemon/moltres/front.4bpp.lz");
+const u32 gMonPalette_Moltres[] = INCBIN_U32("graphics/pokemon/moltres/normal.gbapal.lz");
+const u32 gMonBackPic_Moltres[] = INCBIN_U32("graphics/pokemon/moltres/back.4bpp.lz");
+const u32 gMonShinyPalette_Moltres[] = INCBIN_U32("graphics/pokemon/moltres/shiny.gbapal.lz");
+const u8 gMonIcon_Moltres[] = INCBIN_U8("graphics/pokemon/moltres/icon.4bpp");
+const u8 gMonFootprint_Moltres[] = INCBIN_U8("graphics/pokemon/moltres/footprint.1bpp");
+
+const u32 gMonFrontPic_Dratini[] = INCBIN_U32("graphics/pokemon/dratini/front.4bpp.lz");
+const u32 gMonPalette_Dratini[] = INCBIN_U32("graphics/pokemon/dratini/normal.gbapal.lz");
+const u32 gMonBackPic_Dratini[] = INCBIN_U32("graphics/pokemon/dratini/back.4bpp.lz");
+const u32 gMonShinyPalette_Dratini[] = INCBIN_U32("graphics/pokemon/dratini/shiny.gbapal.lz");
+const u8 gMonIcon_Dratini[] = INCBIN_U8("graphics/pokemon/dratini/icon.4bpp");
+const u8 gMonFootprint_Dratini[] = INCBIN_U8("graphics/pokemon/dratini/footprint.1bpp");
+
+const u32 gMonFrontPic_Dragonair[] = INCBIN_U32("graphics/pokemon/dragonair/front.4bpp.lz");
+const u32 gMonPalette_Dragonair[] = INCBIN_U32("graphics/pokemon/dragonair/normal.gbapal.lz");
+const u32 gMonBackPic_Dragonair[] = INCBIN_U32("graphics/pokemon/dragonair/back.4bpp.lz");
+const u32 gMonShinyPalette_Dragonair[] = INCBIN_U32("graphics/pokemon/dragonair/shiny.gbapal.lz");
+const u8 gMonIcon_Dragonair[] = INCBIN_U8("graphics/pokemon/dragonair/icon.4bpp");
+const u8 gMonFootprint_Dragonair[] = INCBIN_U8("graphics/pokemon/dragonair/footprint.1bpp");
+
+const u32 gMonFrontPic_Dragonite[] = INCBIN_U32("graphics/pokemon/dragonite/front.4bpp.lz");
+const u32 gMonPalette_Dragonite[] = INCBIN_U32("graphics/pokemon/dragonite/normal.gbapal.lz");
+const u32 gMonBackPic_Dragonite[] = INCBIN_U32("graphics/pokemon/dragonite/back.4bpp.lz");
+const u32 gMonShinyPalette_Dragonite[] = INCBIN_U32("graphics/pokemon/dragonite/shiny.gbapal.lz");
+const u8 gMonIcon_Dragonite[] = INCBIN_U8("graphics/pokemon/dragonite/icon.4bpp");
+const u8 gMonFootprint_Dragonite[] = INCBIN_U8("graphics/pokemon/dragonite/footprint.1bpp");
+
+const u32 gMonFrontPic_Mewtwo[] = INCBIN_U32("graphics/pokemon/mewtwo/front.4bpp.lz");
+const u32 gMonPalette_Mewtwo[] = INCBIN_U32("graphics/pokemon/mewtwo/normal.gbapal.lz");
+const u32 gMonBackPic_Mewtwo[] = INCBIN_U32("graphics/pokemon/mewtwo/back.4bpp.lz");
+const u32 gMonShinyPalette_Mewtwo[] = INCBIN_U32("graphics/pokemon/mewtwo/shiny.gbapal.lz");
+const u8 gMonIcon_Mewtwo[] = INCBIN_U8("graphics/pokemon/mewtwo/icon.4bpp");
+const u8 gMonFootprint_Mewtwo[] = INCBIN_U8("graphics/pokemon/mewtwo/footprint.1bpp");
+
+const u32 gMonFrontPic_Mew[] = INCBIN_U32("graphics/pokemon/mew/front.4bpp.lz");
+const u32 gMonPalette_Mew[] = INCBIN_U32("graphics/pokemon/mew/normal.gbapal.lz");
+const u32 gMonBackPic_Mew[] = INCBIN_U32("graphics/pokemon/mew/back.4bpp.lz");
+const u32 gMonShinyPalette_Mew[] = INCBIN_U32("graphics/pokemon/mew/shiny.gbapal.lz");
+const u8 gMonIcon_Mew[] = INCBIN_U8("graphics/pokemon/mew/icon.4bpp");
+const u8 gMonFootprint_Mew[] = INCBIN_U8("graphics/pokemon/mew/footprint.1bpp");
+
+const u32 gMonFrontPic_Chikorita[] = INCBIN_U32("graphics/pokemon/chikorita/front.4bpp.lz");
+const u32 gMonPalette_Chikorita[] = INCBIN_U32("graphics/pokemon/chikorita/normal.gbapal.lz");
+const u32 gMonBackPic_Chikorita[] = INCBIN_U32("graphics/pokemon/chikorita/back.4bpp.lz");
+const u32 gMonShinyPalette_Chikorita[] = INCBIN_U32("graphics/pokemon/chikorita/shiny.gbapal.lz");
+const u8 gMonIcon_Chikorita[] = INCBIN_U8("graphics/pokemon/chikorita/icon.4bpp");
+const u8 gMonFootprint_Chikorita[] = INCBIN_U8("graphics/pokemon/chikorita/footprint.1bpp");
+
+const u32 gMonFrontPic_Bayleef[] = INCBIN_U32("graphics/pokemon/bayleef/front.4bpp.lz");
+const u32 gMonPalette_Bayleef[] = INCBIN_U32("graphics/pokemon/bayleef/normal.gbapal.lz");
+const u32 gMonBackPic_Bayleef[] = INCBIN_U32("graphics/pokemon/bayleef/back.4bpp.lz");
+const u32 gMonShinyPalette_Bayleef[] = INCBIN_U32("graphics/pokemon/bayleef/shiny.gbapal.lz");
+const u8 gMonIcon_Bayleef[] = INCBIN_U8("graphics/pokemon/bayleef/icon.4bpp");
+const u8 gMonFootprint_Bayleef[] = INCBIN_U8("graphics/pokemon/bayleef/footprint.1bpp");
+
+const u32 gMonFrontPic_Meganium[] = INCBIN_U32("graphics/pokemon/meganium/front.4bpp.lz");
+const u32 gMonPalette_Meganium[] = INCBIN_U32("graphics/pokemon/meganium/normal.gbapal.lz");
+const u32 gMonBackPic_Meganium[] = INCBIN_U32("graphics/pokemon/meganium/back.4bpp.lz");
+const u32 gMonShinyPalette_Meganium[] = INCBIN_U32("graphics/pokemon/meganium/shiny.gbapal.lz");
+const u8 gMonIcon_Meganium[] = INCBIN_U8("graphics/pokemon/meganium/icon.4bpp");
+const u8 gMonFootprint_Meganium[] = INCBIN_U8("graphics/pokemon/meganium/footprint.1bpp");
+
+const u32 gMonFrontPic_Cyndaquil[] = INCBIN_U32("graphics/pokemon/cyndaquil/front.4bpp.lz");
+const u32 gMonPalette_Cyndaquil[] = INCBIN_U32("graphics/pokemon/cyndaquil/normal.gbapal.lz");
+const u32 gMonBackPic_Cyndaquil[] = INCBIN_U32("graphics/pokemon/cyndaquil/back.4bpp.lz");
+const u32 gMonShinyPalette_Cyndaquil[] = INCBIN_U32("graphics/pokemon/cyndaquil/shiny.gbapal.lz");
+const u8 gMonIcon_Cyndaquil[] = INCBIN_U8("graphics/pokemon/cyndaquil/icon.4bpp");
+const u8 gMonFootprint_Cyndaquil[] = INCBIN_U8("graphics/pokemon/cyndaquil/footprint.1bpp");
+
+const u32 gMonFrontPic_Quilava[] = INCBIN_U32("graphics/pokemon/quilava/front.4bpp.lz");
+const u32 gMonPalette_Quilava[] = INCBIN_U32("graphics/pokemon/quilava/normal.gbapal.lz");
+const u32 gMonBackPic_Quilava[] = INCBIN_U32("graphics/pokemon/quilava/back.4bpp.lz");
+const u32 gMonShinyPalette_Quilava[] = INCBIN_U32("graphics/pokemon/quilava/shiny.gbapal.lz");
+const u8 gMonIcon_Quilava[] = INCBIN_U8("graphics/pokemon/quilava/icon.4bpp");
+const u8 gMonFootprint_Quilava[] = INCBIN_U8("graphics/pokemon/quilava/footprint.1bpp");
+
+const u32 gMonFrontPic_Typhlosion[] = INCBIN_U32("graphics/pokemon/typhlosion/front.4bpp.lz");
+const u32 gMonPalette_Typhlosion[] = INCBIN_U32("graphics/pokemon/typhlosion/normal.gbapal.lz");
+const u32 gMonBackPic_Typhlosion[] = INCBIN_U32("graphics/pokemon/typhlosion/back.4bpp.lz");
+const u32 gMonShinyPalette_Typhlosion[] = INCBIN_U32("graphics/pokemon/typhlosion/shiny.gbapal.lz");
+const u8 gMonIcon_Typhlosion[] = INCBIN_U8("graphics/pokemon/typhlosion/icon.4bpp");
+const u8 gMonFootprint_Typhlosion[] = INCBIN_U8("graphics/pokemon/typhlosion/footprint.1bpp");
+
+const u32 gMonFrontPic_Totodile[] = INCBIN_U32("graphics/pokemon/totodile/front.4bpp.lz");
+const u32 gMonPalette_Totodile[] = INCBIN_U32("graphics/pokemon/totodile/normal.gbapal.lz");
+const u32 gMonBackPic_Totodile[] = INCBIN_U32("graphics/pokemon/totodile/back.4bpp.lz");
+const u32 gMonShinyPalette_Totodile[] = INCBIN_U32("graphics/pokemon/totodile/shiny.gbapal.lz");
+const u8 gMonIcon_Totodile[] = INCBIN_U8("graphics/pokemon/totodile/icon.4bpp");
+const u8 gMonFootprint_Totodile[] = INCBIN_U8("graphics/pokemon/totodile/footprint.1bpp");
+
+const u32 gMonFrontPic_Croconaw[] = INCBIN_U32("graphics/pokemon/croconaw/front.4bpp.lz");
+const u32 gMonPalette_Croconaw[] = INCBIN_U32("graphics/pokemon/croconaw/normal.gbapal.lz");
+const u32 gMonBackPic_Croconaw[] = INCBIN_U32("graphics/pokemon/croconaw/back.4bpp.lz");
+const u32 gMonShinyPalette_Croconaw[] = INCBIN_U32("graphics/pokemon/croconaw/shiny.gbapal.lz");
+const u8 gMonIcon_Croconaw[] = INCBIN_U8("graphics/pokemon/croconaw/icon.4bpp");
+const u8 gMonFootprint_Croconaw[] = INCBIN_U8("graphics/pokemon/croconaw/footprint.1bpp");
+
+const u32 gMonFrontPic_Feraligatr[] = INCBIN_U32("graphics/pokemon/feraligatr/front.4bpp.lz");
+const u32 gMonPalette_Feraligatr[] = INCBIN_U32("graphics/pokemon/feraligatr/normal.gbapal.lz");
+const u32 gMonBackPic_Feraligatr[] = INCBIN_U32("graphics/pokemon/feraligatr/back.4bpp.lz");
+const u32 gMonShinyPalette_Feraligatr[] = INCBIN_U32("graphics/pokemon/feraligatr/shiny.gbapal.lz");
+const u8 gMonIcon_Feraligatr[] = INCBIN_U8("graphics/pokemon/feraligatr/icon.4bpp");
+const u8 gMonFootprint_Feraligatr[] = INCBIN_U8("graphics/pokemon/feraligatr/footprint.1bpp");
+
+const u32 gMonFrontPic_Sentret[] = INCBIN_U32("graphics/pokemon/sentret/front.4bpp.lz");
+const u32 gMonPalette_Sentret[] = INCBIN_U32("graphics/pokemon/sentret/normal.gbapal.lz");
+const u32 gMonBackPic_Sentret[] = INCBIN_U32("graphics/pokemon/sentret/back.4bpp.lz");
+const u32 gMonShinyPalette_Sentret[] = INCBIN_U32("graphics/pokemon/sentret/shiny.gbapal.lz");
+const u8 gMonIcon_Sentret[] = INCBIN_U8("graphics/pokemon/sentret/icon.4bpp");
+const u8 gMonFootprint_Sentret[] = INCBIN_U8("graphics/pokemon/sentret/footprint.1bpp");
+
+const u32 gMonFrontPic_Furret[] = INCBIN_U32("graphics/pokemon/furret/front.4bpp.lz");
+const u32 gMonPalette_Furret[] = INCBIN_U32("graphics/pokemon/furret/normal.gbapal.lz");
+const u32 gMonBackPic_Furret[] = INCBIN_U32("graphics/pokemon/furret/back.4bpp.lz");
+const u32 gMonShinyPalette_Furret[] = INCBIN_U32("graphics/pokemon/furret/shiny.gbapal.lz");
+const u8 gMonIcon_Furret[] = INCBIN_U8("graphics/pokemon/furret/icon.4bpp");
+const u8 gMonFootprint_Furret[] = INCBIN_U8("graphics/pokemon/furret/footprint.1bpp");
+
+const u32 gMonFrontPic_Hoothoot[] = INCBIN_U32("graphics/pokemon/hoothoot/front.4bpp.lz");
+const u32 gMonPalette_Hoothoot[] = INCBIN_U32("graphics/pokemon/hoothoot/normal.gbapal.lz");
+const u32 gMonBackPic_Hoothoot[] = INCBIN_U32("graphics/pokemon/hoothoot/back.4bpp.lz");
+const u32 gMonShinyPalette_Hoothoot[] = INCBIN_U32("graphics/pokemon/hoothoot/shiny.gbapal.lz");
+const u8 gMonIcon_Hoothoot[] = INCBIN_U8("graphics/pokemon/hoothoot/icon.4bpp");
+const u8 gMonFootprint_Hoothoot[] = INCBIN_U8("graphics/pokemon/hoothoot/footprint.1bpp");
+
+const u32 gMonFrontPic_Noctowl[] = INCBIN_U32("graphics/pokemon/noctowl/front.4bpp.lz");
+const u32 gMonPalette_Noctowl[] = INCBIN_U32("graphics/pokemon/noctowl/normal.gbapal.lz");
+const u32 gMonBackPic_Noctowl[] = INCBIN_U32("graphics/pokemon/noctowl/back.4bpp.lz");
+const u32 gMonShinyPalette_Noctowl[] = INCBIN_U32("graphics/pokemon/noctowl/shiny.gbapal.lz");
+const u8 gMonIcon_Noctowl[] = INCBIN_U8("graphics/pokemon/noctowl/icon.4bpp");
+const u8 gMonFootprint_Noctowl[] = INCBIN_U8("graphics/pokemon/noctowl/footprint.1bpp");
+
+const u32 gMonFrontPic_Ledyba[] = INCBIN_U32("graphics/pokemon/ledyba/front.4bpp.lz");
+const u32 gMonPalette_Ledyba[] = INCBIN_U32("graphics/pokemon/ledyba/normal.gbapal.lz");
+const u32 gMonBackPic_Ledyba[] = INCBIN_U32("graphics/pokemon/ledyba/back.4bpp.lz");
+const u32 gMonShinyPalette_Ledyba[] = INCBIN_U32("graphics/pokemon/ledyba/shiny.gbapal.lz");
+const u8 gMonIcon_Ledyba[] = INCBIN_U8("graphics/pokemon/ledyba/icon.4bpp");
+const u8 gMonFootprint_Ledyba[] = INCBIN_U8("graphics/pokemon/ledyba/footprint.1bpp");
+
+const u32 gMonFrontPic_Ledian[] = INCBIN_U32("graphics/pokemon/ledian/front.4bpp.lz");
+const u32 gMonPalette_Ledian[] = INCBIN_U32("graphics/pokemon/ledian/normal.gbapal.lz");
+const u32 gMonBackPic_Ledian[] = INCBIN_U32("graphics/pokemon/ledian/back.4bpp.lz");
+const u32 gMonShinyPalette_Ledian[] = INCBIN_U32("graphics/pokemon/ledian/shiny.gbapal.lz");
+const u8 gMonIcon_Ledian[] = INCBIN_U8("graphics/pokemon/ledian/icon.4bpp");
+const u8 gMonFootprint_Ledian[] = INCBIN_U8("graphics/pokemon/ledian/footprint.1bpp");
+
+const u32 gMonFrontPic_Spinarak[] = INCBIN_U32("graphics/pokemon/spinarak/front.4bpp.lz");
+const u32 gMonPalette_Spinarak[] = INCBIN_U32("graphics/pokemon/spinarak/normal.gbapal.lz");
+const u32 gMonBackPic_Spinarak[] = INCBIN_U32("graphics/pokemon/spinarak/back.4bpp.lz");
+const u32 gMonShinyPalette_Spinarak[] = INCBIN_U32("graphics/pokemon/spinarak/shiny.gbapal.lz");
+const u8 gMonIcon_Spinarak[] = INCBIN_U8("graphics/pokemon/spinarak/icon.4bpp");
+const u8 gMonFootprint_Spinarak[] = INCBIN_U8("graphics/pokemon/spinarak/footprint.1bpp");
+
+const u32 gMonFrontPic_Ariados[] = INCBIN_U32("graphics/pokemon/ariados/front.4bpp.lz");
+const u32 gMonPalette_Ariados[] = INCBIN_U32("graphics/pokemon/ariados/normal.gbapal.lz");
+const u32 gMonBackPic_Ariados[] = INCBIN_U32("graphics/pokemon/ariados/back.4bpp.lz");
+const u32 gMonShinyPalette_Ariados[] = INCBIN_U32("graphics/pokemon/ariados/shiny.gbapal.lz");
+const u8 gMonIcon_Ariados[] = INCBIN_U8("graphics/pokemon/ariados/icon.4bpp");
+const u8 gMonFootprint_Ariados[] = INCBIN_U8("graphics/pokemon/ariados/footprint.1bpp");
+
+const u32 gMonFrontPic_Crobat[] = INCBIN_U32("graphics/pokemon/crobat/front.4bpp.lz");
+const u32 gMonPalette_Crobat[] = INCBIN_U32("graphics/pokemon/crobat/normal.gbapal.lz");
+const u32 gMonBackPic_Crobat[] = INCBIN_U32("graphics/pokemon/crobat/back.4bpp.lz");
+const u32 gMonShinyPalette_Crobat[] = INCBIN_U32("graphics/pokemon/crobat/shiny.gbapal.lz");
+const u8 gMonIcon_Crobat[] = INCBIN_U8("graphics/pokemon/crobat/icon.4bpp");
+const u8 gMonFootprint_Crobat[] = INCBIN_U8("graphics/pokemon/crobat/footprint.1bpp");
+
+const u32 gMonFrontPic_Chinchou[] = INCBIN_U32("graphics/pokemon/chinchou/front.4bpp.lz");
+const u32 gMonPalette_Chinchou[] = INCBIN_U32("graphics/pokemon/chinchou/normal.gbapal.lz");
+const u32 gMonBackPic_Chinchou[] = INCBIN_U32("graphics/pokemon/chinchou/back.4bpp.lz");
+const u32 gMonShinyPalette_Chinchou[] = INCBIN_U32("graphics/pokemon/chinchou/shiny.gbapal.lz");
+const u8 gMonIcon_Chinchou[] = INCBIN_U8("graphics/pokemon/chinchou/icon.4bpp");
+const u8 gMonFootprint_Chinchou[] = INCBIN_U8("graphics/pokemon/chinchou/footprint.1bpp");
+
+const u32 gMonFrontPic_Lanturn[] = INCBIN_U32("graphics/pokemon/lanturn/front.4bpp.lz");
+const u32 gMonPalette_Lanturn[] = INCBIN_U32("graphics/pokemon/lanturn/normal.gbapal.lz");
+const u32 gMonBackPic_Lanturn[] = INCBIN_U32("graphics/pokemon/lanturn/back.4bpp.lz");
+const u32 gMonShinyPalette_Lanturn[] = INCBIN_U32("graphics/pokemon/lanturn/shiny.gbapal.lz");
+const u8 gMonIcon_Lanturn[] = INCBIN_U8("graphics/pokemon/lanturn/icon.4bpp");
+const u8 gMonFootprint_Lanturn[] = INCBIN_U8("graphics/pokemon/lanturn/footprint.1bpp");
+
+const u32 gMonFrontPic_Pichu[] = INCBIN_U32("graphics/pokemon/pichu/front.4bpp.lz");
+const u32 gMonPalette_Pichu[] = INCBIN_U32("graphics/pokemon/pichu/normal.gbapal.lz");
+const u32 gMonBackPic_Pichu[] = INCBIN_U32("graphics/pokemon/pichu/back.4bpp.lz");
+const u32 gMonShinyPalette_Pichu[] = INCBIN_U32("graphics/pokemon/pichu/shiny.gbapal.lz");
+const u8 gMonIcon_Pichu[] = INCBIN_U8("graphics/pokemon/pichu/icon.4bpp");
+const u8 gMonFootprint_Pichu[] = INCBIN_U8("graphics/pokemon/pichu/footprint.1bpp");
+
+const u32 gMonFrontPic_Cleffa[] = INCBIN_U32("graphics/pokemon/cleffa/front.4bpp.lz");
+const u32 gMonPalette_Cleffa[] = INCBIN_U32("graphics/pokemon/cleffa/normal.gbapal.lz");
+const u32 gMonBackPic_Cleffa[] = INCBIN_U32("graphics/pokemon/cleffa/back.4bpp.lz");
+const u32 gMonShinyPalette_Cleffa[] = INCBIN_U32("graphics/pokemon/cleffa/shiny.gbapal.lz");
+const u8 gMonIcon_Cleffa[] = INCBIN_U8("graphics/pokemon/cleffa/icon.4bpp");
+const u8 gMonFootprint_Cleffa[] = INCBIN_U8("graphics/pokemon/cleffa/footprint.1bpp");
+
+const u32 gMonFrontPic_Igglybuff[] = INCBIN_U32("graphics/pokemon/igglybuff/front.4bpp.lz");
+const u32 gMonPalette_Igglybuff[] = INCBIN_U32("graphics/pokemon/igglybuff/normal.gbapal.lz");
+const u32 gMonBackPic_Igglybuff[] = INCBIN_U32("graphics/pokemon/igglybuff/back.4bpp.lz");
+const u32 gMonShinyPalette_Igglybuff[] = INCBIN_U32("graphics/pokemon/igglybuff/shiny.gbapal.lz");
+const u8 gMonIcon_Igglybuff[] = INCBIN_U8("graphics/pokemon/igglybuff/icon.4bpp");
+const u8 gMonFootprint_Igglybuff[] = INCBIN_U8("graphics/pokemon/igglybuff/footprint.1bpp");
+
+const u32 gMonFrontPic_Togepi[] = INCBIN_U32("graphics/pokemon/togepi/front.4bpp.lz");
+const u32 gMonPalette_Togepi[] = INCBIN_U32("graphics/pokemon/togepi/normal.gbapal.lz");
+const u32 gMonBackPic_Togepi[] = INCBIN_U32("graphics/pokemon/togepi/back.4bpp.lz");
+const u32 gMonShinyPalette_Togepi[] = INCBIN_U32("graphics/pokemon/togepi/shiny.gbapal.lz");
+const u8 gMonIcon_Togepi[] = INCBIN_U8("graphics/pokemon/togepi/icon.4bpp");
+const u8 gMonFootprint_Togepi[] = INCBIN_U8("graphics/pokemon/togepi/footprint.1bpp");
+
+const u32 gMonFrontPic_Togetic[] = INCBIN_U32("graphics/pokemon/togetic/front.4bpp.lz");
+const u32 gMonPalette_Togetic[] = INCBIN_U32("graphics/pokemon/togetic/normal.gbapal.lz");
+const u32 gMonBackPic_Togetic[] = INCBIN_U32("graphics/pokemon/togetic/back.4bpp.lz");
+const u32 gMonShinyPalette_Togetic[] = INCBIN_U32("graphics/pokemon/togetic/shiny.gbapal.lz");
+const u8 gMonIcon_Togetic[] = INCBIN_U8("graphics/pokemon/togetic/icon.4bpp");
+const u8 gMonFootprint_Togetic[] = INCBIN_U8("graphics/pokemon/togetic/footprint.1bpp");
+
+const u32 gMonFrontPic_Natu[] = INCBIN_U32("graphics/pokemon/natu/front.4bpp.lz");
+const u32 gMonPalette_Natu[] = INCBIN_U32("graphics/pokemon/natu/normal.gbapal.lz");
+const u32 gMonBackPic_Natu[] = INCBIN_U32("graphics/pokemon/natu/back.4bpp.lz");
+const u32 gMonShinyPalette_Natu[] = INCBIN_U32("graphics/pokemon/natu/shiny.gbapal.lz");
+const u8 gMonIcon_Natu[] = INCBIN_U8("graphics/pokemon/natu/icon.4bpp");
+const u8 gMonFootprint_Natu[] = INCBIN_U8("graphics/pokemon/natu/footprint.1bpp");
+
+const u32 gMonFrontPic_Xatu[] = INCBIN_U32("graphics/pokemon/xatu/front.4bpp.lz");
+const u32 gMonPalette_Xatu[] = INCBIN_U32("graphics/pokemon/xatu/normal.gbapal.lz");
+const u32 gMonBackPic_Xatu[] = INCBIN_U32("graphics/pokemon/xatu/back.4bpp.lz");
+const u32 gMonShinyPalette_Xatu[] = INCBIN_U32("graphics/pokemon/xatu/shiny.gbapal.lz");
+const u8 gMonIcon_Xatu[] = INCBIN_U8("graphics/pokemon/xatu/icon.4bpp");
+const u8 gMonFootprint_Xatu[] = INCBIN_U8("graphics/pokemon/xatu/footprint.1bpp");
+
+const u32 gMonFrontPic_Mareep[] = INCBIN_U32("graphics/pokemon/mareep/front.4bpp.lz");
+const u32 gMonPalette_Mareep[] = INCBIN_U32("graphics/pokemon/mareep/normal.gbapal.lz");
+const u32 gMonBackPic_Mareep[] = INCBIN_U32("graphics/pokemon/mareep/back.4bpp.lz");
+const u32 gMonShinyPalette_Mareep[] = INCBIN_U32("graphics/pokemon/mareep/shiny.gbapal.lz");
+const u8 gMonIcon_Mareep[] = INCBIN_U8("graphics/pokemon/mareep/icon.4bpp");
+const u8 gMonFootprint_Mareep[] = INCBIN_U8("graphics/pokemon/mareep/footprint.1bpp");
+
+const u32 gMonFrontPic_Flaaffy[] = INCBIN_U32("graphics/pokemon/flaaffy/front.4bpp.lz");
+const u32 gMonPalette_Flaaffy[] = INCBIN_U32("graphics/pokemon/flaaffy/normal.gbapal.lz");
+const u32 gMonBackPic_Flaaffy[] = INCBIN_U32("graphics/pokemon/flaaffy/back.4bpp.lz");
+const u32 gMonShinyPalette_Flaaffy[] = INCBIN_U32("graphics/pokemon/flaaffy/shiny.gbapal.lz");
+const u8 gMonIcon_Flaaffy[] = INCBIN_U8("graphics/pokemon/flaaffy/icon.4bpp");
+const u8 gMonFootprint_Flaaffy[] = INCBIN_U8("graphics/pokemon/flaaffy/footprint.1bpp");
+
+const u32 gMonFrontPic_Ampharos[] = INCBIN_U32("graphics/pokemon/ampharos/front.4bpp.lz");
+const u32 gMonPalette_Ampharos[] = INCBIN_U32("graphics/pokemon/ampharos/normal.gbapal.lz");
+const u32 gMonBackPic_Ampharos[] = INCBIN_U32("graphics/pokemon/ampharos/back.4bpp.lz");
+const u32 gMonShinyPalette_Ampharos[] = INCBIN_U32("graphics/pokemon/ampharos/shiny.gbapal.lz");
+const u8 gMonIcon_Ampharos[] = INCBIN_U8("graphics/pokemon/ampharos/icon.4bpp");
+const u8 gMonFootprint_Ampharos[] = INCBIN_U8("graphics/pokemon/ampharos/footprint.1bpp");
+
+const u32 gMonFrontPic_Bellossom[] = INCBIN_U32("graphics/pokemon/bellossom/front.4bpp.lz");
+const u32 gMonPalette_Bellossom[] = INCBIN_U32("graphics/pokemon/bellossom/normal.gbapal.lz");
+const u32 gMonBackPic_Bellossom[] = INCBIN_U32("graphics/pokemon/bellossom/back.4bpp.lz");
+const u32 gMonShinyPalette_Bellossom[] = INCBIN_U32("graphics/pokemon/bellossom/shiny.gbapal.lz");
+const u8 gMonIcon_Bellossom[] = INCBIN_U8("graphics/pokemon/bellossom/icon.4bpp");
+const u8 gMonFootprint_Bellossom[] = INCBIN_U8("graphics/pokemon/bellossom/footprint.1bpp");
+
+const u32 gMonFrontPic_Marill[] = INCBIN_U32("graphics/pokemon/marill/front.4bpp.lz");
+const u32 gMonPalette_Marill[] = INCBIN_U32("graphics/pokemon/marill/normal.gbapal.lz");
+const u32 gMonBackPic_Marill[] = INCBIN_U32("graphics/pokemon/marill/back.4bpp.lz");
+const u32 gMonShinyPalette_Marill[] = INCBIN_U32("graphics/pokemon/marill/shiny.gbapal.lz");
+const u8 gMonIcon_Marill[] = INCBIN_U8("graphics/pokemon/marill/icon.4bpp");
+const u8 gMonFootprint_Marill[] = INCBIN_U8("graphics/pokemon/marill/footprint.1bpp");
+
+const u32 gMonFrontPic_Azumarill[] = INCBIN_U32("graphics/pokemon/azumarill/front.4bpp.lz");
+const u32 gMonPalette_Azumarill[] = INCBIN_U32("graphics/pokemon/azumarill/normal.gbapal.lz");
+const u32 gMonBackPic_Azumarill[] = INCBIN_U32("graphics/pokemon/azumarill/back.4bpp.lz");
+const u32 gMonShinyPalette_Azumarill[] = INCBIN_U32("graphics/pokemon/azumarill/shiny.gbapal.lz");
+const u8 gMonIcon_Azumarill[] = INCBIN_U8("graphics/pokemon/azumarill/icon.4bpp");
+const u8 gMonFootprint_Azumarill[] = INCBIN_U8("graphics/pokemon/azumarill/footprint.1bpp");
+
+const u32 gMonFrontPic_Sudowoodo[] = INCBIN_U32("graphics/pokemon/sudowoodo/front.4bpp.lz");
+const u32 gMonPalette_Sudowoodo[] = INCBIN_U32("graphics/pokemon/sudowoodo/normal.gbapal.lz");
+const u32 gMonBackPic_Sudowoodo[] = INCBIN_U32("graphics/pokemon/sudowoodo/back.4bpp.lz");
+const u32 gMonShinyPalette_Sudowoodo[] = INCBIN_U32("graphics/pokemon/sudowoodo/shiny.gbapal.lz");
+const u8 gMonIcon_Sudowoodo[] = INCBIN_U8("graphics/pokemon/sudowoodo/icon.4bpp");
+const u8 gMonFootprint_Sudowoodo[] = INCBIN_U8("graphics/pokemon/sudowoodo/footprint.1bpp");
+
+const u32 gMonFrontPic_Politoed[] = INCBIN_U32("graphics/pokemon/politoed/front.4bpp.lz");
+const u32 gMonPalette_Politoed[] = INCBIN_U32("graphics/pokemon/politoed/normal.gbapal.lz");
+const u32 gMonBackPic_Politoed[] = INCBIN_U32("graphics/pokemon/politoed/back.4bpp.lz");
+const u32 gMonShinyPalette_Politoed[] = INCBIN_U32("graphics/pokemon/politoed/shiny.gbapal.lz");
+const u8 gMonIcon_Politoed[] = INCBIN_U8("graphics/pokemon/politoed/icon.4bpp");
+const u8 gMonFootprint_Politoed[] = INCBIN_U8("graphics/pokemon/politoed/footprint.1bpp");
+
+const u32 gMonFrontPic_Hoppip[] = INCBIN_U32("graphics/pokemon/hoppip/front.4bpp.lz");
+const u32 gMonPalette_Hoppip[] = INCBIN_U32("graphics/pokemon/hoppip/normal.gbapal.lz");
+const u32 gMonBackPic_Hoppip[] = INCBIN_U32("graphics/pokemon/hoppip/back.4bpp.lz");
+const u32 gMonShinyPalette_Hoppip[] = INCBIN_U32("graphics/pokemon/hoppip/shiny.gbapal.lz");
+const u8 gMonIcon_Hoppip[] = INCBIN_U8("graphics/pokemon/hoppip/icon.4bpp");
+const u8 gMonFootprint_Hoppip[] = INCBIN_U8("graphics/pokemon/hoppip/footprint.1bpp");
+
+const u32 gMonFrontPic_Skiploom[] = INCBIN_U32("graphics/pokemon/skiploom/front.4bpp.lz");
+const u32 gMonPalette_Skiploom[] = INCBIN_U32("graphics/pokemon/skiploom/normal.gbapal.lz");
+const u32 gMonBackPic_Skiploom[] = INCBIN_U32("graphics/pokemon/skiploom/back.4bpp.lz");
+const u32 gMonShinyPalette_Skiploom[] = INCBIN_U32("graphics/pokemon/skiploom/shiny.gbapal.lz");
+const u8 gMonIcon_Skiploom[] = INCBIN_U8("graphics/pokemon/skiploom/icon.4bpp");
+const u8 gMonFootprint_Skiploom[] = INCBIN_U8("graphics/pokemon/skiploom/footprint.1bpp");
+
+const u32 gMonFrontPic_Jumpluff[] = INCBIN_U32("graphics/pokemon/jumpluff/front.4bpp.lz");
+const u32 gMonPalette_Jumpluff[] = INCBIN_U32("graphics/pokemon/jumpluff/normal.gbapal.lz");
+const u32 gMonBackPic_Jumpluff[] = INCBIN_U32("graphics/pokemon/jumpluff/back.4bpp.lz");
+const u32 gMonShinyPalette_Jumpluff[] = INCBIN_U32("graphics/pokemon/jumpluff/shiny.gbapal.lz");
+const u8 gMonIcon_Jumpluff[] = INCBIN_U8("graphics/pokemon/jumpluff/icon.4bpp");
+const u8 gMonFootprint_Jumpluff[] = INCBIN_U8("graphics/pokemon/jumpluff/footprint.1bpp");
+
+const u32 gMonFrontPic_Aipom[] = INCBIN_U32("graphics/pokemon/aipom/front.4bpp.lz");
+const u32 gMonPalette_Aipom[] = INCBIN_U32("graphics/pokemon/aipom/normal.gbapal.lz");
+const u32 gMonBackPic_Aipom[] = INCBIN_U32("graphics/pokemon/aipom/back.4bpp.lz");
+const u32 gMonShinyPalette_Aipom[] = INCBIN_U32("graphics/pokemon/aipom/shiny.gbapal.lz");
+const u8 gMonIcon_Aipom[] = INCBIN_U8("graphics/pokemon/aipom/icon.4bpp");
+const u8 gMonFootprint_Aipom[] = INCBIN_U8("graphics/pokemon/aipom/footprint.1bpp");
+
+const u32 gMonFrontPic_Sunkern[] = INCBIN_U32("graphics/pokemon/sunkern/front.4bpp.lz");
+const u32 gMonPalette_Sunkern[] = INCBIN_U32("graphics/pokemon/sunkern/normal.gbapal.lz");
+const u32 gMonBackPic_Sunkern[] = INCBIN_U32("graphics/pokemon/sunkern/back.4bpp.lz");
+const u32 gMonShinyPalette_Sunkern[] = INCBIN_U32("graphics/pokemon/sunkern/shiny.gbapal.lz");
+const u8 gMonIcon_Sunkern[] = INCBIN_U8("graphics/pokemon/sunkern/icon.4bpp");
+const u8 gMonFootprint_Sunkern[] = INCBIN_U8("graphics/pokemon/sunkern/footprint.1bpp");
+
+const u32 gMonFrontPic_Sunflora[] = INCBIN_U32("graphics/pokemon/sunflora/front.4bpp.lz");
+const u32 gMonPalette_Sunflora[] = INCBIN_U32("graphics/pokemon/sunflora/normal.gbapal.lz");
+const u32 gMonBackPic_Sunflora[] = INCBIN_U32("graphics/pokemon/sunflora/back.4bpp.lz");
+const u32 gMonShinyPalette_Sunflora[] = INCBIN_U32("graphics/pokemon/sunflora/shiny.gbapal.lz");
+const u8 gMonIcon_Sunflora[] = INCBIN_U8("graphics/pokemon/sunflora/icon.4bpp");
+const u8 gMonFootprint_Sunflora[] = INCBIN_U8("graphics/pokemon/sunflora/footprint.1bpp");
+
+const u32 gMonFrontPic_Yanma[] = INCBIN_U32("graphics/pokemon/yanma/front.4bpp.lz");
+const u32 gMonPalette_Yanma[] = INCBIN_U32("graphics/pokemon/yanma/normal.gbapal.lz");
+const u32 gMonBackPic_Yanma[] = INCBIN_U32("graphics/pokemon/yanma/back.4bpp.lz");
+const u32 gMonShinyPalette_Yanma[] = INCBIN_U32("graphics/pokemon/yanma/shiny.gbapal.lz");
+const u8 gMonIcon_Yanma[] = INCBIN_U8("graphics/pokemon/yanma/icon.4bpp");
+const u8 gMonFootprint_Yanma[] = INCBIN_U8("graphics/pokemon/yanma/footprint.1bpp");
+
+const u32 gMonFrontPic_Wooper[] = INCBIN_U32("graphics/pokemon/wooper/front.4bpp.lz");
+const u32 gMonPalette_Wooper[] = INCBIN_U32("graphics/pokemon/wooper/normal.gbapal.lz");
+const u32 gMonBackPic_Wooper[] = INCBIN_U32("graphics/pokemon/wooper/back.4bpp.lz");
+const u32 gMonShinyPalette_Wooper[] = INCBIN_U32("graphics/pokemon/wooper/shiny.gbapal.lz");
+const u8 gMonIcon_Wooper[] = INCBIN_U8("graphics/pokemon/wooper/icon.4bpp");
+const u8 gMonFootprint_Wooper[] = INCBIN_U8("graphics/pokemon/wooper/footprint.1bpp");
+
+const u32 gMonFrontPic_Quagsire[] = INCBIN_U32("graphics/pokemon/quagsire/front.4bpp.lz");
+const u32 gMonPalette_Quagsire[] = INCBIN_U32("graphics/pokemon/quagsire/normal.gbapal.lz");
+const u32 gMonBackPic_Quagsire[] = INCBIN_U32("graphics/pokemon/quagsire/back.4bpp.lz");
+const u32 gMonShinyPalette_Quagsire[] = INCBIN_U32("graphics/pokemon/quagsire/shiny.gbapal.lz");
+const u8 gMonIcon_Quagsire[] = INCBIN_U8("graphics/pokemon/quagsire/icon.4bpp");
+const u8 gMonFootprint_Quagsire[] = INCBIN_U8("graphics/pokemon/quagsire/footprint.1bpp");
+
+const u32 gMonFrontPic_Espeon[] = INCBIN_U32("graphics/pokemon/espeon/front.4bpp.lz");
+const u32 gMonPalette_Espeon[] = INCBIN_U32("graphics/pokemon/espeon/normal.gbapal.lz");
+const u32 gMonBackPic_Espeon[] = INCBIN_U32("graphics/pokemon/espeon/back.4bpp.lz");
+const u32 gMonShinyPalette_Espeon[] = INCBIN_U32("graphics/pokemon/espeon/shiny.gbapal.lz");
+const u8 gMonIcon_Espeon[] = INCBIN_U8("graphics/pokemon/espeon/icon.4bpp");
+const u8 gMonFootprint_Espeon[] = INCBIN_U8("graphics/pokemon/espeon/footprint.1bpp");
+
+const u32 gMonFrontPic_Umbreon[] = INCBIN_U32("graphics/pokemon/umbreon/front.4bpp.lz");
+const u32 gMonPalette_Umbreon[] = INCBIN_U32("graphics/pokemon/umbreon/normal.gbapal.lz");
+const u32 gMonBackPic_Umbreon[] = INCBIN_U32("graphics/pokemon/umbreon/back.4bpp.lz");
+const u32 gMonShinyPalette_Umbreon[] = INCBIN_U32("graphics/pokemon/umbreon/shiny.gbapal.lz");
+const u8 gMonIcon_Umbreon[] = INCBIN_U8("graphics/pokemon/umbreon/icon.4bpp");
+const u8 gMonFootprint_Umbreon[] = INCBIN_U8("graphics/pokemon/umbreon/footprint.1bpp");
+
+const u32 gMonFrontPic_Murkrow[] = INCBIN_U32("graphics/pokemon/murkrow/front.4bpp.lz");
+const u32 gMonPalette_Murkrow[] = INCBIN_U32("graphics/pokemon/murkrow/normal.gbapal.lz");
+const u32 gMonBackPic_Murkrow[] = INCBIN_U32("graphics/pokemon/murkrow/back.4bpp.lz");
+const u32 gMonShinyPalette_Murkrow[] = INCBIN_U32("graphics/pokemon/murkrow/shiny.gbapal.lz");
+const u8 gMonIcon_Murkrow[] = INCBIN_U8("graphics/pokemon/murkrow/icon.4bpp");
+const u8 gMonFootprint_Murkrow[] = INCBIN_U8("graphics/pokemon/murkrow/footprint.1bpp");
+
+const u32 gMonFrontPic_Slowking[] = INCBIN_U32("graphics/pokemon/slowking/front.4bpp.lz");
+const u32 gMonPalette_Slowking[] = INCBIN_U32("graphics/pokemon/slowking/normal.gbapal.lz");
+const u32 gMonBackPic_Slowking[] = INCBIN_U32("graphics/pokemon/slowking/back.4bpp.lz");
+const u32 gMonShinyPalette_Slowking[] = INCBIN_U32("graphics/pokemon/slowking/shiny.gbapal.lz");
+const u8 gMonIcon_Slowking[] = INCBIN_U8("graphics/pokemon/slowking/icon.4bpp");
+const u8 gMonFootprint_Slowking[] = INCBIN_U8("graphics/pokemon/slowking/footprint.1bpp");
+
+const u32 gMonFrontPic_Misdreavus[] = INCBIN_U32("graphics/pokemon/misdreavus/front.4bpp.lz");
+const u32 gMonPalette_Misdreavus[] = INCBIN_U32("graphics/pokemon/misdreavus/normal.gbapal.lz");
+const u32 gMonBackPic_Misdreavus[] = INCBIN_U32("graphics/pokemon/misdreavus/back.4bpp.lz");
+const u32 gMonShinyPalette_Misdreavus[] = INCBIN_U32("graphics/pokemon/misdreavus/shiny.gbapal.lz");
+const u8 gMonIcon_Misdreavus[] = INCBIN_U8("graphics/pokemon/misdreavus/icon.4bpp");
+const u8 gMonFootprint_Misdreavus[] = INCBIN_U8("graphics/pokemon/misdreavus/footprint.1bpp");
+
+const u32 gMonFrontPic_UnownA[] = INCBIN_U32("graphics/pokemon/unown/a/front.4bpp.lz");
+const u32 gMonPalette_Unown[] = INCBIN_U32("graphics/pokemon/unown/normal.gbapal.lz");
+const u32 gMonBackPic_UnownA[] = INCBIN_U32("graphics/pokemon/unown/a/back.4bpp.lz");
+const u32 gMonShinyPalette_Unown[] = INCBIN_U32("graphics/pokemon/unown/shiny.gbapal.lz");
+const u8 gMonIcon_UnownA[] = INCBIN_U8("graphics/pokemon/unown/a/icon.4bpp");
+const u8 gMonFootprint_Unown[] = INCBIN_U8("graphics/pokemon/unown/footprint.1bpp");
+
+const u32 gMonFrontPic_Wobbuffet[] = INCBIN_U32("graphics/pokemon/wobbuffet/front.4bpp.lz");
+const u32 gMonPalette_Wobbuffet[] = INCBIN_U32("graphics/pokemon/wobbuffet/normal.gbapal.lz");
+const u32 gMonBackPic_Wobbuffet[] = INCBIN_U32("graphics/pokemon/wobbuffet/back.4bpp.lz");
+const u32 gMonShinyPalette_Wobbuffet[] = INCBIN_U32("graphics/pokemon/wobbuffet/shiny.gbapal.lz");
+const u8 gMonIcon_Wobbuffet[] = INCBIN_U8("graphics/pokemon/wobbuffet/icon.4bpp");
+const u8 gMonFootprint_Wobbuffet[] = INCBIN_U8("graphics/pokemon/wobbuffet/footprint.1bpp");
+
+const u32 gMonFrontPic_Girafarig[] = INCBIN_U32("graphics/pokemon/girafarig/front.4bpp.lz");
+const u32 gMonPalette_Girafarig[] = INCBIN_U32("graphics/pokemon/girafarig/normal.gbapal.lz");
+const u32 gMonBackPic_Girafarig[] = INCBIN_U32("graphics/pokemon/girafarig/back.4bpp.lz");
+const u32 gMonShinyPalette_Girafarig[] = INCBIN_U32("graphics/pokemon/girafarig/shiny.gbapal.lz");
+const u8 gMonIcon_Girafarig[] = INCBIN_U8("graphics/pokemon/girafarig/icon.4bpp");
+const u8 gMonFootprint_Girafarig[] = INCBIN_U8("graphics/pokemon/girafarig/footprint.1bpp");
+
+const u32 gMonFrontPic_Pineco[] = INCBIN_U32("graphics/pokemon/pineco/front.4bpp.lz");
+const u32 gMonPalette_Pineco[] = INCBIN_U32("graphics/pokemon/pineco/normal.gbapal.lz");
+const u32 gMonBackPic_Pineco[] = INCBIN_U32("graphics/pokemon/pineco/back.4bpp.lz");
+const u32 gMonShinyPalette_Pineco[] = INCBIN_U32("graphics/pokemon/pineco/shiny.gbapal.lz");
+const u8 gMonIcon_Pineco[] = INCBIN_U8("graphics/pokemon/pineco/icon.4bpp");
+const u8 gMonFootprint_Pineco[] = INCBIN_U8("graphics/pokemon/pineco/footprint.1bpp");
+
+const u32 gMonFrontPic_Forretress[] = INCBIN_U32("graphics/pokemon/forretress/front.4bpp.lz");
+const u32 gMonPalette_Forretress[] = INCBIN_U32("graphics/pokemon/forretress/normal.gbapal.lz");
+const u32 gMonBackPic_Forretress[] = INCBIN_U32("graphics/pokemon/forretress/back.4bpp.lz");
+const u32 gMonShinyPalette_Forretress[] = INCBIN_U32("graphics/pokemon/forretress/shiny.gbapal.lz");
+const u8 gMonIcon_Forretress[] = INCBIN_U8("graphics/pokemon/forretress/icon.4bpp");
+const u8 gMonFootprint_Forretress[] = INCBIN_U8("graphics/pokemon/forretress/footprint.1bpp");
+
+const u32 gMonFrontPic_Dunsparce[] = INCBIN_U32("graphics/pokemon/dunsparce/front.4bpp.lz");
+const u32 gMonPalette_Dunsparce[] = INCBIN_U32("graphics/pokemon/dunsparce/normal.gbapal.lz");
+const u32 gMonBackPic_Dunsparce[] = INCBIN_U32("graphics/pokemon/dunsparce/back.4bpp.lz");
+const u32 gMonShinyPalette_Dunsparce[] = INCBIN_U32("graphics/pokemon/dunsparce/shiny.gbapal.lz");
+const u8 gMonIcon_Dunsparce[] = INCBIN_U8("graphics/pokemon/dunsparce/icon.4bpp");
+const u8 gMonFootprint_Dunsparce[] = INCBIN_U8("graphics/pokemon/dunsparce/footprint.1bpp");
+
+const u32 gMonFrontPic_Gligar[] = INCBIN_U32("graphics/pokemon/gligar/front.4bpp.lz");
+const u32 gMonPalette_Gligar[] = INCBIN_U32("graphics/pokemon/gligar/normal.gbapal.lz");
+const u32 gMonBackPic_Gligar[] = INCBIN_U32("graphics/pokemon/gligar/back.4bpp.lz");
+const u32 gMonShinyPalette_Gligar[] = INCBIN_U32("graphics/pokemon/gligar/shiny.gbapal.lz");
+const u8 gMonIcon_Gligar[] = INCBIN_U8("graphics/pokemon/gligar/icon.4bpp");
+const u8 gMonFootprint_Gligar[] = INCBIN_U8("graphics/pokemon/gligar/footprint.1bpp");
+
+const u32 gMonFrontPic_Steelix[] = INCBIN_U32("graphics/pokemon/steelix/front.4bpp.lz");
+const u32 gMonPalette_Steelix[] = INCBIN_U32("graphics/pokemon/steelix/normal.gbapal.lz");
+const u32 gMonBackPic_Steelix[] = INCBIN_U32("graphics/pokemon/steelix/back.4bpp.lz");
+const u32 gMonShinyPalette_Steelix[] = INCBIN_U32("graphics/pokemon/steelix/shiny.gbapal.lz");
+const u8 gMonIcon_Steelix[] = INCBIN_U8("graphics/pokemon/steelix/icon.4bpp");
+const u8 gMonFootprint_Steelix[] = INCBIN_U8("graphics/pokemon/steelix/footprint.1bpp");
+
+const u32 gMonFrontPic_Snubbull[] = INCBIN_U32("graphics/pokemon/snubbull/front.4bpp.lz");
+const u32 gMonPalette_Snubbull[] = INCBIN_U32("graphics/pokemon/snubbull/normal.gbapal.lz");
+const u32 gMonBackPic_Snubbull[] = INCBIN_U32("graphics/pokemon/snubbull/back.4bpp.lz");
+const u32 gMonShinyPalette_Snubbull[] = INCBIN_U32("graphics/pokemon/snubbull/shiny.gbapal.lz");
+const u8 gMonIcon_Snubbull[] = INCBIN_U8("graphics/pokemon/snubbull/icon.4bpp");
+const u8 gMonFootprint_Snubbull[] = INCBIN_U8("graphics/pokemon/snubbull/footprint.1bpp");
+
+const u32 gMonFrontPic_Granbull[] = INCBIN_U32("graphics/pokemon/granbull/front.4bpp.lz");
+const u32 gMonPalette_Granbull[] = INCBIN_U32("graphics/pokemon/granbull/normal.gbapal.lz");
+const u32 gMonBackPic_Granbull[] = INCBIN_U32("graphics/pokemon/granbull/back.4bpp.lz");
+const u32 gMonShinyPalette_Granbull[] = INCBIN_U32("graphics/pokemon/granbull/shiny.gbapal.lz");
+const u8 gMonIcon_Granbull[] = INCBIN_U8("graphics/pokemon/granbull/icon.4bpp");
+const u8 gMonFootprint_Granbull[] = INCBIN_U8("graphics/pokemon/granbull/footprint.1bpp");
+
+const u32 gMonFrontPic_Qwilfish[] = INCBIN_U32("graphics/pokemon/qwilfish/front.4bpp.lz");
+const u32 gMonPalette_Qwilfish[] = INCBIN_U32("graphics/pokemon/qwilfish/normal.gbapal.lz");
+const u32 gMonBackPic_Qwilfish[] = INCBIN_U32("graphics/pokemon/qwilfish/back.4bpp.lz");
+const u32 gMonShinyPalette_Qwilfish[] = INCBIN_U32("graphics/pokemon/qwilfish/shiny.gbapal.lz");
+const u8 gMonIcon_Qwilfish[] = INCBIN_U8("graphics/pokemon/qwilfish/icon.4bpp");
+const u8 gMonFootprint_Qwilfish[] = INCBIN_U8("graphics/pokemon/qwilfish/footprint.1bpp");
+
+const u32 gMonFrontPic_Scizor[] = INCBIN_U32("graphics/pokemon/scizor/front.4bpp.lz");
+const u32 gMonPalette_Scizor[] = INCBIN_U32("graphics/pokemon/scizor/normal.gbapal.lz");
+const u32 gMonBackPic_Scizor[] = INCBIN_U32("graphics/pokemon/scizor/back.4bpp.lz");
+const u32 gMonShinyPalette_Scizor[] = INCBIN_U32("graphics/pokemon/scizor/shiny.gbapal.lz");
+const u8 gMonIcon_Scizor[] = INCBIN_U8("graphics/pokemon/scizor/icon.4bpp");
+const u8 gMonFootprint_Scizor[] = INCBIN_U8("graphics/pokemon/scizor/footprint.1bpp");
+
+const u32 gMonFrontPic_Shuckle[] = INCBIN_U32("graphics/pokemon/shuckle/front.4bpp.lz");
+const u32 gMonPalette_Shuckle[] = INCBIN_U32("graphics/pokemon/shuckle/normal.gbapal.lz");
+const u32 gMonBackPic_Shuckle[] = INCBIN_U32("graphics/pokemon/shuckle/back.4bpp.lz");
+const u32 gMonShinyPalette_Shuckle[] = INCBIN_U32("graphics/pokemon/shuckle/shiny.gbapal.lz");
+const u8 gMonIcon_Shuckle[] = INCBIN_U8("graphics/pokemon/shuckle/icon.4bpp");
+const u8 gMonFootprint_Shuckle[] = INCBIN_U8("graphics/pokemon/shuckle/footprint.1bpp");
+
+const u32 gMonFrontPic_Heracross[] = INCBIN_U32("graphics/pokemon/heracross/front.4bpp.lz");
+const u32 gMonPalette_Heracross[] = INCBIN_U32("graphics/pokemon/heracross/normal.gbapal.lz");
+const u32 gMonBackPic_Heracross[] = INCBIN_U32("graphics/pokemon/heracross/back.4bpp.lz");
+const u32 gMonShinyPalette_Heracross[] = INCBIN_U32("graphics/pokemon/heracross/shiny.gbapal.lz");
+const u8 gMonIcon_Heracross[] = INCBIN_U8("graphics/pokemon/heracross/icon.4bpp");
+const u8 gUnknown_heracross_icon[] = INCBIN_U8("graphics/pokemon/heracross/unk_icon.4bpp");
+const u8 gMonFootprint_Heracross[] = INCBIN_U8("graphics/pokemon/heracross/footprint.1bpp");
+
+const u32 gMonFrontPic_Sneasel[] = INCBIN_U32("graphics/pokemon/sneasel/front.4bpp.lz");
+const u32 gMonPalette_Sneasel[] = INCBIN_U32("graphics/pokemon/sneasel/normal.gbapal.lz");
+const u32 gMonBackPic_Sneasel[] = INCBIN_U32("graphics/pokemon/sneasel/back.4bpp.lz");
+const u32 gMonShinyPalette_Sneasel[] = INCBIN_U32("graphics/pokemon/sneasel/shiny.gbapal.lz");
+const u8 gMonIcon_Sneasel[] = INCBIN_U8("graphics/pokemon/sneasel/icon.4bpp");
+const u8 gMonFootprint_Sneasel[] = INCBIN_U8("graphics/pokemon/sneasel/footprint.1bpp");
+
+const u32 gMonFrontPic_Teddiursa[] = INCBIN_U32("graphics/pokemon/teddiursa/front.4bpp.lz");
+const u32 gMonPalette_Teddiursa[] = INCBIN_U32("graphics/pokemon/teddiursa/normal.gbapal.lz");
+const u32 gMonBackPic_Teddiursa[] = INCBIN_U32("graphics/pokemon/teddiursa/back.4bpp.lz");
+const u32 gMonShinyPalette_Teddiursa[] = INCBIN_U32("graphics/pokemon/teddiursa/shiny.gbapal.lz");
+const u8 gMonIcon_Teddiursa[] = INCBIN_U8("graphics/pokemon/teddiursa/icon.4bpp");
+const u8 gMonFootprint_Teddiursa[] = INCBIN_U8("graphics/pokemon/teddiursa/footprint.1bpp");
+
+const u32 gMonFrontPic_Ursaring[] = INCBIN_U32("graphics/pokemon/ursaring/front.4bpp.lz");
+const u32 gMonPalette_Ursaring[] = INCBIN_U32("graphics/pokemon/ursaring/normal.gbapal.lz");
+const u32 gMonBackPic_Ursaring[] = INCBIN_U32("graphics/pokemon/ursaring/back.4bpp.lz");
+const u32 gMonShinyPalette_Ursaring[] = INCBIN_U32("graphics/pokemon/ursaring/shiny.gbapal.lz");
+const u8 gMonIcon_Ursaring[] = INCBIN_U8("graphics/pokemon/ursaring/icon.4bpp");
+const u8 gMonFootprint_Ursaring[] = INCBIN_U8("graphics/pokemon/ursaring/footprint.1bpp");
+
+const u32 gMonFrontPic_Slugma[] = INCBIN_U32("graphics/pokemon/slugma/front.4bpp.lz");
+const u32 gMonPalette_Slugma[] = INCBIN_U32("graphics/pokemon/slugma/normal.gbapal.lz");
+const u32 gMonBackPic_Slugma[] = INCBIN_U32("graphics/pokemon/slugma/back.4bpp.lz");
+const u32 gMonShinyPalette_Slugma[] = INCBIN_U32("graphics/pokemon/slugma/shiny.gbapal.lz");
+const u8 gMonIcon_Slugma[] = INCBIN_U8("graphics/pokemon/slugma/icon.4bpp");
+const u8 gMonFootprint_Slugma[] = INCBIN_U8("graphics/pokemon/slugma/footprint.1bpp");
+
+const u32 gMonFrontPic_Magcargo[] = INCBIN_U32("graphics/pokemon/magcargo/front.4bpp.lz");
+const u32 gMonPalette_Magcargo[] = INCBIN_U32("graphics/pokemon/magcargo/normal.gbapal.lz");
+const u32 gMonBackPic_Magcargo[] = INCBIN_U32("graphics/pokemon/magcargo/back.4bpp.lz");
+const u32 gMonShinyPalette_Magcargo[] = INCBIN_U32("graphics/pokemon/magcargo/shiny.gbapal.lz");
+const u8 gMonIcon_Magcargo[] = INCBIN_U8("graphics/pokemon/magcargo/icon.4bpp");
+const u8 gMonFootprint_Magcargo[] = INCBIN_U8("graphics/pokemon/magcargo/footprint.1bpp");
+
+const u32 gMonFrontPic_Swinub[] = INCBIN_U32("graphics/pokemon/swinub/front.4bpp.lz");
+const u32 gMonPalette_Swinub[] = INCBIN_U32("graphics/pokemon/swinub/normal.gbapal.lz");
+const u32 gMonBackPic_Swinub[] = INCBIN_U32("graphics/pokemon/swinub/back.4bpp.lz");
+const u32 gMonShinyPalette_Swinub[] = INCBIN_U32("graphics/pokemon/swinub/shiny.gbapal.lz");
+const u8 gMonIcon_Swinub[] = INCBIN_U8("graphics/pokemon/swinub/icon.4bpp");
+const u8 gMonFootprint_Swinub[] = INCBIN_U8("graphics/pokemon/swinub/footprint.1bpp");
+
+const u32 gMonFrontPic_Piloswine[] = INCBIN_U32("graphics/pokemon/piloswine/front.4bpp.lz");
+const u32 gMonPalette_Piloswine[] = INCBIN_U32("graphics/pokemon/piloswine/normal.gbapal.lz");
+const u32 gMonBackPic_Piloswine[] = INCBIN_U32("graphics/pokemon/piloswine/back.4bpp.lz");
+const u32 gMonShinyPalette_Piloswine[] = INCBIN_U32("graphics/pokemon/piloswine/shiny.gbapal.lz");
+const u8 gMonIcon_Piloswine[] = INCBIN_U8("graphics/pokemon/piloswine/icon.4bpp");
+const u8 gMonFootprint_Piloswine[] = INCBIN_U8("graphics/pokemon/piloswine/footprint.1bpp");
+
+const u32 gMonFrontPic_Corsola[] = INCBIN_U32("graphics/pokemon/corsola/front.4bpp.lz");
+const u32 gMonPalette_Corsola[] = INCBIN_U32("graphics/pokemon/corsola/normal.gbapal.lz");
+const u32 gMonBackPic_Corsola[] = INCBIN_U32("graphics/pokemon/corsola/back.4bpp.lz");
+const u32 gMonShinyPalette_Corsola[] = INCBIN_U32("graphics/pokemon/corsola/shiny.gbapal.lz");
+const u8 gMonIcon_Corsola[] = INCBIN_U8("graphics/pokemon/corsola/icon.4bpp");
+const u8 gMonFootprint_Corsola[] = INCBIN_U8("graphics/pokemon/corsola/footprint.1bpp");
+
+const u32 gMonFrontPic_Remoraid[] = INCBIN_U32("graphics/pokemon/remoraid/front.4bpp.lz");
+const u32 gMonPalette_Remoraid[] = INCBIN_U32("graphics/pokemon/remoraid/normal.gbapal.lz");
+const u32 gMonBackPic_Remoraid[] = INCBIN_U32("graphics/pokemon/remoraid/back.4bpp.lz");
+const u32 gMonShinyPalette_Remoraid[] = INCBIN_U32("graphics/pokemon/remoraid/shiny.gbapal.lz");
+const u8 gMonIcon_Remoraid[] = INCBIN_U8("graphics/pokemon/remoraid/icon.4bpp");
+const u8 gMonFootprint_Remoraid[] = INCBIN_U8("graphics/pokemon/remoraid/footprint.1bpp");
+
+const u32 gMonFrontPic_Octillery[] = INCBIN_U32("graphics/pokemon/octillery/front.4bpp.lz");
+const u32 gMonPalette_Octillery[] = INCBIN_U32("graphics/pokemon/octillery/normal.gbapal.lz");
+const u32 gMonBackPic_Octillery[] = INCBIN_U32("graphics/pokemon/octillery/back.4bpp.lz");
+const u32 gMonShinyPalette_Octillery[] = INCBIN_U32("graphics/pokemon/octillery/shiny.gbapal.lz");
+const u8 gMonIcon_Octillery[] = INCBIN_U8("graphics/pokemon/octillery/icon.4bpp");
+const u8 gMonFootprint_Octillery[] = INCBIN_U8("graphics/pokemon/octillery/footprint.1bpp");
+
+const u32 gMonFrontPic_Delibird[] = INCBIN_U32("graphics/pokemon/delibird/front.4bpp.lz");
+const u32 gMonPalette_Delibird[] = INCBIN_U32("graphics/pokemon/delibird/normal.gbapal.lz");
+const u32 gMonBackPic_Delibird[] = INCBIN_U32("graphics/pokemon/delibird/back.4bpp.lz");
+const u32 gMonShinyPalette_Delibird[] = INCBIN_U32("graphics/pokemon/delibird/shiny.gbapal.lz");
+const u8 gMonIcon_Delibird[] = INCBIN_U8("graphics/pokemon/delibird/icon.4bpp");
+const u8 gMonFootprint_Delibird[] = INCBIN_U8("graphics/pokemon/delibird/footprint.1bpp");
+
+const u32 gMonFrontPic_Mantine[] = INCBIN_U32("graphics/pokemon/mantine/front.4bpp.lz");
+const u32 gMonPalette_Mantine[] = INCBIN_U32("graphics/pokemon/mantine/normal.gbapal.lz");
+const u32 gMonBackPic_Mantine[] = INCBIN_U32("graphics/pokemon/mantine/back.4bpp.lz");
+const u32 gMonShinyPalette_Mantine[] = INCBIN_U32("graphics/pokemon/mantine/shiny.gbapal.lz");
+const u8 gMonIcon_Mantine[] = INCBIN_U8("graphics/pokemon/mantine/icon.4bpp");
+const u8 gMonFootprint_Mantine[] = INCBIN_U8("graphics/pokemon/mantine/footprint.1bpp");
+
+const u32 gMonFrontPic_Skarmory[] = INCBIN_U32("graphics/pokemon/skarmory/front.4bpp.lz");
+const u32 gMonPalette_Skarmory[] = INCBIN_U32("graphics/pokemon/skarmory/normal.gbapal.lz");
+const u32 gMonBackPic_Skarmory[] = INCBIN_U32("graphics/pokemon/skarmory/back.4bpp.lz");
+const u32 gMonShinyPalette_Skarmory[] = INCBIN_U32("graphics/pokemon/skarmory/shiny.gbapal.lz");
+const u8 gMonIcon_Skarmory[] = INCBIN_U8("graphics/pokemon/skarmory/icon.4bpp");
+const u8 gMonFootprint_Skarmory[] = INCBIN_U8("graphics/pokemon/skarmory/footprint.1bpp");
+
+const u32 gMonFrontPic_Houndour[] = INCBIN_U32("graphics/pokemon/houndour/front.4bpp.lz");
+const u32 gMonPalette_Houndour[] = INCBIN_U32("graphics/pokemon/houndour/normal.gbapal.lz");
+const u32 gMonBackPic_Houndour[] = INCBIN_U32("graphics/pokemon/houndour/back.4bpp.lz");
+const u32 gMonShinyPalette_Houndour[] = INCBIN_U32("graphics/pokemon/houndour/shiny.gbapal.lz");
+const u8 gMonIcon_Houndour[] = INCBIN_U8("graphics/pokemon/houndour/icon.4bpp");
+const u8 gMonFootprint_Houndour[] = INCBIN_U8("graphics/pokemon/houndour/footprint.1bpp");
+
+const u32 gMonFrontPic_Houndoom[] = INCBIN_U32("graphics/pokemon/houndoom/front.4bpp.lz");
+const u32 gMonPalette_Houndoom[] = INCBIN_U32("graphics/pokemon/houndoom/normal.gbapal.lz");
+const u32 gMonBackPic_Houndoom[] = INCBIN_U32("graphics/pokemon/houndoom/back.4bpp.lz");
+const u32 gMonShinyPalette_Houndoom[] = INCBIN_U32("graphics/pokemon/houndoom/shiny.gbapal.lz");
+const u8 gMonIcon_Houndoom[] = INCBIN_U8("graphics/pokemon/houndoom/icon.4bpp");
+const u8 gMonFootprint_Houndoom[] = INCBIN_U8("graphics/pokemon/houndoom/footprint.1bpp");
+
+const u32 gMonFrontPic_Kingdra[] = INCBIN_U32("graphics/pokemon/kingdra/front.4bpp.lz");
+const u32 gMonPalette_Kingdra[] = INCBIN_U32("graphics/pokemon/kingdra/normal.gbapal.lz");
+const u32 gMonBackPic_Kingdra[] = INCBIN_U32("graphics/pokemon/kingdra/back.4bpp.lz");
+const u32 gMonShinyPalette_Kingdra[] = INCBIN_U32("graphics/pokemon/kingdra/shiny.gbapal.lz");
+const u8 gMonIcon_Kingdra[] = INCBIN_U8("graphics/pokemon/kingdra/icon.4bpp");
+const u8 gMonFootprint_Kingdra[] = INCBIN_U8("graphics/pokemon/kingdra/footprint.1bpp");
+
+const u32 gMonFrontPic_Phanpy[] = INCBIN_U32("graphics/pokemon/phanpy/front.4bpp.lz");
+const u32 gMonPalette_Phanpy[] = INCBIN_U32("graphics/pokemon/phanpy/normal.gbapal.lz");
+const u32 gMonBackPic_Phanpy[] = INCBIN_U32("graphics/pokemon/phanpy/back.4bpp.lz");
+const u32 gMonShinyPalette_Phanpy[] = INCBIN_U32("graphics/pokemon/phanpy/shiny.gbapal.lz");
+const u8 gMonIcon_Phanpy[] = INCBIN_U8("graphics/pokemon/phanpy/icon.4bpp");
+const u8 gMonFootprint_Phanpy[] = INCBIN_U8("graphics/pokemon/phanpy/footprint.1bpp");
+
+const u32 gMonFrontPic_Donphan[] = INCBIN_U32("graphics/pokemon/donphan/front.4bpp.lz");
+const u32 gMonPalette_Donphan[] = INCBIN_U32("graphics/pokemon/donphan/normal.gbapal.lz");
+const u32 gMonBackPic_Donphan[] = INCBIN_U32("graphics/pokemon/donphan/back.4bpp.lz");
+const u32 gMonShinyPalette_Donphan[] = INCBIN_U32("graphics/pokemon/donphan/shiny.gbapal.lz");
+const u8 gMonIcon_Donphan[] = INCBIN_U8("graphics/pokemon/donphan/icon.4bpp");
+const u8 gMonFootprint_Donphan[] = INCBIN_U8("graphics/pokemon/donphan/footprint.1bpp");
+
+const u32 gMonFrontPic_Porygon2[] = INCBIN_U32("graphics/pokemon/porygon2/front.4bpp.lz");
+const u32 gMonPalette_Porygon2[] = INCBIN_U32("graphics/pokemon/porygon2/normal.gbapal.lz");
+const u32 gMonBackPic_Porygon2[] = INCBIN_U32("graphics/pokemon/porygon2/back.4bpp.lz");
+const u32 gMonShinyPalette_Porygon2[] = INCBIN_U32("graphics/pokemon/porygon2/shiny.gbapal.lz");
+const u8 gMonIcon_Porygon2[] = INCBIN_U8("graphics/pokemon/porygon2/icon.4bpp");
+const u8 gMonFootprint_Porygon2[] = INCBIN_U8("graphics/pokemon/porygon2/footprint.1bpp");
+
+const u32 gMonFrontPic_Stantler[] = INCBIN_U32("graphics/pokemon/stantler/front.4bpp.lz");
+const u32 gMonPalette_Stantler[] = INCBIN_U32("graphics/pokemon/stantler/normal.gbapal.lz");
+const u32 gMonBackPic_Stantler[] = INCBIN_U32("graphics/pokemon/stantler/back.4bpp.lz");
+const u32 gMonShinyPalette_Stantler[] = INCBIN_U32("graphics/pokemon/stantler/shiny.gbapal.lz");
+const u8 gMonIcon_Stantler[] = INCBIN_U8("graphics/pokemon/stantler/icon.4bpp");
+const u8 gMonFootprint_Stantler[] = INCBIN_U8("graphics/pokemon/stantler/footprint.1bpp");
+
+const u32 gMonFrontPic_Smeargle[] = INCBIN_U32("graphics/pokemon/smeargle/front.4bpp.lz");
+const u32 gMonPalette_Smeargle[] = INCBIN_U32("graphics/pokemon/smeargle/normal.gbapal.lz");
+const u32 gMonBackPic_Smeargle[] = INCBIN_U32("graphics/pokemon/smeargle/back.4bpp.lz");
+const u32 gMonShinyPalette_Smeargle[] = INCBIN_U32("graphics/pokemon/smeargle/shiny.gbapal.lz");
+const u8 gMonIcon_Smeargle[] = INCBIN_U8("graphics/pokemon/smeargle/icon.4bpp");
+const u8 gMonFootprint_Smeargle[] = INCBIN_U8("graphics/pokemon/smeargle/footprint.1bpp");
+
+const u32 gMonFrontPic_Tyrogue[] = INCBIN_U32("graphics/pokemon/tyrogue/front.4bpp.lz");
+const u32 gMonPalette_Tyrogue[] = INCBIN_U32("graphics/pokemon/tyrogue/normal.gbapal.lz");
+const u32 gMonBackPic_Tyrogue[] = INCBIN_U32("graphics/pokemon/tyrogue/back.4bpp.lz");
+const u32 gMonShinyPalette_Tyrogue[] = INCBIN_U32("graphics/pokemon/tyrogue/shiny.gbapal.lz");
+const u8 gMonIcon_Tyrogue[] = INCBIN_U8("graphics/pokemon/tyrogue/icon.4bpp");
+const u8 gMonFootprint_Tyrogue[] = INCBIN_U8("graphics/pokemon/tyrogue/footprint.1bpp");
+
+const u32 gMonFrontPic_Hitmontop[] = INCBIN_U32("graphics/pokemon/hitmontop/front.4bpp.lz");
+const u32 gMonPalette_Hitmontop[] = INCBIN_U32("graphics/pokemon/hitmontop/normal.gbapal.lz");
+const u32 gMonBackPic_Hitmontop[] = INCBIN_U32("graphics/pokemon/hitmontop/back.4bpp.lz");
+const u32 gMonShinyPalette_Hitmontop[] = INCBIN_U32("graphics/pokemon/hitmontop/shiny.gbapal.lz");
+const u8 gMonIcon_Hitmontop[] = INCBIN_U8("graphics/pokemon/hitmontop/icon.4bpp");
+
+// This might be undefined memory garbage. Its all 00s except for 1 0F. Its also not referenced.
+const u32 gUndefined_8DD1E90[] = INCBIN_U32("data/garbage_8DD2290.bin");
+
+const u8 gMonFootprint_Hitmontop[] = INCBIN_U8("graphics/pokemon/hitmontop/footprint.1bpp");
+
+const u32 gMonFrontPic_Smoochum[] = INCBIN_U32("graphics/pokemon/smoochum/front.4bpp.lz");
+const u32 gMonPalette_Smoochum[] = INCBIN_U32("graphics/pokemon/smoochum/normal.gbapal.lz");
+const u32 gMonBackPic_Smoochum[] = INCBIN_U32("graphics/pokemon/smoochum/back.4bpp.lz");
+const u32 gMonShinyPalette_Smoochum[] = INCBIN_U32("graphics/pokemon/smoochum/shiny.gbapal.lz");
+const u8 gMonIcon_Smoochum[] = INCBIN_U8("graphics/pokemon/smoochum/icon.4bpp");
+const u8 gMonFootprint_Smoochum[] = INCBIN_U8("graphics/pokemon/smoochum/footprint.1bpp");
+
+const u32 gMonFrontPic_Elekid[] = INCBIN_U32("graphics/pokemon/elekid/front.4bpp.lz");
+const u32 gMonPalette_Elekid[] = INCBIN_U32("graphics/pokemon/elekid/normal.gbapal.lz");
+const u32 gMonBackPic_Elekid[] = INCBIN_U32("graphics/pokemon/elekid/back.4bpp.lz");
+const u32 gMonShinyPalette_Elekid[] = INCBIN_U32("graphics/pokemon/elekid/shiny.gbapal.lz");
+const u8 gMonIcon_Elekid[] = INCBIN_U8("graphics/pokemon/elekid/icon.4bpp");
+const u8 gMonFootprint_Elekid[] = INCBIN_U8("graphics/pokemon/elekid/footprint.1bpp");
+
+const u32 gMonFrontPic_Magby[] = INCBIN_U32("graphics/pokemon/magby/front.4bpp.lz");
+const u32 gMonPalette_Magby[] = INCBIN_U32("graphics/pokemon/magby/normal.gbapal.lz");
+const u32 gMonBackPic_Magby[] = INCBIN_U32("graphics/pokemon/magby/back.4bpp.lz");
+const u32 gMonShinyPalette_Magby[] = INCBIN_U32("graphics/pokemon/magby/shiny.gbapal.lz");
+const u8 gMonIcon_Magby[] = INCBIN_U8("graphics/pokemon/magby/icon.4bpp");
+const u8 gMonFootprint_Magby[] = INCBIN_U8("graphics/pokemon/magby/footprint.1bpp");
+
+const u32 gMonFrontPic_Miltank[] = INCBIN_U32("graphics/pokemon/miltank/front.4bpp.lz");
+const u32 gMonPalette_Miltank[] = INCBIN_U32("graphics/pokemon/miltank/normal.gbapal.lz");
+const u32 gMonBackPic_Miltank[] = INCBIN_U32("graphics/pokemon/miltank/back.4bpp.lz");
+const u32 gMonShinyPalette_Miltank[] = INCBIN_U32("graphics/pokemon/miltank/shiny.gbapal.lz");
+const u8 gMonIcon_Miltank[] = INCBIN_U8("graphics/pokemon/miltank/icon.4bpp");
+const u8 gMonFootprint_Miltank[] = INCBIN_U8("graphics/pokemon/miltank/footprint.1bpp");
+
+const u32 gMonFrontPic_Blissey[] = INCBIN_U32("graphics/pokemon/blissey/front.4bpp.lz");
+const u32 gMonPalette_Blissey[] = INCBIN_U32("graphics/pokemon/blissey/normal.gbapal.lz");
+const u32 gMonBackPic_Blissey[] = INCBIN_U32("graphics/pokemon/blissey/back.4bpp.lz");
+const u32 gMonShinyPalette_Blissey[] = INCBIN_U32("graphics/pokemon/blissey/shiny.gbapal.lz");
+const u8 gMonIcon_Blissey[] = INCBIN_U8("graphics/pokemon/blissey/icon.4bpp");
+const u8 gMonFootprint_Blissey[] = INCBIN_U8("graphics/pokemon/blissey/footprint.1bpp");
+
+const u32 gMonFrontPic_Raikou[] = INCBIN_U32("graphics/pokemon/raikou/front.4bpp.lz");
+const u32 gMonPalette_Raikou[] = INCBIN_U32("graphics/pokemon/raikou/normal.gbapal.lz");
+const u32 gMonBackPic_Raikou[] = INCBIN_U32("graphics/pokemon/raikou/back.4bpp.lz");
+const u32 gMonShinyPalette_Raikou[] = INCBIN_U32("graphics/pokemon/raikou/shiny.gbapal.lz");
+const u8 gMonIcon_Raikou[] = INCBIN_U8("graphics/pokemon/raikou/icon.4bpp");
+const u8 gMonFootprint_Raikou[] = INCBIN_U8("graphics/pokemon/raikou/footprint.1bpp");
+
+const u32 gMonFrontPic_Entei[] = INCBIN_U32("graphics/pokemon/entei/front.4bpp.lz");
+const u32 gMonPalette_Entei[] = INCBIN_U32("graphics/pokemon/entei/normal.gbapal.lz");
+const u32 gMonBackPic_Entei[] = INCBIN_U32("graphics/pokemon/entei/back.4bpp.lz");
+const u32 gMonShinyPalette_Entei[] = INCBIN_U32("graphics/pokemon/entei/shiny.gbapal.lz");
+const u8 gMonIcon_Entei[] = INCBIN_U8("graphics/pokemon/entei/icon.4bpp");
+const u8 gMonFootprint_Entei[] = INCBIN_U8("graphics/pokemon/entei/footprint.1bpp");
+
+const u32 gMonFrontPic_Suicune[] = INCBIN_U32("graphics/pokemon/suicune/front.4bpp.lz");
+const u32 gMonPalette_Suicune[] = INCBIN_U32("graphics/pokemon/suicune/normal.gbapal.lz");
+const u32 gMonBackPic_Suicune[] = INCBIN_U32("graphics/pokemon/suicune/back.4bpp.lz");
+const u32 gMonShinyPalette_Suicune[] = INCBIN_U32("graphics/pokemon/suicune/shiny.gbapal.lz");
+const u8 gMonIcon_Suicune[] = INCBIN_U8("graphics/pokemon/suicune/icon.4bpp");
+const u8 gMonFootprint_Suicune[] = INCBIN_U8("graphics/pokemon/suicune/footprint.1bpp");
+
+const u32 gMonFrontPic_Larvitar[] = INCBIN_U32("graphics/pokemon/larvitar/front.4bpp.lz");
+const u32 gMonPalette_Larvitar[] = INCBIN_U32("graphics/pokemon/larvitar/normal.gbapal.lz");
+const u32 gMonBackPic_Larvitar[] = INCBIN_U32("graphics/pokemon/larvitar/back.4bpp.lz");
+const u32 gMonShinyPalette_Larvitar[] = INCBIN_U32("graphics/pokemon/larvitar/shiny.gbapal.lz");
+const u8 gMonIcon_Larvitar[] = INCBIN_U8("graphics/pokemon/larvitar/icon.4bpp");
+const u8 gMonFootprint_Larvitar[] = INCBIN_U8("graphics/pokemon/larvitar/footprint.1bpp");
+
+const u32 gMonFrontPic_Pupitar[] = INCBIN_U32("graphics/pokemon/pupitar/front.4bpp.lz");
+const u32 gMonPalette_Pupitar[] = INCBIN_U32("graphics/pokemon/pupitar/normal.gbapal.lz");
+const u32 gMonBackPic_Pupitar[] = INCBIN_U32("graphics/pokemon/pupitar/back.4bpp.lz");
+const u32 gMonShinyPalette_Pupitar[] = INCBIN_U32("graphics/pokemon/pupitar/shiny.gbapal.lz");
+const u8 gMonIcon_Pupitar[] = INCBIN_U8("graphics/pokemon/pupitar/icon.4bpp");
+const u8 gMonFootprint_Pupitar[] = INCBIN_U8("graphics/pokemon/pupitar/footprint.1bpp");
+
+const u32 gMonFrontPic_Tyranitar[] = INCBIN_U32("graphics/pokemon/tyranitar/front.4bpp.lz");
+const u32 gMonPalette_Tyranitar[] = INCBIN_U32("graphics/pokemon/tyranitar/normal.gbapal.lz");
+const u32 gMonBackPic_Tyranitar[] = INCBIN_U32("graphics/pokemon/tyranitar/back.4bpp.lz");
+const u32 gMonShinyPalette_Tyranitar[] = INCBIN_U32("graphics/pokemon/tyranitar/shiny.gbapal.lz");
+const u8 gMonIcon_Tyranitar[] = INCBIN_U8("graphics/pokemon/tyranitar/icon.4bpp");
+const u8 gMonFootprint_Tyranitar[] = INCBIN_U8("graphics/pokemon/tyranitar/footprint.1bpp");
+
+const u32 gMonFrontPic_Lugia[] = INCBIN_U32("graphics/pokemon/lugia/front.4bpp.lz");
+const u32 gMonPalette_Lugia[] = INCBIN_U32("graphics/pokemon/lugia/normal.gbapal.lz");
+const u32 gMonBackPic_Lugia[] = INCBIN_U32("graphics/pokemon/lugia/back.4bpp.lz");
+const u32 gMonShinyPalette_Lugia[] = INCBIN_U32("graphics/pokemon/lugia/shiny.gbapal.lz");
+const u8 gMonIcon_Lugia[] = INCBIN_U8("graphics/pokemon/lugia/icon.4bpp");
+const u8 gMonFootprint_Lugia[] = INCBIN_U8("graphics/pokemon/lugia/footprint.1bpp");
+
+const u32 gMonFrontPic_HoOh[] = INCBIN_U32("graphics/pokemon/ho_oh/front.4bpp.lz");
+const u32 gMonPalette_HoOh[] = INCBIN_U32("graphics/pokemon/ho_oh/normal.gbapal.lz");
+const u32 gMonBackPic_HoOh[] = INCBIN_U32("graphics/pokemon/ho_oh/back.4bpp.lz");
+const u32 gMonShinyPalette_HoOh[] = INCBIN_U32("graphics/pokemon/ho_oh/shiny.gbapal.lz");
+const u8 gMonIcon_HoOh[] = INCBIN_U8("graphics/pokemon/ho_oh/icon.4bpp");
+const u8 gMonFootprint_HoOh[] = INCBIN_U8("graphics/pokemon/ho_oh/footprint.1bpp");
+
+const u32 gMonFrontPic_Celebi[] = INCBIN_U32("graphics/pokemon/celebi/front.4bpp.lz");
+const u32 gMonPalette_Celebi[] = INCBIN_U32("graphics/pokemon/celebi/normal.gbapal.lz");
+const u32 gMonBackPic_Celebi[] = INCBIN_U32("graphics/pokemon/celebi/back.4bpp.lz");
+const u32 gMonShinyPalette_Celebi[] = INCBIN_U32("graphics/pokemon/celebi/shiny.gbapal.lz");
+const u8 gMonIcon_Celebi[] = INCBIN_U8("graphics/pokemon/celebi/icon.4bpp");
+const u8 gMonFootprint_Celebi[] = INCBIN_U8("graphics/pokemon/celebi/footprint.1bpp");
+
+const u32 gMonFrontPic_DoubleQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/double/front.4bpp.lz");
+const u32 gMonPalette_DoubleQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/double/normal.gbapal.lz");
+const u32 gMonBackPic_DoubleQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/double/back.4bpp.lz");
+const u32 gMonShinyPalette_DoubleQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/double/shiny.gbapal.lz");
+
+const u32 gMonFrontPic_Treecko[] = INCBIN_U32("graphics/pokemon/treecko/front.4bpp.lz");
+const u32 gMonPalette_Treecko[] = INCBIN_U32("graphics/pokemon/treecko/normal.gbapal.lz");
+const u32 gMonBackPic_Treecko[] = INCBIN_U32("graphics/pokemon/treecko/back.4bpp.lz");
+const u32 gMonShinyPalette_Treecko[] = INCBIN_U32("graphics/pokemon/treecko/shiny.gbapal.lz");
+const u8 gMonIcon_Treecko[] = INCBIN_U8("graphics/pokemon/treecko/icon.4bpp");
+const u8 gMonFootprint_Treecko[] = INCBIN_U8("graphics/pokemon/treecko/footprint.1bpp");
+
+const u32 gMonFrontPic_Grovyle[] = INCBIN_U32("graphics/pokemon/grovyle/front.4bpp.lz");
+const u32 gMonPalette_Grovyle[] = INCBIN_U32("graphics/pokemon/grovyle/normal.gbapal.lz");
+const u32 gMonBackPic_Grovyle[] = INCBIN_U32("graphics/pokemon/grovyle/back.4bpp.lz");
+const u32 gMonShinyPalette_Grovyle[] = INCBIN_U32("graphics/pokemon/grovyle/shiny.gbapal.lz");
+const u8 gMonIcon_Grovyle[] = INCBIN_U8("graphics/pokemon/grovyle/icon.4bpp");
+const u8 gMonFootprint_Grovyle[] = INCBIN_U8("graphics/pokemon/grovyle/footprint.1bpp");
+
+const u32 gMonFrontPic_Sceptile[] = INCBIN_U32("graphics/pokemon/sceptile/front.4bpp.lz");
+const u32 gMonPalette_Sceptile[] = INCBIN_U32("graphics/pokemon/sceptile/normal.gbapal.lz");
+const u32 gMonBackPic_Sceptile[] = INCBIN_U32("graphics/pokemon/sceptile/back.4bpp.lz");
+const u32 gMonShinyPalette_Sceptile[] = INCBIN_U32("graphics/pokemon/sceptile/shiny.gbapal.lz");
+const u8 gMonIcon_Sceptile[] = INCBIN_U8("graphics/pokemon/sceptile/icon.4bpp");
+const u8 gMonFootprint_Sceptile[] = INCBIN_U8("graphics/pokemon/sceptile/footprint.1bpp");
+
+const u32 gMonFrontPic_Torchic[] = INCBIN_U32("graphics/pokemon/torchic/front.4bpp.lz");
+const u32 gMonPalette_Torchic[] = INCBIN_U32("graphics/pokemon/torchic/normal.gbapal.lz");
+const u32 gMonBackPic_Torchic[] = INCBIN_U32("graphics/pokemon/torchic/back.4bpp.lz");
+const u32 gMonShinyPalette_Torchic[] = INCBIN_U32("graphics/pokemon/torchic/shiny.gbapal.lz");
+const u8 gMonIcon_Torchic[] = INCBIN_U8("graphics/pokemon/torchic/icon.4bpp");
+const u8 gMonFootprint_Torchic[] = INCBIN_U8("graphics/pokemon/torchic/footprint.1bpp");
+
+const u32 gMonFrontPic_Combusken[] = INCBIN_U32("graphics/pokemon/combusken/front.4bpp.lz");
+const u32 gMonPalette_Combusken[] = INCBIN_U32("graphics/pokemon/combusken/normal.gbapal.lz");
+const u32 gMonBackPic_Combusken[] = INCBIN_U32("graphics/pokemon/combusken/back.4bpp.lz");
+const u32 gMonShinyPalette_Combusken[] = INCBIN_U32("graphics/pokemon/combusken/shiny.gbapal.lz");
+const u8 gMonIcon_Combusken[] = INCBIN_U8("graphics/pokemon/combusken/icon.4bpp");
+const u8 gMonFootprint_Combusken[] = INCBIN_U8("graphics/pokemon/combusken/footprint.1bpp");
+
+const u32 gMonFrontPic_Blaziken[] = INCBIN_U32("graphics/pokemon/blaziken/front.4bpp.lz");
+const u32 gMonPalette_Blaziken[] = INCBIN_U32("graphics/pokemon/blaziken/normal.gbapal.lz");
+const u32 gMonBackPic_Blaziken[] = INCBIN_U32("graphics/pokemon/blaziken/back.4bpp.lz");
+const u32 gMonShinyPalette_Blaziken[] = INCBIN_U32("graphics/pokemon/blaziken/shiny.gbapal.lz");
+const u8 gMonIcon_Blaziken[] = INCBIN_U8("graphics/pokemon/blaziken/icon.4bpp");
+const u8 gMonFootprint_Blaziken[] = INCBIN_U8("graphics/pokemon/blaziken/footprint.1bpp");
+
+const u32 gMonFrontPic_Mudkip[] = INCBIN_U32("graphics/pokemon/mudkip/front.4bpp.lz");
+const u32 gMonPalette_Mudkip[] = INCBIN_U32("graphics/pokemon/mudkip/normal.gbapal.lz");
+const u32 gMonBackPic_Mudkip[] = INCBIN_U32("graphics/pokemon/mudkip/back.4bpp.lz");
+const u32 gMonShinyPalette_Mudkip[] = INCBIN_U32("graphics/pokemon/mudkip/shiny.gbapal.lz");
+const u8 gMonIcon_Mudkip[] = INCBIN_U8("graphics/pokemon/mudkip/icon.4bpp");
+const u8 gMonFootprint_Mudkip[] = INCBIN_U8("graphics/pokemon/mudkip/footprint.1bpp");
+
+const u32 gMonFrontPic_Marshtomp[] = INCBIN_U32("graphics/pokemon/marshtomp/front.4bpp.lz");
+const u32 gMonPalette_Marshtomp[] = INCBIN_U32("graphics/pokemon/marshtomp/normal.gbapal.lz");
+const u32 gMonBackPic_Marshtomp[] = INCBIN_U32("graphics/pokemon/marshtomp/back.4bpp.lz");
+const u32 gMonShinyPalette_Marshtomp[] = INCBIN_U32("graphics/pokemon/marshtomp/shiny.gbapal.lz");
+const u8 gMonIcon_Marshtomp[] = INCBIN_U8("graphics/pokemon/marshtomp/icon.4bpp");
+const u8 gMonFootprint_Marshtomp[] = INCBIN_U8("graphics/pokemon/marshtomp/footprint.1bpp");
+
+const u32 gMonFrontPic_Swampert[] = INCBIN_U32("graphics/pokemon/swampert/front.4bpp.lz");
+const u32 gMonPalette_Swampert[] = INCBIN_U32("graphics/pokemon/swampert/normal.gbapal.lz");
+const u32 gMonBackPic_Swampert[] = INCBIN_U32("graphics/pokemon/swampert/back.4bpp.lz");
+const u32 gMonShinyPalette_Swampert[] = INCBIN_U32("graphics/pokemon/swampert/shiny.gbapal.lz");
+const u8 gMonIcon_Swampert[] = INCBIN_U8("graphics/pokemon/swampert/icon.4bpp");
+const u8 gMonFootprint_Swampert[] = INCBIN_U8("graphics/pokemon/swampert/footprint.1bpp");
+
+const u32 gMonFrontPic_Poochyena[] = INCBIN_U32("graphics/pokemon/poochyena/front.4bpp.lz");
+const u32 gMonPalette_Poochyena[] = INCBIN_U32("graphics/pokemon/poochyena/normal.gbapal.lz");
+const u32 gMonBackPic_Poochyena[] = INCBIN_U32("graphics/pokemon/poochyena/back.4bpp.lz");
+const u32 gMonShinyPalette_Poochyena[] = INCBIN_U32("graphics/pokemon/poochyena/shiny.gbapal.lz");
+const u8 gMonIcon_Poochyena[] = INCBIN_U8("graphics/pokemon/poochyena/icon.4bpp");
+const u8 gMonFootprint_Poochyena[] = INCBIN_U8("graphics/pokemon/poochyena/footprint.1bpp");
+
+const u32 gMonFrontPic_Mightyena[] = INCBIN_U32("graphics/pokemon/mightyena/front.4bpp.lz");
+const u32 gMonPalette_Mightyena[] = INCBIN_U32("graphics/pokemon/mightyena/normal.gbapal.lz");
+const u32 gMonBackPic_Mightyena[] = INCBIN_U32("graphics/pokemon/mightyena/back.4bpp.lz");
+const u32 gMonShinyPalette_Mightyena[] = INCBIN_U32("graphics/pokemon/mightyena/shiny.gbapal.lz");
+const u8 gMonIcon_Mightyena[] = INCBIN_U8("graphics/pokemon/mightyena/icon.4bpp");
+const u8 gMonFootprint_Mightyena[] = INCBIN_U8("graphics/pokemon/mightyena/footprint.1bpp");
+
+const u32 gMonFrontPic_Zigzagoon[] = INCBIN_U32("graphics/pokemon/zigzagoon/front.4bpp.lz");
+const u32 gMonPalette_Zigzagoon[] = INCBIN_U32("graphics/pokemon/zigzagoon/normal.gbapal.lz");
+const u32 gMonBackPic_Zigzagoon[] = INCBIN_U32("graphics/pokemon/zigzagoon/back.4bpp.lz");
+const u32 gMonShinyPalette_Zigzagoon[] = INCBIN_U32("graphics/pokemon/zigzagoon/shiny.gbapal.lz");
+const u8 gMonIcon_Zigzagoon[] = INCBIN_U8("graphics/pokemon/zigzagoon/icon.4bpp");
+const u8 gMonFootprint_Zigzagoon[] = INCBIN_U8("graphics/pokemon/zigzagoon/footprint.1bpp");
+
+const u32 gMonFrontPic_Linoone[] = INCBIN_U32("graphics/pokemon/linoone/front.4bpp.lz");
+const u32 gMonPalette_Linoone[] = INCBIN_U32("graphics/pokemon/linoone/normal.gbapal.lz");
+const u32 gMonBackPic_Linoone[] = INCBIN_U32("graphics/pokemon/linoone/back.4bpp.lz");
+const u32 gMonShinyPalette_Linoone[] = INCBIN_U32("graphics/pokemon/linoone/shiny.gbapal.lz");
+const u8 gMonIcon_Linoone[] = INCBIN_U8("graphics/pokemon/linoone/icon.4bpp");
+const u8 gMonFootprint_Linoone[] = INCBIN_U8("graphics/pokemon/linoone/footprint.1bpp");
+
+const u32 gMonFrontPic_Wurmple[] = INCBIN_U32("graphics/pokemon/wurmple/front.4bpp.lz");
+const u32 gMonPalette_Wurmple[] = INCBIN_U32("graphics/pokemon/wurmple/normal.gbapal.lz");
+const u32 gMonBackPic_Wurmple[] = INCBIN_U32("graphics/pokemon/wurmple/back.4bpp.lz");
+const u32 gMonShinyPalette_Wurmple[] = INCBIN_U32("graphics/pokemon/wurmple/shiny.gbapal.lz");
+const u8 gMonIcon_Wurmple[] = INCBIN_U8("graphics/pokemon/wurmple/icon.4bpp");
+const u8 gMonFootprint_Wurmple[] = INCBIN_U8("graphics/pokemon/wurmple/footprint.1bpp");
+
+const u32 gMonFrontPic_Silcoon[] = INCBIN_U32("graphics/pokemon/silcoon/front.4bpp.lz");
+const u32 gMonPalette_Silcoon[] = INCBIN_U32("graphics/pokemon/silcoon/normal.gbapal.lz");
+const u32 gMonBackPic_Silcoon[] = INCBIN_U32("graphics/pokemon/silcoon/back.4bpp.lz");
+const u32 gMonShinyPalette_Silcoon[] = INCBIN_U32("graphics/pokemon/silcoon/shiny.gbapal.lz");
+const u8 gMonIcon_Silcoon[] = INCBIN_U8("graphics/pokemon/silcoon/icon.4bpp");
+const u8 gMonFootprint_Silcoon[] = INCBIN_U8("graphics/pokemon/silcoon/footprint.1bpp");
+
+const u32 gMonFrontPic_Beautifly[] = INCBIN_U32("graphics/pokemon/beautifly/front.4bpp.lz");
+const u32 gMonPalette_Beautifly[] = INCBIN_U32("graphics/pokemon/beautifly/normal.gbapal.lz");
+const u32 gMonBackPic_Beautifly[] = INCBIN_U32("graphics/pokemon/beautifly/back.4bpp.lz");
+const u32 gMonShinyPalette_Beautifly[] = INCBIN_U32("graphics/pokemon/beautifly/shiny.gbapal.lz");
+const u8 gMonIcon_Beautifly[] = INCBIN_U8("graphics/pokemon/beautifly/icon.4bpp");
+const u8 gMonFootprint_Beautifly[] = INCBIN_U8("graphics/pokemon/beautifly/footprint.1bpp");
+
+const u32 gMonFrontPic_Cascoon[] = INCBIN_U32("graphics/pokemon/cascoon/front.4bpp.lz");
+const u32 gMonPalette_Cascoon[] = INCBIN_U32("graphics/pokemon/cascoon/normal.gbapal.lz");
+const u32 gMonBackPic_Cascoon[] = INCBIN_U32("graphics/pokemon/cascoon/back.4bpp.lz");
+const u32 gMonShinyPalette_Cascoon[] = INCBIN_U32("graphics/pokemon/cascoon/shiny.gbapal.lz");
+const u8 gMonIcon_Cascoon[] = INCBIN_U8("graphics/pokemon/cascoon/icon.4bpp");
+const u8 gMonFootprint_Cascoon[] = INCBIN_U8("graphics/pokemon/cascoon/footprint.1bpp");
+
+const u32 gMonFrontPic_Dustox[] = INCBIN_U32("graphics/pokemon/dustox/front.4bpp.lz");
+const u32 gMonPalette_Dustox[] = INCBIN_U32("graphics/pokemon/dustox/normal.gbapal.lz");
+const u32 gMonBackPic_Dustox[] = INCBIN_U32("graphics/pokemon/dustox/back.4bpp.lz");
+const u32 gMonShinyPalette_Dustox[] = INCBIN_U32("graphics/pokemon/dustox/shiny.gbapal.lz");
+const u8 gMonIcon_Dustox[] = INCBIN_U8("graphics/pokemon/dustox/icon.4bpp");
+const u8 gMonFootprint_Dustox[] = INCBIN_U8("graphics/pokemon/dustox/footprint.1bpp");
+
+const u32 gMonFrontPic_Lotad[] = INCBIN_U32("graphics/pokemon/lotad/front.4bpp.lz");
+const u32 gMonPalette_Lotad[] = INCBIN_U32("graphics/pokemon/lotad/normal.gbapal.lz");
+const u32 gMonBackPic_Lotad[] = INCBIN_U32("graphics/pokemon/lotad/back.4bpp.lz");
+const u32 gMonShinyPalette_Lotad[] = INCBIN_U32("graphics/pokemon/lotad/shiny.gbapal.lz");
+const u8 gMonIcon_Lotad[] = INCBIN_U8("graphics/pokemon/lotad/icon.4bpp");
+const u8 gMonFootprint_Lotad[] = INCBIN_U8("graphics/pokemon/lotad/footprint.1bpp");
+
+const u32 gMonFrontPic_Lombre[] = INCBIN_U32("graphics/pokemon/lombre/front.4bpp.lz");
+const u32 gMonPalette_Lombre[] = INCBIN_U32("graphics/pokemon/lombre/normal.gbapal.lz");
+const u32 gMonBackPic_Lombre[] = INCBIN_U32("graphics/pokemon/lombre/back.4bpp.lz");
+const u32 gMonShinyPalette_Lombre[] = INCBIN_U32("graphics/pokemon/lombre/shiny.gbapal.lz");
+const u8 gMonIcon_Lombre[] = INCBIN_U8("graphics/pokemon/lombre/icon.4bpp");
+const u8 gMonFootprint_Lombre[] = INCBIN_U8("graphics/pokemon/lombre/footprint.1bpp");
+
+const u32 gMonFrontPic_Ludicolo[] = INCBIN_U32("graphics/pokemon/ludicolo/front.4bpp.lz");
+const u32 gMonPalette_Ludicolo[] = INCBIN_U32("graphics/pokemon/ludicolo/normal.gbapal.lz");
+const u32 gMonBackPic_Ludicolo[] = INCBIN_U32("graphics/pokemon/ludicolo/back.4bpp.lz");
+const u32 gMonShinyPalette_Ludicolo[] = INCBIN_U32("graphics/pokemon/ludicolo/shiny.gbapal.lz");
+const u8 gMonIcon_Ludicolo[] = INCBIN_U8("graphics/pokemon/ludicolo/icon.4bpp");
+const u8 gMonFootprint_Ludicolo[] = INCBIN_U8("graphics/pokemon/ludicolo/footprint.1bpp");
+
+const u32 gMonFrontPic_Seedot[] = INCBIN_U32("graphics/pokemon/seedot/front.4bpp.lz");
+const u32 gMonPalette_Seedot[] = INCBIN_U32("graphics/pokemon/seedot/normal.gbapal.lz");
+const u32 gMonBackPic_Seedot[] = INCBIN_U32("graphics/pokemon/seedot/back.4bpp.lz");
+const u32 gMonShinyPalette_Seedot[] = INCBIN_U32("graphics/pokemon/seedot/shiny.gbapal.lz");
+const u8 gMonIcon_Seedot[] = INCBIN_U8("graphics/pokemon/seedot/icon.4bpp");
+const u8 gMonFootprint_Seedot[] = INCBIN_U8("graphics/pokemon/seedot/footprint.1bpp");
+
+const u32 gMonFrontPic_Nuzleaf[] = INCBIN_U32("graphics/pokemon/nuzleaf/front.4bpp.lz");
+const u32 gMonPalette_Nuzleaf[] = INCBIN_U32("graphics/pokemon/nuzleaf/normal.gbapal.lz");
+const u32 gMonBackPic_Nuzleaf[] = INCBIN_U32("graphics/pokemon/nuzleaf/back.4bpp.lz");
+const u32 gMonShinyPalette_Nuzleaf[] = INCBIN_U32("graphics/pokemon/nuzleaf/shiny.gbapal.lz");
+const u8 gMonIcon_Nuzleaf[] = INCBIN_U8("graphics/pokemon/nuzleaf/icon.4bpp");
+const u8 gMonFootprint_Nuzleaf[] = INCBIN_U8("graphics/pokemon/nuzleaf/footprint.1bpp");
+
+const u32 gMonFrontPic_Shiftry[] = INCBIN_U32("graphics/pokemon/shiftry/front.4bpp.lz");
+const u32 gMonPalette_Shiftry[] = INCBIN_U32("graphics/pokemon/shiftry/normal.gbapal.lz");
+const u32 gMonBackPic_Shiftry[] = INCBIN_U32("graphics/pokemon/shiftry/back.4bpp.lz");
+const u32 gMonShinyPalette_Shiftry[] = INCBIN_U32("graphics/pokemon/shiftry/shiny.gbapal.lz");
+const u8 gMonIcon_Shiftry[] = INCBIN_U8("graphics/pokemon/shiftry/icon.4bpp");
+const u8 gMonFootprint_Shiftry[] = INCBIN_U8("graphics/pokemon/shiftry/footprint.1bpp");
+
+const u32 gMonFrontPic_Nincada[] = INCBIN_U32("graphics/pokemon/nincada/front.4bpp.lz");
+const u32 gMonPalette_Nincada[] = INCBIN_U32("graphics/pokemon/nincada/normal.gbapal.lz");
+const u32 gMonBackPic_Nincada[] = INCBIN_U32("graphics/pokemon/nincada/back.4bpp.lz");
+const u32 gMonShinyPalette_Nincada[] = INCBIN_U32("graphics/pokemon/nincada/shiny.gbapal.lz");
+const u8 gMonIcon_Nincada[] = INCBIN_U8("graphics/pokemon/nincada/icon.4bpp");
+const u8 gMonFootprint_Nincada[] = INCBIN_U8("graphics/pokemon/nincada/footprint.1bpp");
+
+const u32 gMonFrontPic_Ninjask[] = INCBIN_U32("graphics/pokemon/ninjask/front.4bpp.lz");
+const u32 gMonPalette_Ninjask[] = INCBIN_U32("graphics/pokemon/ninjask/normal.gbapal.lz");
+const u32 gMonBackPic_Ninjask[] = INCBIN_U32("graphics/pokemon/ninjask/back.4bpp.lz");
+const u32 gMonShinyPalette_Ninjask[] = INCBIN_U32("graphics/pokemon/ninjask/shiny.gbapal.lz");
+const u8 gMonIcon_Ninjask[] = INCBIN_U8("graphics/pokemon/ninjask/icon.4bpp");
+const u8 gMonFootprint_Ninjask[] = INCBIN_U8("graphics/pokemon/ninjask/footprint.1bpp");
+
+const u32 gMonFrontPic_Shedinja[] = INCBIN_U32("graphics/pokemon/shedinja/front.4bpp.lz");
+const u32 gMonPalette_Shedinja[] = INCBIN_U32("graphics/pokemon/shedinja/normal.gbapal.lz");
+const u32 gMonBackPic_Shedinja[] = INCBIN_U32("graphics/pokemon/shedinja/back.4bpp.lz");
+const u32 gMonShinyPalette_Shedinja[] = INCBIN_U32("graphics/pokemon/shedinja/shiny.gbapal.lz");
+const u8 gMonIcon_Shedinja[] = INCBIN_U8("graphics/pokemon/shedinja/icon.4bpp");
+const u8 gMonFootprint_Shedinja[] = INCBIN_U8("graphics/pokemon/shedinja/footprint.1bpp");
+
+const u32 gMonFrontPic_Taillow[] = INCBIN_U32("graphics/pokemon/taillow/front.4bpp.lz");
+const u32 gMonPalette_Taillow[] = INCBIN_U32("graphics/pokemon/taillow/normal.gbapal.lz");
+const u32 gMonBackPic_Taillow[] = INCBIN_U32("graphics/pokemon/taillow/back.4bpp.lz");
+const u32 gMonShinyPalette_Taillow[] = INCBIN_U32("graphics/pokemon/taillow/shiny.gbapal.lz");
+const u8 gMonIcon_Taillow[] = INCBIN_U8("graphics/pokemon/taillow/icon.4bpp");
+const u8 gMonFootprint_Taillow[] = INCBIN_U8("graphics/pokemon/taillow/footprint.1bpp");
+
+const u32 gMonFrontPic_Swellow[] = INCBIN_U32("graphics/pokemon/swellow/front.4bpp.lz");
+const u32 gMonPalette_Swellow[] = INCBIN_U32("graphics/pokemon/swellow/normal.gbapal.lz");
+const u32 gMonBackPic_Swellow[] = INCBIN_U32("graphics/pokemon/swellow/back.4bpp.lz");
+const u32 gMonShinyPalette_Swellow[] = INCBIN_U32("graphics/pokemon/swellow/shiny.gbapal.lz");
+const u8 gMonIcon_Swellow[] = INCBIN_U8("graphics/pokemon/swellow/icon.4bpp");
+const u8 gMonFootprint_Swellow[] = INCBIN_U8("graphics/pokemon/swellow/footprint.1bpp");
+
+const u32 gMonFrontPic_Shroomish[] = INCBIN_U32("graphics/pokemon/shroomish/front.4bpp.lz");
+const u32 gMonPalette_Shroomish[] = INCBIN_U32("graphics/pokemon/shroomish/normal.gbapal.lz");
+const u32 gMonBackPic_Shroomish[] = INCBIN_U32("graphics/pokemon/shroomish/back.4bpp.lz");
+const u32 gMonShinyPalette_Shroomish[] = INCBIN_U32("graphics/pokemon/shroomish/shiny.gbapal.lz");
+const u8 gMonIcon_Shroomish[] = INCBIN_U8("graphics/pokemon/shroomish/icon.4bpp");
+const u8 gMonFootprint_Shroomish[] = INCBIN_U8("graphics/pokemon/shroomish/footprint.1bpp");
+
+const u32 gMonFrontPic_Breloom[] = INCBIN_U32("graphics/pokemon/breloom/front.4bpp.lz");
+const u32 gMonPalette_Breloom[] = INCBIN_U32("graphics/pokemon/breloom/normal.gbapal.lz");
+const u32 gMonBackPic_Breloom[] = INCBIN_U32("graphics/pokemon/breloom/back.4bpp.lz");
+const u32 gMonShinyPalette_Breloom[] = INCBIN_U32("graphics/pokemon/breloom/shiny.gbapal.lz");
+const u8 gMonIcon_Breloom[] = INCBIN_U8("graphics/pokemon/breloom/icon.4bpp");
+const u8 gMonFootprint_Breloom[] = INCBIN_U8("graphics/pokemon/breloom/footprint.1bpp");
+
+const u32 gMonFrontPic_Spinda[] = INCBIN_U32("graphics/pokemon/spinda/front.4bpp.lz");
+const u32 gMonPalette_Spinda[] = INCBIN_U32("graphics/pokemon/spinda/normal.gbapal.lz");
+const u32 gMonBackPic_Spinda[] = INCBIN_U32("graphics/pokemon/spinda/back.4bpp.lz");
+const u32 gMonShinyPalette_Spinda[] = INCBIN_U32("graphics/pokemon/spinda/shiny.gbapal.lz");
+const u8 gMonIcon_Spinda[] = INCBIN_U8("graphics/pokemon/spinda/icon.4bpp");
+const u8 gMonFootprint_Spinda[] = INCBIN_U8("graphics/pokemon/spinda/footprint.1bpp");
+
+const u32 gMonFrontPic_Wingull[] = INCBIN_U32("graphics/pokemon/wingull/front.4bpp.lz");
+const u32 gMonPalette_Wingull[] = INCBIN_U32("graphics/pokemon/wingull/normal.gbapal.lz");
+const u32 gMonBackPic_Wingull[] = INCBIN_U32("graphics/pokemon/wingull/back.4bpp.lz");
+const u32 gMonShinyPalette_Wingull[] = INCBIN_U32("graphics/pokemon/wingull/shiny.gbapal.lz");
+const u8 gMonIcon_Wingull[] = INCBIN_U8("graphics/pokemon/wingull/icon.4bpp");
+const u8 gMonFootprint_Wingull[] = INCBIN_U8("graphics/pokemon/wingull/footprint.1bpp");
+
+const u32 gMonFrontPic_Pelipper[] = INCBIN_U32("graphics/pokemon/pelipper/front.4bpp.lz");
+const u32 gMonPalette_Pelipper[] = INCBIN_U32("graphics/pokemon/pelipper/normal.gbapal.lz");
+const u32 gMonBackPic_Pelipper[] = INCBIN_U32("graphics/pokemon/pelipper/back.4bpp.lz");
+const u32 gMonShinyPalette_Pelipper[] = INCBIN_U32("graphics/pokemon/pelipper/shiny.gbapal.lz");
+const u8 gMonIcon_Pelipper[] = INCBIN_U8("graphics/pokemon/pelipper/icon.4bpp");
+const u8 gMonFootprint_Pelipper[] = INCBIN_U8("graphics/pokemon/pelipper/footprint.1bpp");
+
+const u32 gMonFrontPic_Surskit[] = INCBIN_U32("graphics/pokemon/surskit/front.4bpp.lz");
+const u32 gMonPalette_Surskit[] = INCBIN_U32("graphics/pokemon/surskit/normal.gbapal.lz");
+const u32 gMonBackPic_Surskit[] = INCBIN_U32("graphics/pokemon/surskit/back.4bpp.lz");
+const u32 gMonShinyPalette_Surskit[] = INCBIN_U32("graphics/pokemon/surskit/shiny.gbapal.lz");
+const u8 gMonIcon_Surskit[] = INCBIN_U8("graphics/pokemon/surskit/icon.4bpp");
+const u8 gMonFootprint_Surskit[] = INCBIN_U8("graphics/pokemon/surskit/footprint.1bpp");
+
+const u32 gMonFrontPic_Masquerain[] = INCBIN_U32("graphics/pokemon/masquerain/front.4bpp.lz");
+const u32 gMonPalette_Masquerain[] = INCBIN_U32("graphics/pokemon/masquerain/normal.gbapal.lz");
+const u32 gMonBackPic_Masquerain[] = INCBIN_U32("graphics/pokemon/masquerain/back.4bpp.lz");
+const u32 gMonShinyPalette_Masquerain[] = INCBIN_U32("graphics/pokemon/masquerain/shiny.gbapal.lz");
+const u8 gMonIcon_Masquerain[] = INCBIN_U8("graphics/pokemon/masquerain/icon.4bpp");
+const u8 gMonFootprint_Masquerain[] = INCBIN_U8("graphics/pokemon/masquerain/footprint.1bpp");
+
+const u32 gMonFrontPic_Wailmer[] = INCBIN_U32("graphics/pokemon/wailmer/front.4bpp.lz");
+const u32 gMonPalette_Wailmer[] = INCBIN_U32("graphics/pokemon/wailmer/normal.gbapal.lz");
+const u32 gMonBackPic_Wailmer[] = INCBIN_U32("graphics/pokemon/wailmer/back.4bpp.lz");
+const u32 gMonShinyPalette_Wailmer[] = INCBIN_U32("graphics/pokemon/wailmer/shiny.gbapal.lz");
+const u8 gMonIcon_Wailmer[] = INCBIN_U8("graphics/pokemon/wailmer/icon.4bpp");
+const u8 gMonFootprint_Wailmer[] = INCBIN_U8("graphics/pokemon/wailmer/footprint.1bpp");
+
+const u32 gMonFrontPic_Wailord[] = INCBIN_U32("graphics/pokemon/wailord/front.4bpp.lz");
+const u32 gMonPalette_Wailord[] = INCBIN_U32("graphics/pokemon/wailord/normal.gbapal.lz");
+const u32 gMonBackPic_Wailord[] = INCBIN_U32("graphics/pokemon/wailord/back.4bpp.lz");
+const u32 gMonShinyPalette_Wailord[] = INCBIN_U32("graphics/pokemon/wailord/shiny.gbapal.lz");
+const u8 gMonIcon_Wailord[] = INCBIN_U8("graphics/pokemon/wailord/icon.4bpp");
+const u8 gMonFootprint_Wailord[] = INCBIN_U8("graphics/pokemon/wailord/footprint.1bpp");
+
+const u32 gMonFrontPic_Skitty[] = INCBIN_U32("graphics/pokemon/skitty/front.4bpp.lz");
+const u32 gMonPalette_Skitty[] = INCBIN_U32("graphics/pokemon/skitty/normal.gbapal.lz");
+const u32 gMonBackPic_Skitty[] = INCBIN_U32("graphics/pokemon/skitty/back.4bpp.lz");
+const u32 gMonShinyPalette_Skitty[] = INCBIN_U32("graphics/pokemon/skitty/shiny.gbapal.lz");
+const u8 gMonIcon_Skitty[] = INCBIN_U8("graphics/pokemon/skitty/icon.4bpp");
+const u8 gMonFootprint_Skitty[] = INCBIN_U8("graphics/pokemon/skitty/footprint.1bpp");
+
+const u32 gMonFrontPic_Delcatty[] = INCBIN_U32("graphics/pokemon/delcatty/front.4bpp.lz");
+const u32 gMonPalette_Delcatty[] = INCBIN_U32("graphics/pokemon/delcatty/normal.gbapal.lz");
+const u32 gMonBackPic_Delcatty[] = INCBIN_U32("graphics/pokemon/delcatty/back.4bpp.lz");
+const u32 gMonShinyPalette_Delcatty[] = INCBIN_U32("graphics/pokemon/delcatty/shiny.gbapal.lz");
+const u8 gMonIcon_Delcatty[] = INCBIN_U8("graphics/pokemon/delcatty/icon.4bpp");
+const u8 gMonFootprint_Delcatty[] = INCBIN_U8("graphics/pokemon/delcatty/footprint.1bpp");
+
+const u32 gMonFrontPic_Kecleon[] = INCBIN_U32("graphics/pokemon/kecleon/front.4bpp.lz");
+const u32 gMonPalette_Kecleon[] = INCBIN_U32("graphics/pokemon/kecleon/normal.gbapal.lz");
+const u32 gMonBackPic_Kecleon[] = INCBIN_U32("graphics/pokemon/kecleon/back.4bpp.lz");
+const u32 gMonShinyPalette_Kecleon[] = INCBIN_U32("graphics/pokemon/kecleon/shiny.gbapal.lz");
+const u8 gMonIcon_Kecleon[] = INCBIN_U8("graphics/pokemon/kecleon/icon.4bpp");
+const u8 gMonFootprint_Kecleon[] = INCBIN_U8("graphics/pokemon/kecleon/footprint.1bpp");
+
+const u32 gMonFrontPic_Baltoy[] = INCBIN_U32("graphics/pokemon/baltoy/front.4bpp.lz");
+const u32 gMonPalette_Baltoy[] = INCBIN_U32("graphics/pokemon/baltoy/normal.gbapal.lz");
+const u32 gMonBackPic_Baltoy[] = INCBIN_U32("graphics/pokemon/baltoy/back.4bpp.lz");
+const u32 gMonShinyPalette_Baltoy[] = INCBIN_U32("graphics/pokemon/baltoy/shiny.gbapal.lz");
+const u8 gMonIcon_Baltoy[] = INCBIN_U8("graphics/pokemon/baltoy/icon.4bpp");
+const u8 gMonFootprint_Baltoy[] = INCBIN_U8("graphics/pokemon/baltoy/footprint.1bpp");
+
+const u32 gMonFrontPic_Claydol[] = INCBIN_U32("graphics/pokemon/claydol/front.4bpp.lz");
+const u32 gMonPalette_Claydol[] = INCBIN_U32("graphics/pokemon/claydol/normal.gbapal.lz");
+const u32 gMonBackPic_Claydol[] = INCBIN_U32("graphics/pokemon/claydol/back.4bpp.lz");
+const u32 gMonShinyPalette_Claydol[] = INCBIN_U32("graphics/pokemon/claydol/shiny.gbapal.lz");
+const u8 gMonIcon_Claydol[] = INCBIN_U8("graphics/pokemon/claydol/icon.4bpp");
+const u8 gMonFootprint_Claydol[] = INCBIN_U8("graphics/pokemon/claydol/footprint.1bpp");
+
+const u32 gMonFrontPic_Nosepass[] = INCBIN_U32("graphics/pokemon/nosepass/front.4bpp.lz");
+const u32 gMonPalette_Nosepass[] = INCBIN_U32("graphics/pokemon/nosepass/normal.gbapal.lz");
+const u32 gMonBackPic_Nosepass[] = INCBIN_U32("graphics/pokemon/nosepass/back.4bpp.lz");
+const u32 gMonShinyPalette_Nosepass[] = INCBIN_U32("graphics/pokemon/nosepass/shiny.gbapal.lz");
+const u8 gMonIcon_Nosepass[] = INCBIN_U8("graphics/pokemon/nosepass/icon.4bpp");
+const u8 gMonFootprint_Nosepass[] = INCBIN_U8("graphics/pokemon/nosepass/footprint.1bpp");
+
+const u32 gMonFrontPic_Torkoal[] = INCBIN_U32("graphics/pokemon/torkoal/front.4bpp.lz");
+const u32 gMonPalette_Torkoal[] = INCBIN_U32("graphics/pokemon/torkoal/normal.gbapal.lz");
+const u32 gMonBackPic_Torkoal[] = INCBIN_U32("graphics/pokemon/torkoal/back.4bpp.lz");
+const u32 gMonShinyPalette_Torkoal[] = INCBIN_U32("graphics/pokemon/torkoal/shiny.gbapal.lz");
+const u8 gMonIcon_Torkoal[] = INCBIN_U8("graphics/pokemon/torkoal/icon.4bpp");
+const u8 gMonFootprint_Torkoal[] = INCBIN_U8("graphics/pokemon/torkoal/footprint.1bpp");
+
+const u32 gMonFrontPic_Sableye[] = INCBIN_U32("graphics/pokemon/sableye/front.4bpp.lz");
+const u32 gMonPalette_Sableye[] = INCBIN_U32("graphics/pokemon/sableye/normal.gbapal.lz");
+const u32 gMonBackPic_Sableye[] = INCBIN_U32("graphics/pokemon/sableye/back.4bpp.lz");
+const u32 gMonShinyPalette_Sableye[] = INCBIN_U32("graphics/pokemon/sableye/shiny.gbapal.lz");
+const u8 gMonIcon_Sableye[] = INCBIN_U8("graphics/pokemon/sableye/icon.4bpp");
+const u8 gMonFootprint_Sableye[] = INCBIN_U8("graphics/pokemon/sableye/footprint.1bpp");
+
+const u32 gMonFrontPic_Barboach[] = INCBIN_U32("graphics/pokemon/barboach/front.4bpp.lz");
+const u32 gMonPalette_Barboach[] = INCBIN_U32("graphics/pokemon/barboach/normal.gbapal.lz");
+const u32 gMonBackPic_Barboach[] = INCBIN_U32("graphics/pokemon/barboach/back.4bpp.lz");
+const u32 gMonShinyPalette_Barboach[] = INCBIN_U32("graphics/pokemon/barboach/shiny.gbapal.lz");
+const u8 gMonIcon_Barboach[] = INCBIN_U8("graphics/pokemon/barboach/icon.4bpp");
+const u8 gMonFootprint_Barboach[] = INCBIN_U8("graphics/pokemon/barboach/footprint.1bpp");
+
+const u32 gMonFrontPic_Whiscash[] = INCBIN_U32("graphics/pokemon/whiscash/front.4bpp.lz");
+const u32 gMonPalette_Whiscash[] = INCBIN_U32("graphics/pokemon/whiscash/normal.gbapal.lz");
+const u32 gMonBackPic_Whiscash[] = INCBIN_U32("graphics/pokemon/whiscash/back.4bpp.lz");
+const u32 gMonShinyPalette_Whiscash[] = INCBIN_U32("graphics/pokemon/whiscash/shiny.gbapal.lz");
+const u8 gMonIcon_Whiscash[] = INCBIN_U8("graphics/pokemon/whiscash/icon.4bpp");
+const u8 gMonFootprint_Whiscash[] = INCBIN_U8("graphics/pokemon/whiscash/footprint.1bpp");
+
+const u32 gMonFrontPic_Luvdisc[] = INCBIN_U32("graphics/pokemon/luvdisc/front.4bpp.lz");
+const u32 gMonPalette_Luvdisc[] = INCBIN_U32("graphics/pokemon/luvdisc/normal.gbapal.lz");
+const u32 gMonBackPic_Luvdisc[] = INCBIN_U32("graphics/pokemon/luvdisc/back.4bpp.lz");
+const u32 gMonShinyPalette_Luvdisc[] = INCBIN_U32("graphics/pokemon/luvdisc/shiny.gbapal.lz");
+const u8 gMonIcon_Luvdisc[] = INCBIN_U8("graphics/pokemon/luvdisc/icon.4bpp");
+const u8 gMonFootprint_Luvdisc[] = INCBIN_U8("graphics/pokemon/luvdisc/footprint.1bpp");
+
+const u32 gMonFrontPic_Corphish[] = INCBIN_U32("graphics/pokemon/corphish/front.4bpp.lz");
+const u32 gMonPalette_Corphish[] = INCBIN_U32("graphics/pokemon/corphish/normal.gbapal.lz");
+const u32 gMonBackPic_Corphish[] = INCBIN_U32("graphics/pokemon/corphish/back.4bpp.lz");
+const u32 gMonShinyPalette_Corphish[] = INCBIN_U32("graphics/pokemon/corphish/shiny.gbapal.lz");
+const u8 gMonIcon_Corphish[] = INCBIN_U8("graphics/pokemon/corphish/icon.4bpp");
+const u8 gMonFootprint_Corphish[] = INCBIN_U8("graphics/pokemon/corphish/footprint.1bpp");
+
+const u32 gMonFrontPic_Crawdaunt[] = INCBIN_U32("graphics/pokemon/crawdaunt/front.4bpp.lz");
+const u32 gMonPalette_Crawdaunt[] = INCBIN_U32("graphics/pokemon/crawdaunt/normal.gbapal.lz");
+const u32 gMonBackPic_Crawdaunt[] = INCBIN_U32("graphics/pokemon/crawdaunt/back.4bpp.lz");
+const u32 gMonShinyPalette_Crawdaunt[] = INCBIN_U32("graphics/pokemon/crawdaunt/shiny.gbapal.lz");
+const u8 gMonIcon_Crawdaunt[] = INCBIN_U8("graphics/pokemon/crawdaunt/icon.4bpp");
+const u8 gMonFootprint_Crawdaunt[] = INCBIN_U8("graphics/pokemon/crawdaunt/footprint.1bpp");
+
+const u32 gMonFrontPic_Feebas[] = INCBIN_U32("graphics/pokemon/feebas/front.4bpp.lz");
+const u32 gMonPalette_Feebas[] = INCBIN_U32("graphics/pokemon/feebas/normal.gbapal.lz");
+const u32 gMonBackPic_Feebas[] = INCBIN_U32("graphics/pokemon/feebas/back.4bpp.lz");
+const u32 gMonShinyPalette_Feebas[] = INCBIN_U32("graphics/pokemon/feebas/shiny.gbapal.lz");
+const u8 gMonIcon_Feebas[] = INCBIN_U8("graphics/pokemon/feebas/icon.4bpp");
+const u8 gMonFootprint_Feebas[] = INCBIN_U8("graphics/pokemon/feebas/footprint.1bpp");
+
+const u32 gMonFrontPic_Milotic[] = INCBIN_U32("graphics/pokemon/milotic/front.4bpp.lz");
+const u32 gMonPalette_Milotic[] = INCBIN_U32("graphics/pokemon/milotic/normal.gbapal.lz");
+const u32 gMonBackPic_Milotic[] = INCBIN_U32("graphics/pokemon/milotic/back.4bpp.lz");
+const u32 gMonShinyPalette_Milotic[] = INCBIN_U32("graphics/pokemon/milotic/shiny.gbapal.lz");
+const u8 gMonIcon_Milotic[] = INCBIN_U8("graphics/pokemon/milotic/icon.4bpp");
+const u8 gMonFootprint_Milotic[] = INCBIN_U8("graphics/pokemon/milotic/footprint.1bpp");
+
+const u32 gMonFrontPic_Carvanha[] = INCBIN_U32("graphics/pokemon/carvanha/front.4bpp.lz");
+const u32 gMonPalette_Carvanha[] = INCBIN_U32("graphics/pokemon/carvanha/normal.gbapal.lz");
+const u32 gMonBackPic_Carvanha[] = INCBIN_U32("graphics/pokemon/carvanha/back.4bpp.lz");
+const u32 gMonShinyPalette_Carvanha[] = INCBIN_U32("graphics/pokemon/carvanha/shiny.gbapal.lz");
+const u8 gMonIcon_Carvanha[] = INCBIN_U8("graphics/pokemon/carvanha/icon.4bpp");
+const u8 gMonFootprint_Carvanha[] = INCBIN_U8("graphics/pokemon/carvanha/footprint.1bpp");
+
+const u32 gMonFrontPic_Sharpedo[] = INCBIN_U32("graphics/pokemon/sharpedo/front.4bpp.lz");
+const u32 gMonPalette_Sharpedo[] = INCBIN_U32("graphics/pokemon/sharpedo/normal.gbapal.lz");
+const u32 gMonBackPic_Sharpedo[] = INCBIN_U32("graphics/pokemon/sharpedo/back.4bpp.lz");
+const u32 gMonShinyPalette_Sharpedo[] = INCBIN_U32("graphics/pokemon/sharpedo/shiny.gbapal.lz");
+const u8 gMonIcon_Sharpedo[] = INCBIN_U8("graphics/pokemon/sharpedo/icon.4bpp");
+const u8 gMonFootprint_Sharpedo[] = INCBIN_U8("graphics/pokemon/sharpedo/footprint.1bpp");
+
+const u32 gMonFrontPic_Trapinch[] = INCBIN_U32("graphics/pokemon/trapinch/front.4bpp.lz");
+const u32 gMonPalette_Trapinch[] = INCBIN_U32("graphics/pokemon/trapinch/normal.gbapal.lz");
+const u32 gMonBackPic_Trapinch[] = INCBIN_U32("graphics/pokemon/trapinch/back.4bpp.lz");
+const u32 gMonShinyPalette_Trapinch[] = INCBIN_U32("graphics/pokemon/trapinch/shiny.gbapal.lz");
+const u8 gMonIcon_Trapinch[] = INCBIN_U8("graphics/pokemon/trapinch/icon.4bpp");
+const u8 gMonFootprint_Trapinch[] = INCBIN_U8("graphics/pokemon/trapinch/footprint.1bpp");
+
+const u32 gMonFrontPic_Vibrava[] = INCBIN_U32("graphics/pokemon/vibrava/front.4bpp.lz");
+const u32 gMonPalette_Vibrava[] = INCBIN_U32("graphics/pokemon/vibrava/normal.gbapal.lz");
+const u32 gMonBackPic_Vibrava[] = INCBIN_U32("graphics/pokemon/vibrava/back.4bpp.lz");
+const u32 gMonShinyPalette_Vibrava[] = INCBIN_U32("graphics/pokemon/vibrava/shiny.gbapal.lz");
+const u8 gMonIcon_Vibrava[] = INCBIN_U8("graphics/pokemon/vibrava/icon.4bpp");
+const u8 gMonFootprint_Vibrava[] = INCBIN_U8("graphics/pokemon/vibrava/footprint.1bpp");
+
+const u32 gMonFrontPic_Flygon[] = INCBIN_U32("graphics/pokemon/flygon/front.4bpp.lz");
+const u32 gMonPalette_Flygon[] = INCBIN_U32("graphics/pokemon/flygon/normal.gbapal.lz");
+const u32 gMonBackPic_Flygon[] = INCBIN_U32("graphics/pokemon/flygon/back.4bpp.lz");
+const u32 gMonShinyPalette_Flygon[] = INCBIN_U32("graphics/pokemon/flygon/shiny.gbapal.lz");
+const u8 gMonIcon_Flygon[] = INCBIN_U8("graphics/pokemon/flygon/icon.4bpp");
+const u8 gMonFootprint_Flygon[] = INCBIN_U8("graphics/pokemon/flygon/footprint.1bpp");
+
+const u32 gMonFrontPic_Makuhita[] = INCBIN_U32("graphics/pokemon/makuhita/front.4bpp.lz");
+const u32 gMonPalette_Makuhita[] = INCBIN_U32("graphics/pokemon/makuhita/normal.gbapal.lz");
+const u32 gMonBackPic_Makuhita[] = INCBIN_U32("graphics/pokemon/makuhita/back.4bpp.lz");
+const u32 gMonShinyPalette_Makuhita[] = INCBIN_U32("graphics/pokemon/makuhita/shiny.gbapal.lz");
+const u8 gMonIcon_Makuhita[] = INCBIN_U8("graphics/pokemon/makuhita/icon.4bpp");
+const u8 gMonFootprint_Makuhita[] = INCBIN_U8("graphics/pokemon/makuhita/footprint.1bpp");
+
+const u32 gMonFrontPic_Hariyama[] = INCBIN_U32("graphics/pokemon/hariyama/front.4bpp.lz");
+const u32 gMonPalette_Hariyama[] = INCBIN_U32("graphics/pokemon/hariyama/normal.gbapal.lz");
+const u32 gMonBackPic_Hariyama[] = INCBIN_U32("graphics/pokemon/hariyama/back.4bpp.lz");
+const u32 gMonShinyPalette_Hariyama[] = INCBIN_U32("graphics/pokemon/hariyama/shiny.gbapal.lz");
+const u8 gMonIcon_Hariyama[] = INCBIN_U8("graphics/pokemon/hariyama/icon.4bpp");
+const u8 gMonFootprint_Hariyama[] = INCBIN_U8("graphics/pokemon/hariyama/footprint.1bpp");
+
+const u32 gMonFrontPic_Electrike[] = INCBIN_U32("graphics/pokemon/electrike/front.4bpp.lz");
+const u32 gMonPalette_Electrike[] = INCBIN_U32("graphics/pokemon/electrike/normal.gbapal.lz");
+const u32 gMonBackPic_Electrike[] = INCBIN_U32("graphics/pokemon/electrike/back.4bpp.lz");
+const u32 gMonShinyPalette_Electrike[] = INCBIN_U32("graphics/pokemon/electrike/shiny.gbapal.lz");
+const u8 gMonIcon_Electrike[] = INCBIN_U8("graphics/pokemon/electrike/icon.4bpp");
+const u8 gMonFootprint_Electrike[] = INCBIN_U8("graphics/pokemon/electrike/footprint.1bpp");
+
+const u32 gMonFrontPic_Manectric[] = INCBIN_U32("graphics/pokemon/manectric/front.4bpp.lz");
+const u32 gMonPalette_Manectric[] = INCBIN_U32("graphics/pokemon/manectric/normal.gbapal.lz");
+const u32 gMonBackPic_Manectric[] = INCBIN_U32("graphics/pokemon/manectric/back.4bpp.lz");
+const u32 gMonShinyPalette_Manectric[] = INCBIN_U32("graphics/pokemon/manectric/shiny.gbapal.lz");
+const u8 gMonIcon_Manectric[] = INCBIN_U8("graphics/pokemon/manectric/icon.4bpp");
+const u8 gMonFootprint_Manectric[] = INCBIN_U8("graphics/pokemon/manectric/footprint.1bpp");
+
+const u32 gMonFrontPic_Numel[] = INCBIN_U32("graphics/pokemon/numel/front.4bpp.lz");
+const u32 gMonPalette_Numel[] = INCBIN_U32("graphics/pokemon/numel/normal.gbapal.lz");
+const u32 gMonBackPic_Numel[] = INCBIN_U32("graphics/pokemon/numel/back.4bpp.lz");
+const u32 gMonShinyPalette_Numel[] = INCBIN_U32("graphics/pokemon/numel/shiny.gbapal.lz");
+const u8 gMonIcon_Numel[] = INCBIN_U8("graphics/pokemon/numel/icon.4bpp");
+const u8 gMonFootprint_Numel[] = INCBIN_U8("graphics/pokemon/numel/footprint.1bpp");
+
+const u32 gMonFrontPic_Camerupt[] = INCBIN_U32("graphics/pokemon/camerupt/front.4bpp.lz");
+const u32 gMonPalette_Camerupt[] = INCBIN_U32("graphics/pokemon/camerupt/normal.gbapal.lz");
+const u32 gMonBackPic_Camerupt[] = INCBIN_U32("graphics/pokemon/camerupt/back.4bpp.lz");
+const u32 gMonShinyPalette_Camerupt[] = INCBIN_U32("graphics/pokemon/camerupt/shiny.gbapal.lz");
+const u8 gMonIcon_Camerupt[] = INCBIN_U8("graphics/pokemon/camerupt/icon.4bpp");
+const u8 gMonFootprint_Camerupt[] = INCBIN_U8("graphics/pokemon/camerupt/footprint.1bpp");
+
+const u32 gMonFrontPic_Spheal[] = INCBIN_U32("graphics/pokemon/spheal/front.4bpp.lz");
+const u32 gMonPalette_Spheal[] = INCBIN_U32("graphics/pokemon/spheal/normal.gbapal.lz");
+const u32 gMonBackPic_Spheal[] = INCBIN_U32("graphics/pokemon/spheal/back.4bpp.lz");
+const u32 gMonShinyPalette_Spheal[] = INCBIN_U32("graphics/pokemon/spheal/shiny.gbapal.lz");
+const u8 gMonIcon_Spheal[] = INCBIN_U8("graphics/pokemon/spheal/icon.4bpp");
+const u8 gMonFootprint_Spheal[] = INCBIN_U8("graphics/pokemon/spheal/footprint.1bpp");
+
+const u32 gMonFrontPic_Sealeo[] = INCBIN_U32("graphics/pokemon/sealeo/front.4bpp.lz");
+const u32 gMonPalette_Sealeo[] = INCBIN_U32("graphics/pokemon/sealeo/normal.gbapal.lz");
+const u32 gMonBackPic_Sealeo[] = INCBIN_U32("graphics/pokemon/sealeo/back.4bpp.lz");
+const u32 gMonShinyPalette_Sealeo[] = INCBIN_U32("graphics/pokemon/sealeo/shiny.gbapal.lz");
+const u8 gMonIcon_Sealeo[] = INCBIN_U8("graphics/pokemon/sealeo/icon.4bpp");
+const u8 gMonFootprint_Sealeo[] = INCBIN_U8("graphics/pokemon/sealeo/footprint.1bpp");
+
+const u32 gMonFrontPic_Walrein[] = INCBIN_U32("graphics/pokemon/walrein/front.4bpp.lz");
+const u32 gMonPalette_Walrein[] = INCBIN_U32("graphics/pokemon/walrein/normal.gbapal.lz");
+const u32 gMonBackPic_Walrein[] = INCBIN_U32("graphics/pokemon/walrein/back.4bpp.lz");
+const u32 gMonShinyPalette_Walrein[] = INCBIN_U32("graphics/pokemon/walrein/shiny.gbapal.lz");
+const u8 gMonIcon_Walrein[] = INCBIN_U8("graphics/pokemon/walrein/icon.4bpp");
+const u8 gMonFootprint_Walrein[] = INCBIN_U8("graphics/pokemon/walrein/footprint.1bpp");
+
+const u32 gMonFrontPic_Cacnea[] = INCBIN_U32("graphics/pokemon/cacnea/front.4bpp.lz");
+const u32 gMonPalette_Cacnea[] = INCBIN_U32("graphics/pokemon/cacnea/normal.gbapal.lz");
+const u32 gMonBackPic_Cacnea[] = INCBIN_U32("graphics/pokemon/cacnea/back.4bpp.lz");
+const u32 gMonShinyPalette_Cacnea[] = INCBIN_U32("graphics/pokemon/cacnea/shiny.gbapal.lz");
+const u8 gMonIcon_Cacnea[] = INCBIN_U8("graphics/pokemon/cacnea/icon.4bpp");
+const u8 gMonFootprint_Cacnea[] = INCBIN_U8("graphics/pokemon/cacnea/footprint.1bpp");
+
+const u32 gMonFrontPic_Cacturne[] = INCBIN_U32("graphics/pokemon/cacturne/front.4bpp.lz");
+const u32 gMonPalette_Cacturne[] = INCBIN_U32("graphics/pokemon/cacturne/normal.gbapal.lz");
+const u32 gMonBackPic_Cacturne[] = INCBIN_U32("graphics/pokemon/cacturne/back.4bpp.lz");
+const u32 gMonShinyPalette_Cacturne[] = INCBIN_U32("graphics/pokemon/cacturne/shiny.gbapal.lz");
+const u8 gMonIcon_Cacturne[] = INCBIN_U8("graphics/pokemon/cacturne/icon.4bpp");
+const u8 gMonFootprint_Cacturne[] = INCBIN_U8("graphics/pokemon/cacturne/footprint.1bpp");
+
+const u32 gMonFrontPic_Snorunt[] = INCBIN_U32("graphics/pokemon/snorunt/front.4bpp.lz");
+const u32 gMonPalette_Snorunt[] = INCBIN_U32("graphics/pokemon/snorunt/normal.gbapal.lz");
+const u32 gMonBackPic_Snorunt[] = INCBIN_U32("graphics/pokemon/snorunt/back.4bpp.lz");
+const u32 gMonShinyPalette_Snorunt[] = INCBIN_U32("graphics/pokemon/snorunt/shiny.gbapal.lz");
+const u8 gMonIcon_Snorunt[] = INCBIN_U8("graphics/pokemon/snorunt/icon.4bpp");
+const u8 gMonFootprint_Snorunt[] = INCBIN_U8("graphics/pokemon/snorunt/footprint.1bpp");
+
+const u32 gMonFrontPic_Glalie[] = INCBIN_U32("graphics/pokemon/glalie/front.4bpp.lz");
+const u32 gMonPalette_Glalie[] = INCBIN_U32("graphics/pokemon/glalie/normal.gbapal.lz");
+const u32 gMonBackPic_Glalie[] = INCBIN_U32("graphics/pokemon/glalie/back.4bpp.lz");
+const u32 gMonShinyPalette_Glalie[] = INCBIN_U32("graphics/pokemon/glalie/shiny.gbapal.lz");
+const u8 gMonIcon_Glalie[] = INCBIN_U8("graphics/pokemon/glalie/icon.4bpp");
+const u8 gMonFootprint_Glalie[] = INCBIN_U8("graphics/pokemon/glalie/footprint.1bpp");
+
+const u32 gMonFrontPic_Lunatone[] = INCBIN_U32("graphics/pokemon/lunatone/front.4bpp.lz");
+const u32 gMonPalette_Lunatone[] = INCBIN_U32("graphics/pokemon/lunatone/normal.gbapal.lz");
+const u32 gMonBackPic_Lunatone[] = INCBIN_U32("graphics/pokemon/lunatone/back.4bpp.lz");
+const u32 gMonShinyPalette_Lunatone[] = INCBIN_U32("graphics/pokemon/lunatone/shiny.gbapal.lz");
+const u8 gMonIcon_Lunatone[] = INCBIN_U8("graphics/pokemon/lunatone/icon.4bpp");
+const u8 gMonFootprint_Lunatone[] = INCBIN_U8("graphics/pokemon/lunatone/footprint.1bpp");
+
+const u32 gMonFrontPic_Solrock[] = INCBIN_U32("graphics/pokemon/solrock/front.4bpp.lz");
+const u32 gMonPalette_Solrock[] = INCBIN_U32("graphics/pokemon/solrock/normal.gbapal.lz");
+const u32 gMonBackPic_Solrock[] = INCBIN_U32("graphics/pokemon/solrock/back.4bpp.lz");
+const u32 gMonShinyPalette_Solrock[] = INCBIN_U32("graphics/pokemon/solrock/shiny.gbapal.lz");
+const u8 gMonIcon_Solrock[] = INCBIN_U8("graphics/pokemon/solrock/icon.4bpp");
+const u8 gMonFootprint_Solrock[] = INCBIN_U8("graphics/pokemon/solrock/footprint.1bpp");
+
+const u32 gMonFrontPic_Azurill[] = INCBIN_U32("graphics/pokemon/azurill/front.4bpp.lz");
+const u32 gMonPalette_Azurill[] = INCBIN_U32("graphics/pokemon/azurill/normal.gbapal.lz");
+const u32 gMonBackPic_Azurill[] = INCBIN_U32("graphics/pokemon/azurill/back.4bpp.lz");
+const u32 gMonShinyPalette_Azurill[] = INCBIN_U32("graphics/pokemon/azurill/shiny.gbapal.lz");
+const u8 gMonIcon_Azurill[] = INCBIN_U8("graphics/pokemon/azurill/icon.4bpp");
+const u8 gMonFootprint_Azurill[] = INCBIN_U8("graphics/pokemon/azurill/footprint.1bpp");
+
+const u32 gMonFrontPic_Spoink[] = INCBIN_U32("graphics/pokemon/spoink/front.4bpp.lz");
+const u32 gMonPalette_Spoink[] = INCBIN_U32("graphics/pokemon/spoink/normal.gbapal.lz");
+const u32 gMonBackPic_Spoink[] = INCBIN_U32("graphics/pokemon/spoink/back.4bpp.lz");
+const u32 gMonShinyPalette_Spoink[] = INCBIN_U32("graphics/pokemon/spoink/shiny.gbapal.lz");
+const u8 gMonIcon_Spoink[] = INCBIN_U8("graphics/pokemon/spoink/icon.4bpp");
+const u8 gMonFootprint_Spoink[] = INCBIN_U8("graphics/pokemon/spoink/footprint.1bpp");
+
+const u32 gMonFrontPic_Grumpig[] = INCBIN_U32("graphics/pokemon/grumpig/front.4bpp.lz");
+const u32 gMonPalette_Grumpig[] = INCBIN_U32("graphics/pokemon/grumpig/normal.gbapal.lz");
+const u32 gMonBackPic_Grumpig[] = INCBIN_U32("graphics/pokemon/grumpig/back.4bpp.lz");
+const u32 gMonShinyPalette_Grumpig[] = INCBIN_U32("graphics/pokemon/grumpig/shiny.gbapal.lz");
+const u8 gMonIcon_Grumpig[] = INCBIN_U8("graphics/pokemon/grumpig/icon.4bpp");
+const u8 gMonFootprint_Grumpig[] = INCBIN_U8("graphics/pokemon/grumpig/footprint.1bpp");
+
+const u32 gMonFrontPic_Plusle[] = INCBIN_U32("graphics/pokemon/plusle/front.4bpp.lz");
+const u32 gMonPalette_Plusle[] = INCBIN_U32("graphics/pokemon/plusle/normal.gbapal.lz");
+const u32 gMonBackPic_Plusle[] = INCBIN_U32("graphics/pokemon/plusle/back.4bpp.lz");
+const u32 gMonShinyPalette_Plusle[] = INCBIN_U32("graphics/pokemon/plusle/shiny.gbapal.lz");
+const u8 gMonIcon_Plusle[] = INCBIN_U8("graphics/pokemon/plusle/icon.4bpp");
+const u8 gMonFootprint_Plusle[] = INCBIN_U8("graphics/pokemon/plusle/footprint.1bpp");
+
+const u32 gMonFrontPic_Minun[] = INCBIN_U32("graphics/pokemon/minun/front.4bpp.lz");
+const u32 gMonPalette_Minun[] = INCBIN_U32("graphics/pokemon/minun/normal.gbapal.lz");
+const u32 gMonBackPic_Minun[] = INCBIN_U32("graphics/pokemon/minun/back.4bpp.lz");
+const u32 gMonShinyPalette_Minun[] = INCBIN_U32("graphics/pokemon/minun/shiny.gbapal.lz");
+const u8 gMonIcon_Minun[] = INCBIN_U8("graphics/pokemon/minun/icon.4bpp");
+const u8 gMonFootprint_Minun[] = INCBIN_U8("graphics/pokemon/minun/footprint.1bpp");
+
+const u32 gMonFrontPic_Mawile[] = INCBIN_U32("graphics/pokemon/mawile/front.4bpp.lz");
+const u32 gMonPalette_Mawile[] = INCBIN_U32("graphics/pokemon/mawile/normal.gbapal.lz");
+const u32 gMonBackPic_Mawile[] = INCBIN_U32("graphics/pokemon/mawile/back.4bpp.lz");
+const u32 gMonShinyPalette_Mawile[] = INCBIN_U32("graphics/pokemon/mawile/shiny.gbapal.lz");
+const u8 gMonIcon_Mawile[] = INCBIN_U8("graphics/pokemon/mawile/icon.4bpp");
+const u8 gMonFootprint_Mawile[] = INCBIN_U8("graphics/pokemon/mawile/footprint.1bpp");
+
+const u32 gMonFrontPic_Meditite[] = INCBIN_U32("graphics/pokemon/meditite/front.4bpp.lz");
+const u32 gMonPalette_Meditite[] = INCBIN_U32("graphics/pokemon/meditite/normal.gbapal.lz");
+const u32 gMonBackPic_Meditite[] = INCBIN_U32("graphics/pokemon/meditite/back.4bpp.lz");
+const u32 gMonShinyPalette_Meditite[] = INCBIN_U32("graphics/pokemon/meditite/shiny.gbapal.lz");
+const u8 gMonIcon_Meditite[] = INCBIN_U8("graphics/pokemon/meditite/icon.4bpp");
+const u8 gMonFootprint_Meditite[] = INCBIN_U8("graphics/pokemon/meditite/footprint.1bpp");
+
+const u32 gMonFrontPic_Medicham[] = INCBIN_U32("graphics/pokemon/medicham/front.4bpp.lz");
+const u32 gMonPalette_Medicham[] = INCBIN_U32("graphics/pokemon/medicham/normal.gbapal.lz");
+const u32 gMonBackPic_Medicham[] = INCBIN_U32("graphics/pokemon/medicham/back.4bpp.lz");
+const u32 gMonShinyPalette_Medicham[] = INCBIN_U32("graphics/pokemon/medicham/shiny.gbapal.lz");
+const u8 gMonIcon_Medicham[] = INCBIN_U8("graphics/pokemon/medicham/icon.4bpp");
+const u8 gMonFootprint_Medicham[] = INCBIN_U8("graphics/pokemon/medicham/footprint.1bpp");
+
+const u32 gMonFrontPic_Swablu[] = INCBIN_U32("graphics/pokemon/swablu/front.4bpp.lz");
+const u32 gMonPalette_Swablu[] = INCBIN_U32("graphics/pokemon/swablu/normal.gbapal.lz");
+const u32 gMonBackPic_Swablu[] = INCBIN_U32("graphics/pokemon/swablu/back.4bpp.lz");
+const u32 gMonShinyPalette_Swablu[] = INCBIN_U32("graphics/pokemon/swablu/shiny.gbapal.lz");
+const u8 gMonIcon_Swablu[] = INCBIN_U8("graphics/pokemon/swablu/icon.4bpp");
+const u8 gMonFootprint_Swablu[] = INCBIN_U8("graphics/pokemon/swablu/footprint.1bpp");
+
+const u32 gMonFrontPic_Altaria[] = INCBIN_U32("graphics/pokemon/altaria/front.4bpp.lz");
+const u32 gMonPalette_Altaria[] = INCBIN_U32("graphics/pokemon/altaria/normal.gbapal.lz");
+const u32 gMonBackPic_Altaria[] = INCBIN_U32("graphics/pokemon/altaria/back.4bpp.lz");
+const u32 gMonShinyPalette_Altaria[] = INCBIN_U32("graphics/pokemon/altaria/shiny.gbapal.lz");
+const u8 gMonIcon_Altaria[] = INCBIN_U8("graphics/pokemon/altaria/icon.4bpp");
+const u8 gMonFootprint_Altaria[] = INCBIN_U8("graphics/pokemon/altaria/footprint.1bpp");
+
+const u32 gMonFrontPic_Wynaut[] = INCBIN_U32("graphics/pokemon/wynaut/front.4bpp.lz");
+const u32 gMonPalette_Wynaut[] = INCBIN_U32("graphics/pokemon/wynaut/normal.gbapal.lz");
+const u32 gMonBackPic_Wynaut[] = INCBIN_U32("graphics/pokemon/wynaut/back.4bpp.lz");
+const u32 gMonShinyPalette_Wynaut[] = INCBIN_U32("graphics/pokemon/wynaut/shiny.gbapal.lz");
+const u8 gMonIcon_Wynaut[] = INCBIN_U8("graphics/pokemon/wynaut/icon.4bpp");
+const u8 gMonFootprint_Wynaut[] = INCBIN_U8("graphics/pokemon/wynaut/footprint.1bpp");
+
+const u32 gMonFrontPic_Duskull[] = INCBIN_U32("graphics/pokemon/duskull/front.4bpp.lz");
+const u32 gMonPalette_Duskull[] = INCBIN_U32("graphics/pokemon/duskull/normal.gbapal.lz");
+const u32 gMonBackPic_Duskull[] = INCBIN_U32("graphics/pokemon/duskull/back.4bpp.lz");
+const u32 gMonShinyPalette_Duskull[] = INCBIN_U32("graphics/pokemon/duskull/shiny.gbapal.lz");
+const u8 gMonIcon_Duskull[] = INCBIN_U8("graphics/pokemon/duskull/icon.4bpp");
+const u8 gMonFootprint_Duskull[] = INCBIN_U8("graphics/pokemon/duskull/footprint.1bpp");
+
+const u32 gMonFrontPic_Dusclops[] = INCBIN_U32("graphics/pokemon/dusclops/front.4bpp.lz");
+const u32 gMonPalette_Dusclops[] = INCBIN_U32("graphics/pokemon/dusclops/normal.gbapal.lz");
+const u32 gMonBackPic_Dusclops[] = INCBIN_U32("graphics/pokemon/dusclops/back.4bpp.lz");
+const u32 gMonShinyPalette_Dusclops[] = INCBIN_U32("graphics/pokemon/dusclops/shiny.gbapal.lz");
+const u8 gMonIcon_Dusclops[] = INCBIN_U8("graphics/pokemon/dusclops/icon.4bpp");
+const u8 gMonFootprint_Dusclops[] = INCBIN_U8("graphics/pokemon/dusclops/footprint.1bpp");
+
+const u32 gMonFrontPic_Roselia[] = INCBIN_U32("graphics/pokemon/roselia/front.4bpp.lz");
+const u32 gMonPalette_Roselia[] = INCBIN_U32("graphics/pokemon/roselia/normal.gbapal.lz");
+const u32 gMonBackPic_Roselia[] = INCBIN_U32("graphics/pokemon/roselia/back.4bpp.lz");
+const u32 gMonShinyPalette_Roselia[] = INCBIN_U32("graphics/pokemon/roselia/shiny.gbapal.lz");
+const u8 gMonIcon_Roselia[] = INCBIN_U8("graphics/pokemon/roselia/icon.4bpp");
+const u8 gMonFootprint_Roselia[] = INCBIN_U8("graphics/pokemon/roselia/footprint.1bpp");
+
+const u32 gMonFrontPic_Slakoth[] = INCBIN_U32("graphics/pokemon/slakoth/front.4bpp.lz");
+const u32 gMonPalette_Slakoth[] = INCBIN_U32("graphics/pokemon/slakoth/normal.gbapal.lz");
+const u32 gMonBackPic_Slakoth[] = INCBIN_U32("graphics/pokemon/slakoth/back.4bpp.lz");
+const u32 gMonShinyPalette_Slakoth[] = INCBIN_U32("graphics/pokemon/slakoth/shiny.gbapal.lz");
+const u8 gMonIcon_Slakoth[] = INCBIN_U8("graphics/pokemon/slakoth/icon.4bpp");
+const u8 gMonFootprint_Slakoth[] = INCBIN_U8("graphics/pokemon/slakoth/footprint.1bpp");
+
+const u32 gMonFrontPic_Vigoroth[] = INCBIN_U32("graphics/pokemon/vigoroth/front.4bpp.lz");
+const u32 gMonPalette_Vigoroth[] = INCBIN_U32("graphics/pokemon/vigoroth/normal.gbapal.lz");
+const u32 gMonBackPic_Vigoroth[] = INCBIN_U32("graphics/pokemon/vigoroth/back.4bpp.lz");
+const u32 gMonShinyPalette_Vigoroth[] = INCBIN_U32("graphics/pokemon/vigoroth/shiny.gbapal.lz");
+const u8 gMonIcon_Vigoroth[] = INCBIN_U8("graphics/pokemon/vigoroth/icon.4bpp");
+const u8 gMonFootprint_Vigoroth[] = INCBIN_U8("graphics/pokemon/vigoroth/footprint.1bpp");
+
+const u32 gMonFrontPic_Slaking[] = INCBIN_U32("graphics/pokemon/slaking/front.4bpp.lz");
+const u32 gMonPalette_Slaking[] = INCBIN_U32("graphics/pokemon/slaking/normal.gbapal.lz");
+const u32 gMonBackPic_Slaking[] = INCBIN_U32("graphics/pokemon/slaking/back.4bpp.lz");
+const u32 gMonShinyPalette_Slaking[] = INCBIN_U32("graphics/pokemon/slaking/shiny.gbapal.lz");
+const u8 gMonIcon_Slaking[] = INCBIN_U8("graphics/pokemon/slaking/icon.4bpp");
+const u8 gMonFootprint_Slaking[] = INCBIN_U8("graphics/pokemon/slaking/footprint.1bpp");
+
+const u32 gMonFrontPic_Gulpin[] = INCBIN_U32("graphics/pokemon/gulpin/front.4bpp.lz");
+const u32 gMonPalette_Gulpin[] = INCBIN_U32("graphics/pokemon/gulpin/normal.gbapal.lz");
+const u32 gMonBackPic_Gulpin[] = INCBIN_U32("graphics/pokemon/gulpin/back.4bpp.lz");
+const u32 gMonShinyPalette_Gulpin[] = INCBIN_U32("graphics/pokemon/gulpin/shiny.gbapal.lz");
+const u8 gMonIcon_Gulpin[] = INCBIN_U8("graphics/pokemon/gulpin/icon.4bpp");
+const u8 gMonFootprint_Gulpin[] = INCBIN_U8("graphics/pokemon/gulpin/footprint.1bpp");
+
+const u32 gMonFrontPic_Swalot[] = INCBIN_U32("graphics/pokemon/swalot/front.4bpp.lz");
+const u32 gMonPalette_Swalot[] = INCBIN_U32("graphics/pokemon/swalot/normal.gbapal.lz");
+const u32 gMonBackPic_Swalot[] = INCBIN_U32("graphics/pokemon/swalot/back.4bpp.lz");
+const u32 gMonShinyPalette_Swalot[] = INCBIN_U32("graphics/pokemon/swalot/shiny.gbapal.lz");
+const u8 gMonIcon_Swalot[] = INCBIN_U8("graphics/pokemon/swalot/icon.4bpp");
+const u8 gMonFootprint_Swalot[] = INCBIN_U8("graphics/pokemon/swalot/footprint.1bpp");
+
+const u32 gMonFrontPic_Tropius[] = INCBIN_U32("graphics/pokemon/tropius/front.4bpp.lz");
+const u32 gMonPalette_Tropius[] = INCBIN_U32("graphics/pokemon/tropius/normal.gbapal.lz");
+const u32 gMonBackPic_Tropius[] = INCBIN_U32("graphics/pokemon/tropius/back.4bpp.lz");
+const u32 gMonShinyPalette_Tropius[] = INCBIN_U32("graphics/pokemon/tropius/shiny.gbapal.lz");
+const u8 gMonIcon_Tropius[] = INCBIN_U8("graphics/pokemon/tropius/icon.4bpp");
+const u8 gMonFootprint_Tropius[] = INCBIN_U8("graphics/pokemon/tropius/footprint.1bpp");
+
+const u32 gMonFrontPic_Whismur[] = INCBIN_U32("graphics/pokemon/whismur/front.4bpp.lz");
+const u32 gMonPalette_Whismur[] = INCBIN_U32("graphics/pokemon/whismur/normal.gbapal.lz");
+const u32 gMonBackPic_Whismur[] = INCBIN_U32("graphics/pokemon/whismur/back.4bpp.lz");
+const u32 gMonShinyPalette_Whismur[] = INCBIN_U32("graphics/pokemon/whismur/shiny.gbapal.lz");
+const u8 gMonIcon_Whismur[] = INCBIN_U8("graphics/pokemon/whismur/icon.4bpp");
+const u8 gMonFootprint_Whismur[] = INCBIN_U8("graphics/pokemon/whismur/footprint.1bpp");
+
+const u32 gMonFrontPic_Loudred[] = INCBIN_U32("graphics/pokemon/loudred/front.4bpp.lz");
+const u32 gMonPalette_Loudred[] = INCBIN_U32("graphics/pokemon/loudred/normal.gbapal.lz");
+const u32 gMonBackPic_Loudred[] = INCBIN_U32("graphics/pokemon/loudred/back.4bpp.lz");
+const u32 gMonShinyPalette_Loudred[] = INCBIN_U32("graphics/pokemon/loudred/shiny.gbapal.lz");
+const u8 gMonIcon_Loudred[] = INCBIN_U8("graphics/pokemon/loudred/icon.4bpp");
+const u8 gMonFootprint_Loudred[] = INCBIN_U8("graphics/pokemon/loudred/footprint.1bpp");
+
+const u32 gMonFrontPic_Exploud[] = INCBIN_U32("graphics/pokemon/exploud/front.4bpp.lz");
+const u32 gMonPalette_Exploud[] = INCBIN_U32("graphics/pokemon/exploud/normal.gbapal.lz");
+const u32 gMonBackPic_Exploud[] = INCBIN_U32("graphics/pokemon/exploud/back.4bpp.lz");
+const u32 gMonShinyPalette_Exploud[] = INCBIN_U32("graphics/pokemon/exploud/shiny.gbapal.lz");
+const u8 gMonIcon_Exploud[] = INCBIN_U8("graphics/pokemon/exploud/icon.4bpp");
+const u8 gMonFootprint_Exploud[] = INCBIN_U8("graphics/pokemon/exploud/footprint.1bpp");
+
+const u32 gMonFrontPic_Clamperl[] = INCBIN_U32("graphics/pokemon/clamperl/front.4bpp.lz");
+const u32 gMonPalette_Clamperl[] = INCBIN_U32("graphics/pokemon/clamperl/normal.gbapal.lz");
+const u32 gMonBackPic_Clamperl[] = INCBIN_U32("graphics/pokemon/clamperl/back.4bpp.lz");
+const u32 gMonShinyPalette_Clamperl[] = INCBIN_U32("graphics/pokemon/clamperl/shiny.gbapal.lz");
+const u8 gMonIcon_Clamperl[] = INCBIN_U8("graphics/pokemon/clamperl/icon.4bpp");
+const u8 gMonFootprint_Clamperl[] = INCBIN_U8("graphics/pokemon/clamperl/footprint.1bpp");
+
+const u32 gMonFrontPic_Huntail[] = INCBIN_U32("graphics/pokemon/huntail/front.4bpp.lz");
+const u32 gMonPalette_Huntail[] = INCBIN_U32("graphics/pokemon/huntail/normal.gbapal.lz");
+const u32 gMonBackPic_Huntail[] = INCBIN_U32("graphics/pokemon/huntail/back.4bpp.lz");
+const u32 gMonShinyPalette_Huntail[] = INCBIN_U32("graphics/pokemon/huntail/shiny.gbapal.lz");
+const u8 gMonIcon_Huntail[] = INCBIN_U8("graphics/pokemon/huntail/icon.4bpp");
+const u8 gMonFootprint_Huntail[] = INCBIN_U8("graphics/pokemon/huntail/footprint.1bpp");
+
+const u32 gMonFrontPic_Gorebyss[] = INCBIN_U32("graphics/pokemon/gorebyss/front.4bpp.lz");
+const u32 gMonPalette_Gorebyss[] = INCBIN_U32("graphics/pokemon/gorebyss/normal.gbapal.lz");
+const u32 gMonBackPic_Gorebyss[] = INCBIN_U32("graphics/pokemon/gorebyss/back.4bpp.lz");
+const u32 gMonShinyPalette_Gorebyss[] = INCBIN_U32("graphics/pokemon/gorebyss/shiny.gbapal.lz");
+const u8 gMonIcon_Gorebyss[] = INCBIN_U8("graphics/pokemon/gorebyss/icon.4bpp");
+const u8 gMonFootprint_Gorebyss[] = INCBIN_U8("graphics/pokemon/gorebyss/footprint.1bpp");
+
+const u32 gMonFrontPic_Absol[] = INCBIN_U32("graphics/pokemon/absol/front.4bpp.lz");
+const u32 gMonPalette_Absol[] = INCBIN_U32("graphics/pokemon/absol/normal.gbapal.lz");
+const u32 gMonBackPic_Absol[] = INCBIN_U32("graphics/pokemon/absol/back.4bpp.lz");
+const u32 gMonShinyPalette_Absol[] = INCBIN_U32("graphics/pokemon/absol/shiny.gbapal.lz");
+const u8 gMonIcon_Absol[] = INCBIN_U8("graphics/pokemon/absol/icon.4bpp");
+const u8 gMonFootprint_Absol[] = INCBIN_U8("graphics/pokemon/absol/footprint.1bpp");
+
+const u32 gMonFrontPic_Shuppet[] = INCBIN_U32("graphics/pokemon/shuppet/front.4bpp.lz");
+const u32 gMonPalette_Shuppet[] = INCBIN_U32("graphics/pokemon/shuppet/normal.gbapal.lz");
+const u32 gMonBackPic_Shuppet[] = INCBIN_U32("graphics/pokemon/shuppet/back.4bpp.lz");
+const u32 gMonShinyPalette_Shuppet[] = INCBIN_U32("graphics/pokemon/shuppet/shiny.gbapal.lz");
+const u8 gMonIcon_Shuppet[] = INCBIN_U8("graphics/pokemon/shuppet/icon.4bpp");
+const u8 gMonFootprint_Shuppet[] = INCBIN_U8("graphics/pokemon/shuppet/footprint.1bpp");
+
+const u32 gMonFrontPic_Banette[] = INCBIN_U32("graphics/pokemon/banette/front.4bpp.lz");
+const u32 gMonPalette_Banette[] = INCBIN_U32("graphics/pokemon/banette/normal.gbapal.lz");
+const u32 gMonBackPic_Banette[] = INCBIN_U32("graphics/pokemon/banette/back.4bpp.lz");
+const u32 gMonShinyPalette_Banette[] = INCBIN_U32("graphics/pokemon/banette/shiny.gbapal.lz");
+const u8 gMonIcon_Banette[] = INCBIN_U8("graphics/pokemon/banette/icon.4bpp");
+const u8 gMonFootprint_Banette[] = INCBIN_U8("graphics/pokemon/banette/footprint.1bpp");
+
+const u32 gMonFrontPic_Seviper[] = INCBIN_U32("graphics/pokemon/seviper/front.4bpp.lz");
+const u32 gMonPalette_Seviper[] = INCBIN_U32("graphics/pokemon/seviper/normal.gbapal.lz");
+const u32 gMonBackPic_Seviper[] = INCBIN_U32("graphics/pokemon/seviper/back.4bpp.lz");
+const u32 gMonShinyPalette_Seviper[] = INCBIN_U32("graphics/pokemon/seviper/shiny.gbapal.lz");
+const u8 gMonIcon_Seviper[] = INCBIN_U8("graphics/pokemon/seviper/icon.4bpp");
+const u8 gMonFootprint_Seviper[] = INCBIN_U8("graphics/pokemon/seviper/footprint.1bpp");
+
+const u32 gMonFrontPic_Zangoose[] = INCBIN_U32("graphics/pokemon/zangoose/front.4bpp.lz");
+const u32 gMonPalette_Zangoose[] = INCBIN_U32("graphics/pokemon/zangoose/normal.gbapal.lz");
+const u32 gMonBackPic_Zangoose[] = INCBIN_U32("graphics/pokemon/zangoose/back.4bpp.lz");
+const u32 gMonShinyPalette_Zangoose[] = INCBIN_U32("graphics/pokemon/zangoose/shiny.gbapal.lz");
+const u8 gMonIcon_Zangoose[] = INCBIN_U8("graphics/pokemon/zangoose/icon.4bpp");
+const u8 gMonFootprint_Zangoose[] = INCBIN_U8("graphics/pokemon/zangoose/footprint.1bpp");
+
+const u32 gMonFrontPic_Relicanth[] = INCBIN_U32("graphics/pokemon/relicanth/front.4bpp.lz");
+const u32 gMonPalette_Relicanth[] = INCBIN_U32("graphics/pokemon/relicanth/normal.gbapal.lz");
+const u32 gMonBackPic_Relicanth[] = INCBIN_U32("graphics/pokemon/relicanth/back.4bpp.lz");
+const u32 gMonShinyPalette_Relicanth[] = INCBIN_U32("graphics/pokemon/relicanth/shiny.gbapal.lz");
+const u8 gMonIcon_Relicanth[] = INCBIN_U8("graphics/pokemon/relicanth/icon.4bpp");
+const u8 gMonFootprint_Relicanth[] = INCBIN_U8("graphics/pokemon/relicanth/footprint.1bpp");
+
+const u32 gMonFrontPic_Aron[] = INCBIN_U32("graphics/pokemon/aron/front.4bpp.lz");
+const u32 gMonPalette_Aron[] = INCBIN_U32("graphics/pokemon/aron/normal.gbapal.lz");
+const u32 gMonBackPic_Aron[] = INCBIN_U32("graphics/pokemon/aron/back.4bpp.lz");
+const u32 gMonShinyPalette_Aron[] = INCBIN_U32("graphics/pokemon/aron/shiny.gbapal.lz");
+const u8 gMonIcon_Aron[] = INCBIN_U8("graphics/pokemon/aron/icon.4bpp");
+const u8 gMonFootprint_Aron[] = INCBIN_U8("graphics/pokemon/aron/footprint.1bpp");
+
+const u32 gMonFrontPic_Lairon[] = INCBIN_U32("graphics/pokemon/lairon/front.4bpp.lz");
+const u32 gMonPalette_Lairon[] = INCBIN_U32("graphics/pokemon/lairon/normal.gbapal.lz");
+const u32 gMonBackPic_Lairon[] = INCBIN_U32("graphics/pokemon/lairon/back.4bpp.lz");
+const u32 gMonShinyPalette_Lairon[] = INCBIN_U32("graphics/pokemon/lairon/shiny.gbapal.lz");
+const u8 gMonIcon_Lairon[] = INCBIN_U8("graphics/pokemon/lairon/icon.4bpp");
+const u8 gMonFootprint_Lairon[] = INCBIN_U8("graphics/pokemon/lairon/footprint.1bpp");
+
+const u32 gMonFrontPic_Aggron[] = INCBIN_U32("graphics/pokemon/aggron/front.4bpp.lz");
+const u32 gMonPalette_Aggron[] = INCBIN_U32("graphics/pokemon/aggron/normal.gbapal.lz");
+const u32 gMonBackPic_Aggron[] = INCBIN_U32("graphics/pokemon/aggron/back.4bpp.lz");
+const u32 gMonShinyPalette_Aggron[] = INCBIN_U32("graphics/pokemon/aggron/shiny.gbapal.lz");
+const u8 gMonIcon_Aggron[] = INCBIN_U8("graphics/pokemon/aggron/icon.4bpp");
+const u8 gMonFootprint_Aggron[] = INCBIN_U8("graphics/pokemon/aggron/footprint.1bpp");
+
+const u32 gMonFrontPic_Castform[] = INCBIN_U32("graphics/pokemon/castform/front.4bpp.lz");
+const u32 gMonPalette_Castform[] = INCBIN_U32("graphics/pokemon/castform/normal.gbapal.lz");
+const u32 gMonBackPic_Castform[] = INCBIN_U32("graphics/pokemon/castform/back.4bpp.lz");
+const u32 gMonShinyPalette_Castform[] = INCBIN_U32("graphics/pokemon/castform/shiny.gbapal.lz");
+const u8 gMonIcon_Castform[] = INCBIN_U8("graphics/pokemon/castform/icon.4bpp");
+const u8 gMonFootprint_Castform[] = INCBIN_U8("graphics/pokemon/castform/footprint.1bpp");
+
+const u32 gMonFrontPic_Volbeat[] = INCBIN_U32("graphics/pokemon/volbeat/front.4bpp.lz");
+const u32 gMonPalette_Volbeat[] = INCBIN_U32("graphics/pokemon/volbeat/normal.gbapal.lz");
+const u32 gMonBackPic_Volbeat[] = INCBIN_U32("graphics/pokemon/volbeat/back.4bpp.lz");
+const u32 gMonShinyPalette_Volbeat[] = INCBIN_U32("graphics/pokemon/volbeat/shiny.gbapal.lz");
+const u8 gMonIcon_Volbeat[] = INCBIN_U8("graphics/pokemon/volbeat/icon.4bpp");
+const u8 gMonFootprint_Volbeat[] = INCBIN_U8("graphics/pokemon/volbeat/footprint.1bpp");
+
+const u32 gMonFrontPic_Illumise[] = INCBIN_U32("graphics/pokemon/illumise/front.4bpp.lz");
+const u32 gMonPalette_Illumise[] = INCBIN_U32("graphics/pokemon/illumise/normal.gbapal.lz");
+const u32 gMonBackPic_Illumise[] = INCBIN_U32("graphics/pokemon/illumise/back.4bpp.lz");
+const u32 gMonShinyPalette_Illumise[] = INCBIN_U32("graphics/pokemon/illumise/shiny.gbapal.lz");
+const u8 gMonIcon_Illumise[] = INCBIN_U8("graphics/pokemon/illumise/icon.4bpp");
+const u8 gMonFootprint_Illumise[] = INCBIN_U8("graphics/pokemon/illumise/footprint.1bpp");
+
+const u32 gMonFrontPic_Lileep[] = INCBIN_U32("graphics/pokemon/lileep/front.4bpp.lz");
+const u32 gMonPalette_Lileep[] = INCBIN_U32("graphics/pokemon/lileep/normal.gbapal.lz");
+const u32 gMonBackPic_Lileep[] = INCBIN_U32("graphics/pokemon/lileep/back.4bpp.lz");
+const u32 gMonShinyPalette_Lileep[] = INCBIN_U32("graphics/pokemon/lileep/shiny.gbapal.lz");
+const u8 gMonIcon_Lileep[] = INCBIN_U8("graphics/pokemon/lileep/icon.4bpp");
+const u8 gMonFootprint_Lileep[] = INCBIN_U8("graphics/pokemon/lileep/footprint.1bpp");
+
+const u32 gMonFrontPic_Cradily[] = INCBIN_U32("graphics/pokemon/cradily/front.4bpp.lz");
+const u32 gMonPalette_Cradily[] = INCBIN_U32("graphics/pokemon/cradily/normal.gbapal.lz");
+const u32 gMonBackPic_Cradily[] = INCBIN_U32("graphics/pokemon/cradily/back.4bpp.lz");
+const u32 gMonShinyPalette_Cradily[] = INCBIN_U32("graphics/pokemon/cradily/shiny.gbapal.lz");
+const u8 gMonIcon_Cradily[] = INCBIN_U8("graphics/pokemon/cradily/icon.4bpp");
+const u8 gMonFootprint_Cradily[] = INCBIN_U8("graphics/pokemon/cradily/footprint.1bpp");
+
+const u32 gMonFrontPic_Anorith[] = INCBIN_U32("graphics/pokemon/anorith/front.4bpp.lz");
+const u32 gMonPalette_Anorith[] = INCBIN_U32("graphics/pokemon/anorith/normal.gbapal.lz");
+const u32 gMonBackPic_Anorith[] = INCBIN_U32("graphics/pokemon/anorith/back.4bpp.lz");
+const u32 gMonShinyPalette_Anorith[] = INCBIN_U32("graphics/pokemon/anorith/shiny.gbapal.lz");
+const u8 gMonIcon_Anorith[] = INCBIN_U8("graphics/pokemon/anorith/icon.4bpp");
+const u8 gMonFootprint_Anorith[] = INCBIN_U8("graphics/pokemon/anorith/footprint.1bpp");
+
+const u32 gMonFrontPic_Armaldo[] = INCBIN_U32("graphics/pokemon/armaldo/front.4bpp.lz");
+const u32 gMonPalette_Armaldo[] = INCBIN_U32("graphics/pokemon/armaldo/normal.gbapal.lz");
+const u32 gMonBackPic_Armaldo[] = INCBIN_U32("graphics/pokemon/armaldo/back.4bpp.lz");
+const u32 gMonShinyPalette_Armaldo[] = INCBIN_U32("graphics/pokemon/armaldo/shiny.gbapal.lz");
+const u8 gMonIcon_Armaldo[] = INCBIN_U8("graphics/pokemon/armaldo/icon.4bpp");
+const u8 gMonFootprint_Armaldo[] = INCBIN_U8("graphics/pokemon/armaldo/footprint.1bpp");
+
+const u32 gMonFrontPic_Ralts[] = INCBIN_U32("graphics/pokemon/ralts/front.4bpp.lz");
+const u32 gMonPalette_Ralts[] = INCBIN_U32("graphics/pokemon/ralts/normal.gbapal.lz");
+const u32 gMonBackPic_Ralts[] = INCBIN_U32("graphics/pokemon/ralts/back.4bpp.lz");
+const u32 gMonShinyPalette_Ralts[] = INCBIN_U32("graphics/pokemon/ralts/shiny.gbapal.lz");
+const u8 gMonIcon_Ralts[] = INCBIN_U8("graphics/pokemon/ralts/icon.4bpp");
+const u8 gMonFootprint_Ralts[] = INCBIN_U8("graphics/pokemon/ralts/footprint.1bpp");
+
+const u32 gMonFrontPic_Kirlia[] = INCBIN_U32("graphics/pokemon/kirlia/front.4bpp.lz");
+const u32 gMonPalette_Kirlia[] = INCBIN_U32("graphics/pokemon/kirlia/normal.gbapal.lz");
+const u32 gMonBackPic_Kirlia[] = INCBIN_U32("graphics/pokemon/kirlia/back.4bpp.lz");
+const u32 gMonShinyPalette_Kirlia[] = INCBIN_U32("graphics/pokemon/kirlia/shiny.gbapal.lz");
+const u8 gMonIcon_Kirlia[] = INCBIN_U8("graphics/pokemon/kirlia/icon.4bpp");
+const u8 gMonFootprint_Kirlia[] = INCBIN_U8("graphics/pokemon/kirlia/footprint.1bpp");
+
+const u32 gMonFrontPic_Gardevoir[] = INCBIN_U32("graphics/pokemon/gardevoir/front.4bpp.lz");
+const u32 gMonPalette_Gardevoir[] = INCBIN_U32("graphics/pokemon/gardevoir/normal.gbapal.lz");
+const u32 gMonBackPic_Gardevoir[] = INCBIN_U32("graphics/pokemon/gardevoir/back.4bpp.lz");
+const u32 gMonShinyPalette_Gardevoir[] = INCBIN_U32("graphics/pokemon/gardevoir/shiny.gbapal.lz");
+const u8 gMonIcon_Gardevoir[] = INCBIN_U8("graphics/pokemon/gardevoir/icon.4bpp");
+const u8 gMonFootprint_Gardevoir[] = INCBIN_U8("graphics/pokemon/gardevoir/footprint.1bpp");
+
+const u32 gMonFrontPic_Bagon[] = INCBIN_U32("graphics/pokemon/bagon/front.4bpp.lz");
+const u32 gMonPalette_Bagon[] = INCBIN_U32("graphics/pokemon/bagon/normal.gbapal.lz");
+const u32 gMonBackPic_Bagon[] = INCBIN_U32("graphics/pokemon/bagon/back.4bpp.lz");
+const u32 gMonShinyPalette_Bagon[] = INCBIN_U32("graphics/pokemon/bagon/shiny.gbapal.lz");
+const u8 gMonIcon_Bagon[] = INCBIN_U8("graphics/pokemon/bagon/icon.4bpp");
+const u8 gMonFootprint_Bagon[] = INCBIN_U8("graphics/pokemon/bagon/footprint.1bpp");
+
+const u32 gMonFrontPic_Shelgon[] = INCBIN_U32("graphics/pokemon/shelgon/front.4bpp.lz");
+const u32 gMonPalette_Shelgon[] = INCBIN_U32("graphics/pokemon/shelgon/normal.gbapal.lz");
+const u32 gMonBackPic_Shelgon[] = INCBIN_U32("graphics/pokemon/shelgon/back.4bpp.lz");
+const u32 gMonShinyPalette_Shelgon[] = INCBIN_U32("graphics/pokemon/shelgon/shiny.gbapal.lz");
+const u8 gMonIcon_Shelgon[] = INCBIN_U8("graphics/pokemon/shelgon/icon.4bpp");
+const u8 gMonFootprint_Shelgon[] = INCBIN_U8("graphics/pokemon/shelgon/footprint.1bpp");
+
+const u32 gMonFrontPic_Salamence[] = INCBIN_U32("graphics/pokemon/salamence/front.4bpp.lz");
+const u32 gMonPalette_Salamence[] = INCBIN_U32("graphics/pokemon/salamence/normal.gbapal.lz");
+const u32 gMonBackPic_Salamence[] = INCBIN_U32("graphics/pokemon/salamence/back.4bpp.lz");
+const u32 gMonShinyPalette_Salamence[] = INCBIN_U32("graphics/pokemon/salamence/shiny.gbapal.lz");
+const u8 gMonIcon_Salamence[] = INCBIN_U8("graphics/pokemon/salamence/icon.4bpp");
+const u8 gMonFootprint_Salamence[] = INCBIN_U8("graphics/pokemon/salamence/footprint.1bpp");
+
+const u32 gMonFrontPic_Beldum[] = INCBIN_U32("graphics/pokemon/beldum/front.4bpp.lz");
+const u32 gMonPalette_Beldum[] = INCBIN_U32("graphics/pokemon/beldum/normal.gbapal.lz");
+const u32 gMonBackPic_Beldum[] = INCBIN_U32("graphics/pokemon/beldum/back.4bpp.lz");
+const u32 gMonShinyPalette_Beldum[] = INCBIN_U32("graphics/pokemon/beldum/shiny.gbapal.lz");
+const u8 gMonIcon_Beldum[] = INCBIN_U8("graphics/pokemon/beldum/icon.4bpp");
+const u8 gMonFootprint_Beldum[] = INCBIN_U8("graphics/pokemon/beldum/footprint.1bpp");
+
+const u32 gMonFrontPic_Metang[] = INCBIN_U32("graphics/pokemon/metang/front.4bpp.lz");
+const u32 gMonPalette_Metang[] = INCBIN_U32("graphics/pokemon/metang/normal.gbapal.lz");
+const u32 gMonBackPic_Metang[] = INCBIN_U32("graphics/pokemon/metang/back.4bpp.lz");
+const u32 gMonShinyPalette_Metang[] = INCBIN_U32("graphics/pokemon/metang/shiny.gbapal.lz");
+const u8 gMonIcon_Metang[] = INCBIN_U8("graphics/pokemon/metang/icon.4bpp");
+const u8 gMonFootprint_Metang[] = INCBIN_U8("graphics/pokemon/metang/footprint.1bpp");
+
+const u32 gMonFrontPic_Metagross[] = INCBIN_U32("graphics/pokemon/metagross/front.4bpp.lz");
+const u32 gMonPalette_Metagross[] = INCBIN_U32("graphics/pokemon/metagross/normal.gbapal.lz");
+const u32 gMonBackPic_Metagross[] = INCBIN_U32("graphics/pokemon/metagross/back.4bpp.lz");
+const u32 gMonShinyPalette_Metagross[] = INCBIN_U32("graphics/pokemon/metagross/shiny.gbapal.lz");
+const u8 gMonIcon_Metagross[] = INCBIN_U8("graphics/pokemon/metagross/icon.4bpp");
+const u8 gMonFootprint_Metagross[] = INCBIN_U8("graphics/pokemon/metagross/footprint.1bpp");
+
+const u32 gMonFrontPic_Regirock[] = INCBIN_U32("graphics/pokemon/regirock/front.4bpp.lz");
+const u32 gMonPalette_Regirock[] = INCBIN_U32("graphics/pokemon/regirock/normal.gbapal.lz");
+const u32 gMonBackPic_Regirock[] = INCBIN_U32("graphics/pokemon/regirock/back.4bpp.lz");
+const u32 gMonShinyPalette_Regirock[] = INCBIN_U32("graphics/pokemon/regirock/shiny.gbapal.lz");
+const u8 gMonIcon_Regirock[] = INCBIN_U8("graphics/pokemon/regirock/icon.4bpp");
+const u8 gMonFootprint_Regirock[] = INCBIN_U8("graphics/pokemon/regirock/footprint.1bpp");
+
+const u32 gMonFrontPic_Regice[] = INCBIN_U32("graphics/pokemon/regice/front.4bpp.lz");
+const u32 gMonPalette_Regice[] = INCBIN_U32("graphics/pokemon/regice/normal.gbapal.lz");
+const u32 gMonBackPic_Regice[] = INCBIN_U32("graphics/pokemon/regice/back.4bpp.lz");
+const u32 gMonShinyPalette_Regice[] = INCBIN_U32("graphics/pokemon/regice/shiny.gbapal.lz");
+const u8 gMonIcon_Regice[] = INCBIN_U8("graphics/pokemon/regice/icon.4bpp");
+const u8 gMonFootprint_Regice[] = INCBIN_U8("graphics/pokemon/regice/footprint.1bpp");
+
+const u32 gMonFrontPic_Registeel[] = INCBIN_U32("graphics/pokemon/registeel/front.4bpp.lz");
+const u32 gMonPalette_Registeel[] = INCBIN_U32("graphics/pokemon/registeel/normal.gbapal.lz");
+const u32 gMonBackPic_Registeel[] = INCBIN_U32("graphics/pokemon/registeel/back.4bpp.lz");
+const u32 gMonShinyPalette_Registeel[] = INCBIN_U32("graphics/pokemon/registeel/shiny.gbapal.lz");
+const u8 gMonIcon_Registeel[] = INCBIN_U8("graphics/pokemon/registeel/icon.4bpp");
+const u8 gMonFootprint_Registeel[] = INCBIN_U8("graphics/pokemon/registeel/footprint.1bpp");
+
+const u32 gMonFrontPic_Kyogre[] = INCBIN_U32("graphics/pokemon/kyogre/front.4bpp.lz");
+const u32 gMonPalette_Kyogre[] = INCBIN_U32("graphics/pokemon/kyogre/normal.gbapal.lz");
+const u32 gMonBackPic_Kyogre[] = INCBIN_U32("graphics/pokemon/kyogre/back.4bpp.lz");
+const u32 gMonShinyPalette_Kyogre[] = INCBIN_U32("graphics/pokemon/kyogre/shiny.gbapal.lz");
+const u8 gMonIcon_Kyogre[] = INCBIN_U8("graphics/pokemon/kyogre/icon.4bpp");
+const u8 gMonFootprint_Kyogre[] = INCBIN_U8("graphics/pokemon/kyogre/footprint.1bpp");
+
+const u32 gMonFrontPic_Groudon[] = INCBIN_U32("graphics/pokemon/groudon/front.4bpp.lz");
+const u32 gMonPalette_Groudon[] = INCBIN_U32("graphics/pokemon/groudon/normal.gbapal.lz");
+const u32 gMonBackPic_Groudon[] = INCBIN_U32("graphics/pokemon/groudon/back.4bpp.lz");
+const u32 gMonShinyPalette_Groudon[] = INCBIN_U32("graphics/pokemon/groudon/shiny.gbapal.lz");
+const u8 gMonIcon_Groudon[] = INCBIN_U8("graphics/pokemon/groudon/icon.4bpp");
+const u8 gMonFootprint_Groudon[] = INCBIN_U8("graphics/pokemon/groudon/footprint.1bpp");
+
+const u32 gMonFrontPic_Rayquaza[] = INCBIN_U32("graphics/pokemon/rayquaza/front.4bpp.lz");
+const u32 gMonPalette_Rayquaza[] = INCBIN_U32("graphics/pokemon/rayquaza/normal.gbapal.lz");
+const u32 gMonBackPic_Rayquaza[] = INCBIN_U32("graphics/pokemon/rayquaza/back.4bpp.lz");
+const u32 gMonShinyPalette_Rayquaza[] = INCBIN_U32("graphics/pokemon/rayquaza/shiny.gbapal.lz");
+const u8 gMonIcon_Rayquaza[] = INCBIN_U8("graphics/pokemon/rayquaza/icon.4bpp");
+const u8 gMonFootprint_Rayquaza[] = INCBIN_U8("graphics/pokemon/rayquaza/footprint.1bpp");
+
+const u32 gMonFrontPic_Latias[] = INCBIN_U32("graphics/pokemon/latias/front.4bpp.lz");
+const u32 gMonPalette_Latias[] = INCBIN_U32("graphics/pokemon/latias/normal.gbapal.lz");
+const u32 gMonBackPic_Latias[] = INCBIN_U32("graphics/pokemon/latias/back.4bpp.lz");
+const u32 gMonShinyPalette_Latias[] = INCBIN_U32("graphics/pokemon/latias/shiny.gbapal.lz");
+const u8 gMonIcon_Latias[] = INCBIN_U8("graphics/pokemon/latias/icon.4bpp");
+const u8 gMonFootprint_Latias[] = INCBIN_U8("graphics/pokemon/latias/footprint.1bpp");
+
+const u32 gMonFrontPic_Latios[] = INCBIN_U32("graphics/pokemon/latios/front.4bpp.lz");
+const u32 gMonPalette_Latios[] = INCBIN_U32("graphics/pokemon/latios/normal.gbapal.lz");
+const u32 gMonBackPic_Latios[] = INCBIN_U32("graphics/pokemon/latios/back.4bpp.lz");
+const u32 gMonShinyPalette_Latios[] = INCBIN_U32("graphics/pokemon/latios/shiny.gbapal.lz");
+const u8 gMonIcon_Latios[] = INCBIN_U8("graphics/pokemon/latios/icon.4bpp");
+const u8 gMonFootprint_Latios[] = INCBIN_U8("graphics/pokemon/latios/footprint.1bpp");
+
+const u32 gMonFrontPic_Jirachi[] = INCBIN_U32("graphics/pokemon/jirachi/front.4bpp.lz");
+const u32 gMonPalette_Jirachi[] = INCBIN_U32("graphics/pokemon/jirachi/normal.gbapal.lz");
+const u32 gMonBackPic_Jirachi[] = INCBIN_U32("graphics/pokemon/jirachi/back.4bpp.lz");
+const u32 gMonShinyPalette_Jirachi[] = INCBIN_U32("graphics/pokemon/jirachi/shiny.gbapal.lz");
+const u8 gMonIcon_Jirachi[] = INCBIN_U8("graphics/pokemon/jirachi/icon.4bpp");
+const u8 gMonFootprint_Jirachi[] = INCBIN_U8("graphics/pokemon/jirachi/footprint.1bpp");
+
+#ifdef FIRERED
+const u32 gMonFrontPic_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/front.4bpp.lz");
+const u32 gMonPalette_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/normal.gbapal.lz");
+const u32 gMonBackPic_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/back.4bpp.lz");
+const u32 gMonShinyPalette_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/shiny.gbapal.lz");
+const u8 gMonIcon_Deoxys[] = INCBIN_U8("graphics/pokemon/deoxys/icon.4bpp", "graphics/pokemon/deoxys/icon_attack.4bpp");
+const u8 gMonFootprint_Deoxys[] = INCBIN_U8("graphics/pokemon/deoxys/footprint.1bpp");
+#endif
+
+#ifdef LEAFGREEN
+const u32 gMonFrontPic_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/front_def.4bpp.lz");
+const u32 gMonPalette_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/normal.gbapal.lz");
+const u32 gMonBackPic_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/back_def.4bpp.lz");
+const u32 gMonShinyPalette_Deoxys[] = INCBIN_U32("graphics/pokemon/deoxys/shiny.gbapal.lz");
+const u8 gMonIcon_Deoxys[] = INCBIN_U8("graphics/pokemon/deoxys/icon.4bpp", "graphics/pokemon/deoxys/icon_defense.4bpp");
+const u8 gMonFootprint_Deoxys[] = INCBIN_U8("graphics/pokemon/deoxys/footprint.1bpp");
+#endif
+
+const u32 gMonFrontPic_Chimecho[] = INCBIN_U32("graphics/pokemon/chimecho/front.4bpp.lz");
+const u32 gMonPalette_Chimecho[] = INCBIN_U32("graphics/pokemon/chimecho/normal.gbapal.lz");
+const u32 gMonBackPic_Chimecho[] = INCBIN_U32("graphics/pokemon/chimecho/back.4bpp.lz");
+const u32 gMonShinyPalette_Chimecho[] = INCBIN_U32("graphics/pokemon/chimecho/shiny.gbapal.lz");
+const u8 gMonIcon_Chimecho[] = INCBIN_U8("graphics/pokemon/chimecho/icon.4bpp");
+const u8 gMonFootprint_Chimecho[] = INCBIN_U8("graphics/pokemon/chimecho/footprint.1bpp");
+
+const u32 gMonFrontPic_Egg[] = INCBIN_U32("graphics/pokemon/egg/front.4bpp.lz");
+const u32 gMonPalette_Egg[] = INCBIN_U32("graphics/pokemon/egg/normal.gbapal.lz");
+
+const u32 gMonFrontPic_UnownB[] = INCBIN_U32("graphics/pokemon/unown/b/front.4bpp.lz");
+const u32 gMonBackPic_UnownB[] = INCBIN_U32("graphics/pokemon/unown/b/back.4bpp.lz");
+const u8 gMonIcon_UnownB[] = INCBIN_U8("graphics/pokemon/unown/b/icon.4bpp");
+
+const u32 gMonFrontPic_UnownC[] = INCBIN_U32("graphics/pokemon/unown/c/front.4bpp.lz");
+const u32 gMonBackPic_UnownC[] = INCBIN_U32("graphics/pokemon/unown/c/back.4bpp.lz");
+const u8 gMonIcon_UnownC[] = INCBIN_U8("graphics/pokemon/unown/c/icon.4bpp");
+
+const u32 gMonFrontPic_UnownD[] = INCBIN_U32("graphics/pokemon/unown/d/front.4bpp.lz");
+const u32 gMonBackPic_UnownD[] = INCBIN_U32("graphics/pokemon/unown/d/back.4bpp.lz");
+const u8 gMonIcon_UnownD[] = INCBIN_U8("graphics/pokemon/unown/d/icon.4bpp");
+
+const u32 gMonFrontPic_UnownE[] = INCBIN_U32("graphics/pokemon/unown/e/front.4bpp.lz");
+const u32 gMonBackPic_UnownE[] = INCBIN_U32("graphics/pokemon/unown/e/back.4bpp.lz");
+const u8 gMonIcon_UnownE[] = INCBIN_U8("graphics/pokemon/unown/e/icon.4bpp");
+
+const u32 gMonFrontPic_UnownF[] = INCBIN_U32("graphics/pokemon/unown/f/front.4bpp.lz");
+const u32 gMonBackPic_UnownF[] = INCBIN_U32("graphics/pokemon/unown/f/back.4bpp.lz");
+const u8 gMonIcon_UnownF[] = INCBIN_U8("graphics/pokemon/unown/f/icon.4bpp");
+
+const u32 gMonFrontPic_UnownG[] = INCBIN_U32("graphics/pokemon/unown/g/front.4bpp.lz");
+const u32 gMonBackPic_UnownG[] = INCBIN_U32("graphics/pokemon/unown/g/back.4bpp.lz");
+const u8 gMonIcon_UnownG[] = INCBIN_U8("graphics/pokemon/unown/g/icon.4bpp");
+
+const u32 gMonFrontPic_UnownH[] = INCBIN_U32("graphics/pokemon/unown/h/front.4bpp.lz");
+const u32 gMonBackPic_UnownH[] = INCBIN_U32("graphics/pokemon/unown/h/back.4bpp.lz");
+const u8 gMonIcon_UnownH[] = INCBIN_U8("graphics/pokemon/unown/h/icon.4bpp");
+
+const u32 gMonFrontPic_UnownI[] = INCBIN_U32("graphics/pokemon/unown/i/front.4bpp.lz");
+const u32 gMonBackPic_UnownI[] = INCBIN_U32("graphics/pokemon/unown/i/back.4bpp.lz");
+const u8 gMonIcon_UnownI[] = INCBIN_U8("graphics/pokemon/unown/i/icon.4bpp");
+
+const u32 gMonFrontPic_UnownJ[] = INCBIN_U32("graphics/pokemon/unown/j/front.4bpp.lz");
+const u32 gMonBackPic_UnownJ[] = INCBIN_U32("graphics/pokemon/unown/j/back.4bpp.lz");
+const u8 gMonIcon_UnownJ[] = INCBIN_U8("graphics/pokemon/unown/j/icon.4bpp");
+
+const u32 gMonFrontPic_UnownK[] = INCBIN_U32("graphics/pokemon/unown/k/front.4bpp.lz");
+const u32 gMonBackPic_UnownK[] = INCBIN_U32("graphics/pokemon/unown/k/back.4bpp.lz");
+const u8 gMonIcon_UnownK[] = INCBIN_U8("graphics/pokemon/unown/k/icon.4bpp");
+
+const u32 gMonFrontPic_UnownL[] = INCBIN_U32("graphics/pokemon/unown/l/front.4bpp.lz");
+const u32 gMonBackPic_UnownL[] = INCBIN_U32("graphics/pokemon/unown/l/back.4bpp.lz");
+const u8 gMonIcon_UnownL[] = INCBIN_U8("graphics/pokemon/unown/l/icon.4bpp");
+
+const u32 gMonFrontPic_UnownM[] = INCBIN_U32("graphics/pokemon/unown/m/front.4bpp.lz");
+const u32 gMonBackPic_UnownM[] = INCBIN_U32("graphics/pokemon/unown/m/back.4bpp.lz");
+const u8 gMonIcon_UnownM[] = INCBIN_U8("graphics/pokemon/unown/m/icon.4bpp");
+
+const u32 gMonFrontPic_UnownN[] = INCBIN_U32("graphics/pokemon/unown/n/front.4bpp.lz");
+const u32 gMonBackPic_UnownN[] = INCBIN_U32("graphics/pokemon/unown/n/back.4bpp.lz");
+const u8 gMonIcon_UnownN[] = INCBIN_U8("graphics/pokemon/unown/n/icon.4bpp");
+
+const u32 gMonFrontPic_UnownO[] = INCBIN_U32("graphics/pokemon/unown/o/front.4bpp.lz");
+const u32 gMonBackPic_UnownO[] = INCBIN_U32("graphics/pokemon/unown/o/back.4bpp.lz");
+const u8 gMonIcon_UnownO[] = INCBIN_U8("graphics/pokemon/unown/o/icon.4bpp");
+
+const u32 gMonFrontPic_UnownP[] = INCBIN_U32("graphics/pokemon/unown/p/front.4bpp.lz");
+const u32 gMonBackPic_UnownP[] = INCBIN_U32("graphics/pokemon/unown/p/back.4bpp.lz");
+const u8 gMonIcon_UnownP[] = INCBIN_U8("graphics/pokemon/unown/p/icon.4bpp");
+
+const u32 gMonFrontPic_UnownQ[] = INCBIN_U32("graphics/pokemon/unown/q/front.4bpp.lz");
+const u32 gMonBackPic_UnownQ[] = INCBIN_U32("graphics/pokemon/unown/q/back.4bpp.lz");
+const u8 gMonIcon_UnownQ[] = INCBIN_U8("graphics/pokemon/unown/q/icon.4bpp");
+
+const u32 gMonFrontPic_UnownR[] = INCBIN_U32("graphics/pokemon/unown/r/front.4bpp.lz");
+const u32 gMonBackPic_UnownR[] = INCBIN_U32("graphics/pokemon/unown/r/back.4bpp.lz");
+const u8 gMonIcon_UnownR[] = INCBIN_U8("graphics/pokemon/unown/r/icon.4bpp");
+
+const u32 gMonFrontPic_UnownS[] = INCBIN_U32("graphics/pokemon/unown/s/front.4bpp.lz");
+const u32 gMonBackPic_UnownS[] = INCBIN_U32("graphics/pokemon/unown/s/back.4bpp.lz");
+const u8 gMonIcon_UnownS[] = INCBIN_U8("graphics/pokemon/unown/s/icon.4bpp");
+
+const u32 gMonFrontPic_UnownT[] = INCBIN_U32("graphics/pokemon/unown/t/front.4bpp.lz");
+const u32 gMonBackPic_UnownT[] = INCBIN_U32("graphics/pokemon/unown/t/back.4bpp.lz");
+const u8 gMonIcon_UnownT[] = INCBIN_U8("graphics/pokemon/unown/t/icon.4bpp");
+
+const u32 gMonFrontPic_UnownU[] = INCBIN_U32("graphics/pokemon/unown/u/front.4bpp.lz");
+const u32 gMonBackPic_UnownU[] = INCBIN_U32("graphics/pokemon/unown/u/back.4bpp.lz");
+const u8 gMonIcon_UnownU[] = INCBIN_U8("graphics/pokemon/unown/u/icon.4bpp");
+
+const u32 gMonFrontPic_UnownV[] = INCBIN_U32("graphics/pokemon/unown/v/front.4bpp.lz");
+const u32 gMonBackPic_UnownV[] = INCBIN_U32("graphics/pokemon/unown/v/back.4bpp.lz");
+const u8 gMonIcon_UnownV[] = INCBIN_U8("graphics/pokemon/unown/v/icon.4bpp");
+
+const u32 gMonFrontPic_UnownW[] = INCBIN_U32("graphics/pokemon/unown/w/front.4bpp.lz");
+const u32 gMonBackPic_UnownW[] = INCBIN_U32("graphics/pokemon/unown/w/back.4bpp.lz");
+const u8 gMonIcon_UnownW[] = INCBIN_U8("graphics/pokemon/unown/w/icon.4bpp");
+
+const u32 gMonFrontPic_UnownX[] = INCBIN_U32("graphics/pokemon/unown/x/front.4bpp.lz");
+const u32 gMonBackPic_UnownX[] = INCBIN_U32("graphics/pokemon/unown/x/back.4bpp.lz");
+const u8 gMonIcon_UnownX[] = INCBIN_U8("graphics/pokemon/unown/x/icon.4bpp");
+
+const u32 gMonFrontPic_UnownY[] = INCBIN_U32("graphics/pokemon/unown/y/front.4bpp.lz");
+const u32 gMonBackPic_UnownY[] = INCBIN_U32("graphics/pokemon/unown/y/back.4bpp.lz");
+const u8 gMonIcon_UnownY[] = INCBIN_U8("graphics/pokemon/unown/y/icon.4bpp");
+
+const u32 gMonFrontPic_UnownZ[] = INCBIN_U32("graphics/pokemon/unown/z/front.4bpp.lz");
+const u32 gMonBackPic_UnownZ[] = INCBIN_U32("graphics/pokemon/unown/z/back.4bpp.lz");
+const u8 gMonIcon_UnownZ[] = INCBIN_U8("graphics/pokemon/unown/z/icon.4bpp");
+
+const u32 gMonFrontPic_UnownExclamationMark[] = INCBIN_U32("graphics/pokemon/unown/exclamation_mark/front.4bpp.lz");
+const u32 gMonBackPic_UnownExclamationMark[] = INCBIN_U32("graphics/pokemon/unown/exclamation_mark/back.4bpp.lz");
+const u8 gMonIcon_UnownExclamationMark[] = INCBIN_U8("graphics/pokemon/unown/exclamation_mark/icon.4bpp");
+
+const u32 gMonFrontPic_UnownQuestionMark[] = INCBIN_U32("graphics/pokemon/unown/question_mark/front.4bpp.lz");
+const u32 gMonBackPic_UnownQuestionMark[] = INCBIN_U32("graphics/pokemon/unown/question_mark/back.4bpp.lz");
+const u8 gMonIcon_UnownQuestionMark[] = INCBIN_U8("graphics/pokemon/unown/question_mark/icon.4bpp");
diff --git a/src/data/graphics/trainers.h b/src/data/graphics/trainers.h
new file mode 100644
index 000000000..07183e288
--- /dev/null
+++ b/src/data/graphics/trainers.h
@@ -0,0 +1,456 @@
+const u32 gTrainerFrontPic_AquaLeaderArchie[] = INCBIN_U32("graphics/trainers/front_pics/aqua_leader_archie_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AquaLeaderArchie[] = INCBIN_U32("graphics/trainers/palettes/aqua_leader_archie.gbapal.lz");
+
+const u32 gTrainerFrontPic_AquaGruntM[] = INCBIN_U32("graphics/trainers/front_pics/aqua_grunt_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AquaGruntM[] = INCBIN_U32("graphics/trainers/palettes/aqua_grunt_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_AquaGruntF[] = INCBIN_U32("graphics/trainers/front_pics/aqua_grunt_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AquaGruntF[] = INCBIN_U32("graphics/trainers/palettes/aqua_grunt_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSAromaLady[] = INCBIN_U32("graphics/trainers/front_pics/rs_aroma_lady_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSAromaLady[] = INCBIN_U32("graphics/trainers/palettes/rs_aroma_lady.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSRuinManiac[] = INCBIN_U32("graphics/trainers/front_pics/rs_ruin_maniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSRuinManiac[] = INCBIN_U32("graphics/trainers/palettes/rs_ruin_maniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_Interviewer[] = INCBIN_U32("graphics/trainers/front_pics/interviewer_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Interviewer[] = INCBIN_U32("graphics/trainers/palettes/interviewer.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSTuberF[] = INCBIN_U32("graphics/trainers/front_pics/rs_tuber_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSTuberF[] = INCBIN_U32("graphics/trainers/palettes/rs_tuber_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_TuberM[] = INCBIN_U32("graphics/trainers/front_pics/tuber_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_TuberM[] = INCBIN_U32("graphics/trainers/palettes/tuber_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSCooltrainerM[] = INCBIN_U32("graphics/trainers/front_pics/rs_cool_trainer_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSCooltrainerM[] = INCBIN_U32("graphics/trainers/palettes/rs_cool_trainer_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSCooltrainerF[] = INCBIN_U32("graphics/trainers/front_pics/rs_cool_trainer_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSCooltrainerF[] = INCBIN_U32("graphics/trainers/palettes/rs_cool_trainer_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_HexManiac[] = INCBIN_U32("graphics/trainers/front_pics/hex_maniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_HexManiac[] = INCBIN_U32("graphics/trainers/palettes/hex_maniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSLady[] = INCBIN_U32("graphics/trainers/front_pics/rs_lady_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSLady[] = INCBIN_U32("graphics/trainers/palettes/rs_lady.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBeauty[] = INCBIN_U32("graphics/trainers/front_pics/rs_beauty_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBeauty[] = INCBIN_U32("graphics/trainers/palettes/rs_beauty.gbapal.lz");
+
+const u32 gTrainerFrontPic_RichBoy[] = INCBIN_U32("graphics/trainers/front_pics/rich_boy_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RichBoy[] = INCBIN_U32("graphics/trainers/palettes/rich_boy.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPokeManiac[] = INCBIN_U32("graphics/trainers/front_pics/rs_pokemaniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPokeManiac[] = INCBIN_U32("graphics/trainers/palettes/rs_pokemaniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSSwimmerM[] = INCBIN_U32("graphics/trainers/front_pics/rs_swimmer_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSSwimmerM[] = INCBIN_U32("graphics/trainers/palettes/rs_swimmer_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBlackBelt[] = INCBIN_U32("graphics/trainers/front_pics/rs_black_belt_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBlackBelt[] = INCBIN_U32("graphics/trainers/palettes/rs_black_belt.gbapal.lz");
+
+const u32 gTrainerFrontPic_Guitarist[] = INCBIN_U32("graphics/trainers/front_pics/guitarist_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Guitarist[] = INCBIN_U32("graphics/trainers/palettes/guitarist.gbapal.lz");
+
+const u32 gTrainerFrontPic_Kindler[] = INCBIN_U32("graphics/trainers/front_pics/kindler_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Kindler[] = INCBIN_U32("graphics/trainers/palettes/kindler.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSCamper[] = INCBIN_U32("graphics/trainers/front_pics/rs_camper_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSCamper[] = INCBIN_U32("graphics/trainers/palettes/rs_camper.gbapal.lz");
+
+const u32 gTrainerFrontPic_BugManiac[] = INCBIN_U32("graphics/trainers/front_pics/bug_maniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_BugManiac[] = INCBIN_U32("graphics/trainers/palettes/bug_maniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPsychicM[] = INCBIN_U32("graphics/trainers/front_pics/rs_psychic_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPsychicM[] = INCBIN_U32("graphics/trainers/palettes/rs_psychic_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPsychicF[] = INCBIN_U32("graphics/trainers/front_pics/rs_psychic_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPsychicF[] = INCBIN_U32("graphics/trainers/palettes/rs_psychic_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSGentleman[] = INCBIN_U32("graphics/trainers/front_pics/rs_gentleman_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSGentleman[] = INCBIN_U32("graphics/trainers/palettes/rs_gentleman.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourSidney[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_sidney_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourSidney[] = INCBIN_U32("graphics/trainers/palettes/elite_four_sidney.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourPhoebe[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_phoebe_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourPhoebe[] = INCBIN_U32("graphics/trainers/palettes/elite_four_phoebe.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderRoxanne[] = INCBIN_U32("graphics/trainers/front_pics/leader_roxanne_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderRoxanne[] = INCBIN_U32("graphics/trainers/palettes/leader_roxanne.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderBrawly[] = INCBIN_U32("graphics/trainers/front_pics/leader_brawly_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderBrawly[] = INCBIN_U32("graphics/trainers/palettes/leader_brawly.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderTateAndLiza[] = INCBIN_U32("graphics/trainers/front_pics/leader_tate_and_liza_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderTateAndLiza[] = INCBIN_U32("graphics/trainers/palettes/leader_tate_and_liza.gbapal.lz");
+
+const u32 gTrainerFrontPic_SchoolKidM[] = INCBIN_U32("graphics/trainers/front_pics/school_kid_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SchoolKidM[] = INCBIN_U32("graphics/trainers/palettes/school_kid_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_SchoolKidF[] = INCBIN_U32("graphics/trainers/front_pics/school_kid_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SchoolKidF[] = INCBIN_U32("graphics/trainers/palettes/school_kid_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_SrAndJr[] = INCBIN_U32("graphics/trainers/front_pics/sr_and_jr_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SrAndJr[] = INCBIN_U32("graphics/trainers/palettes/sr_and_jr.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokefanM[] = INCBIN_U32("graphics/trainers/front_pics/pokefan_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokefanM[] = INCBIN_U32("graphics/trainers/palettes/pokefan_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokefanF[] = INCBIN_U32("graphics/trainers/front_pics/pokefan_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokefanF[] = INCBIN_U32("graphics/trainers/palettes/pokefan_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_ExpertM[] = INCBIN_U32("graphics/trainers/front_pics/expert_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ExpertM[] = INCBIN_U32("graphics/trainers/palettes/expert_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_ExpertF[] = INCBIN_U32("graphics/trainers/front_pics/expert_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ExpertF[] = INCBIN_U32("graphics/trainers/palettes/expert_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSYoungster[] = INCBIN_U32("graphics/trainers/front_pics/rs_youngster_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSYoungster[] = INCBIN_U32("graphics/trainers/palettes/rs_youngster.gbapal.lz");
+
+const u32 gTrainerFrontPic_ChampionSteven[] = INCBIN_U32("graphics/trainers/front_pics/champion_steven_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ChampionSteven[] = INCBIN_U32("graphics/trainers/palettes/champion_steven.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSFisherman[] = INCBIN_U32("graphics/trainers/front_pics/rs_fisherman_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSFisherman[] = INCBIN_U32("graphics/trainers/palettes/rs_fisherman.gbapal.lz");
+
+const u32 gTrainerFrontPic_CyclingTriathleteM[] = INCBIN_U32("graphics/trainers/front_pics/cycling_triathlete_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CyclingTriathleteM[] = INCBIN_U32("graphics/trainers/palettes/cycling_triathlete_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_CyclingTriathleteF[] = INCBIN_U32("graphics/trainers/front_pics/cycling_triathlete_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CyclingTriathleteF[] = INCBIN_U32("graphics/trainers/palettes/cycling_triathlete_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RunningTriathleteM[] = INCBIN_U32("graphics/trainers/front_pics/running_triathlete_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RunningTriathleteM[] = INCBIN_U32("graphics/trainers/palettes/running_triathlete_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RunningTriathleteF[] = INCBIN_U32("graphics/trainers/front_pics/running_triathlete_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RunningTriathleteF[] = INCBIN_U32("graphics/trainers/palettes/running_triathlete_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_SwimmingTriathleteM[] = INCBIN_U32("graphics/trainers/front_pics/swimming_triathlete_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SwimmingTriathleteM[] = INCBIN_U32("graphics/trainers/palettes/swimming_triathlete_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_SwimmingTriathleteF[] = INCBIN_U32("graphics/trainers/front_pics/swimming_triathlete_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SwimmingTriathleteF[] = INCBIN_U32("graphics/trainers/palettes/swimming_triathlete_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_DragonTamer[] = INCBIN_U32("graphics/trainers/front_pics/dragon_tamer_front_pic.4bpp.lz");
+const u32 gTrainerPalette_DragonTamer[] = INCBIN_U32("graphics/trainers/palettes/dragon_tamer.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBirdKeeper[] = INCBIN_U32("graphics/trainers/front_pics/rs_bird_keeper_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBirdKeeper[] = INCBIN_U32("graphics/trainers/palettes/rs_bird_keeper.gbapal.lz");
+
+const u32 gTrainerFrontPic_NinjaBoy[] = INCBIN_U32("graphics/trainers/front_pics/ninja_boy_front_pic.4bpp.lz");
+const u32 gTrainerPalette_NinjaBoy[] = INCBIN_U32("graphics/trainers/palettes/ninja_boy.gbapal.lz");
+
+const u32 gTrainerFrontPic_BattleGirl[] = INCBIN_U32("graphics/trainers/front_pics/battle_girl_front_pic.4bpp.lz");
+const u32 gTrainerPalette_BattleGirl[] = INCBIN_U32("graphics/trainers/palettes/battle_girl.gbapal.lz");
+
+const u32 gTrainerFrontPic_ParasolLady[] = INCBIN_U32("graphics/trainers/front_pics/parasol_lady_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ParasolLady[] = INCBIN_U32("graphics/trainers/palettes/parasol_lady.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSSwimmerF[] = INCBIN_U32("graphics/trainers/front_pics/rs_swimmer_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSSwimmerF[] = INCBIN_U32("graphics/trainers/palettes/rs_swimmer_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPicnicker[] = INCBIN_U32("graphics/trainers/front_pics/rs_picnicker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPicnicker[] = INCBIN_U32("graphics/trainers/palettes/rs_picnicker.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSTwins[] = INCBIN_U32("graphics/trainers/front_pics/rs_twins_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSTwins[] = INCBIN_U32("graphics/trainers/palettes/rs_twins.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSSailor[] = INCBIN_U32("graphics/trainers/front_pics/rs_sailor_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSSailor[] = INCBIN_U32("graphics/trainers/palettes/rs_sailor.gbapal.lz");
+
+const u32 gTrainerFrontPic_Collector[] = INCBIN_U32("graphics/trainers/front_pics/collector_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Collector[] = INCBIN_U32("graphics/trainers/palettes/collector.gbapal.lz");
+
+const u32 gTrainerFrontPic_Wally[] = INCBIN_U32("graphics/trainers/front_pics/wally_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Wally[] = INCBIN_U32("graphics/trainers/palettes/wally.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBrendan1[] = INCBIN_U32("graphics/trainers/front_pics/ruby_sapphire_brendan_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBrendan1[] = INCBIN_U32("graphics/trainers/palettes/ruby_sapphire_brendan.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSMay1[] = INCBIN_U32("graphics/trainers/front_pics/ruby_sapphire_may_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSMay1[] = INCBIN_U32("graphics/trainers/palettes/ruby_sapphire_may.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokemonBreederM[] = INCBIN_U32("graphics/trainers/front_pics/pokemon_breeder_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokemonBreederM[] = INCBIN_U32("graphics/trainers/palettes/pokemon_breeder_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPokemonBreederF[] = INCBIN_U32("graphics/trainers/front_pics/rs_pokemon_breeder_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPokemonBreederF[] = INCBIN_U32("graphics/trainers/palettes/rs_pokemon_breeder_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPokemonRangerM[] = INCBIN_U32("graphics/trainers/front_pics/rs_pokemon_ranger_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPokemonRangerM[] = INCBIN_U32("graphics/trainers/palettes/rs_pokemon_ranger_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSPokemonRangerF[] = INCBIN_U32("graphics/trainers/front_pics/rs_pokemon_ranger_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSPokemonRangerF[] = INCBIN_U32("graphics/trainers/palettes/rs_pokemon_ranger_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_MagmaLeaderMaxie[] = INCBIN_U32("graphics/trainers/front_pics/magma_leader_maxie_front_pic.4bpp.lz");
+const u32 gTrainerPalette_MagmaLeaderMaxie[] = INCBIN_U32("graphics/trainers/palettes/magma_leader_maxie.gbapal.lz");
+
+const u32 gTrainerFrontPic_MagmaGruntM[] = INCBIN_U32("graphics/trainers/front_pics/magma_grunt_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_MagmaGruntM[] = INCBIN_U32("graphics/trainers/palettes/magma_grunt_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_MagmaGruntF[] = INCBIN_U32("graphics/trainers/front_pics/magma_grunt_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_MagmaGruntF[] = INCBIN_U32("graphics/trainers/palettes/magma_grunt_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSLass[] = INCBIN_U32("graphics/trainers/front_pics/rs_lass_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSLass[] = INCBIN_U32("graphics/trainers/palettes/rs_lass.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBugCatcher[] = INCBIN_U32("graphics/trainers/front_pics/rs_bug_catcher_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBugCatcher[] = INCBIN_U32("graphics/trainers/palettes/rs_bug_catcher.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSHiker[] = INCBIN_U32("graphics/trainers/front_pics/rs_hiker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSHiker[] = INCBIN_U32("graphics/trainers/palettes/rs_hiker.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSYoungCouple[] = INCBIN_U32("graphics/trainers/front_pics/rs_young_couple_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSYoungCouple[] = INCBIN_U32("graphics/trainers/palettes/rs_young_couple.gbapal.lz");
+
+const u32 gTrainerFrontPic_OldCouple[] = INCBIN_U32("graphics/trainers/front_pics/old_couple_front_pic.4bpp.lz");
+const u32 gTrainerPalette_OldCouple[] = INCBIN_U32("graphics/trainers/palettes/old_couple.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSSisAndBro[] = INCBIN_U32("graphics/trainers/front_pics/rs_sis_and_bro_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSSisAndBro[] = INCBIN_U32("graphics/trainers/palettes/rs_sis_and_bro.gbapal.lz");
+
+const u32 gTrainerFrontPic_AquaAdminM[] = INCBIN_U32("graphics/trainers/front_pics/aqua_admin_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AquaAdminM[] = INCBIN_U32("graphics/trainers/palettes/aqua_admin_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_AquaAdminF[] = INCBIN_U32("graphics/trainers/front_pics/aqua_admin_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AquaAdminF[] = INCBIN_U32("graphics/trainers/palettes/aqua_admin_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_MagmaAdminM[] = INCBIN_U32("graphics/trainers/front_pics/magma_admin_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_MagmaAdminM[] = INCBIN_U32("graphics/trainers/palettes/magma_admin_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_MagmaAdminF[] = INCBIN_U32("graphics/trainers/front_pics/magma_admin_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_MagmaAdminF[] = INCBIN_U32("graphics/trainers/palettes/magma_admin_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderWattson[] = INCBIN_U32("graphics/trainers/front_pics/leader_wattson_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderWattson[] = INCBIN_U32("graphics/trainers/palettes/leader_wattson.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderFlannery[] = INCBIN_U32("graphics/trainers/front_pics/leader_flannery_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderFlannery[] = INCBIN_U32("graphics/trainers/palettes/leader_flannery.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderNorman[] = INCBIN_U32("graphics/trainers/front_pics/leader_norman_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderNorman[] = INCBIN_U32("graphics/trainers/palettes/leader_norman.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderWinona[] = INCBIN_U32("graphics/trainers/front_pics/leader_winona_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderWinona[] = INCBIN_U32("graphics/trainers/palettes/leader_winona.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderWallace[] = INCBIN_U32("graphics/trainers/front_pics/leader_wallace_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderWallace[] = INCBIN_U32("graphics/trainers/palettes/leader_wallace.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourGlacia[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_glacia_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourGlacia[] = INCBIN_U32("graphics/trainers/palettes/elite_four_glacia.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourDrake[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_drake_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourDrake[] = INCBIN_U32("graphics/trainers/palettes/elite_four_drake.gbapal.lz");
+
+const u32 gTrainerFrontPic_Youngster[] = INCBIN_U32("graphics/trainers/front_pics/youngster_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Youngster[] = INCBIN_U32("graphics/trainers/palettes/youngster.gbapal.lz");
+
+const u32 gTrainerFrontPic_BugCatcher[] = INCBIN_U32("graphics/trainers/front_pics/bug_catcher_front_pic.4bpp.lz");
+const u32 gTrainerPalette_BugCatcher[] = INCBIN_U32("graphics/trainers/palettes/bug_catcher.gbapal.lz");
+
+const u32 gTrainerFrontPic_Lass[] = INCBIN_U32("graphics/trainers/front_pics/lass_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Lass[] = INCBIN_U32("graphics/trainers/palettes/lass.gbapal.lz");
+
+const u32 gTrainerFrontPic_Sailor[] = INCBIN_U32("graphics/trainers/front_pics/sailor_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Sailor[] = INCBIN_U32("graphics/trainers/palettes/sailor.gbapal.lz");
+
+const u32 gTrainerFrontPic_Camper[] = INCBIN_U32("graphics/trainers/front_pics/camper_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Camper[] = INCBIN_U32("graphics/trainers/palettes/camper.gbapal.lz");
+
+const u32 gTrainerFrontPic_Picnicker[] = INCBIN_U32("graphics/trainers/front_pics/picnicker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Picnicker[] = INCBIN_U32("graphics/trainers/palettes/picnicker.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokeManiac[] = INCBIN_U32("graphics/trainers/front_pics/pokemaniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokeManiac[] = INCBIN_U32("graphics/trainers/palettes/pokemaniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_SuperNerd[] = INCBIN_U32("graphics/trainers/front_pics/super_nerd_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SuperNerd[] = INCBIN_U32("graphics/trainers/palettes/super_nerd.gbapal.lz");
+
+const u32 gTrainerFrontPic_Hiker[] = INCBIN_U32("graphics/trainers/front_pics/hiker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Hiker[] = INCBIN_U32("graphics/trainers/palettes/hiker.gbapal.lz");
+
+const u32 gTrainerFrontPic_Biker[] = INCBIN_U32("graphics/trainers/front_pics/biker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Biker[] = INCBIN_U32("graphics/trainers/palettes/biker.gbapal.lz");
+
+const u32 gTrainerFrontPic_Burglar[] = INCBIN_U32("graphics/trainers/front_pics/burglar_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Burglar[] = INCBIN_U32("graphics/trainers/palettes/burglar.gbapal.lz");
+
+const u32 gTrainerFrontPic_Engineer[] = INCBIN_U32("graphics/trainers/front_pics/engineer_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Engineer[] = INCBIN_U32("graphics/trainers/palettes/engineer.gbapal.lz");
+
+const u32 gTrainerFrontPic_Fisherman[] = INCBIN_U32("graphics/trainers/front_pics/fisherman_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Fisherman[] = INCBIN_U32("graphics/trainers/palettes/fisherman.gbapal.lz");
+
+const u32 gTrainerFrontPic_SwimmerM[] = INCBIN_U32("graphics/trainers/front_pics/swimmer_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SwimmerM[] = INCBIN_U32("graphics/trainers/palettes/swimmer_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_CueBall[] = INCBIN_U32("graphics/trainers/front_pics/cue_ball_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CueBall[] = INCBIN_U32("graphics/trainers/palettes/cue_ball.gbapal.lz");
+
+const u32 gTrainerFrontPic_Gamer[] = INCBIN_U32("graphics/trainers/front_pics/gamer_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Gamer[] = INCBIN_U32("graphics/trainers/palettes/gamer.gbapal.lz");
+
+const u32 gTrainerFrontPic_Beauty[] = INCBIN_U32("graphics/trainers/front_pics/beauty_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Beauty[] = INCBIN_U32("graphics/trainers/palettes/beauty.gbapal.lz");
+
+const u32 gTrainerFrontPic_SwimmerF[] = INCBIN_U32("graphics/trainers/front_pics/swimmer_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SwimmerF[] = INCBIN_U32("graphics/trainers/palettes/swimmer_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_PsychicM[] = INCBIN_U32("graphics/trainers/front_pics/psychic_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PsychicM[] = INCBIN_U32("graphics/trainers/palettes/psychic_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_Rocker[] = INCBIN_U32("graphics/trainers/front_pics/rocker_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Rocker[] = INCBIN_U32("graphics/trainers/palettes/rocker.gbapal.lz");
+
+const u32 gTrainerFrontPic_Juggler[] = INCBIN_U32("graphics/trainers/front_pics/juggler_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Juggler[] = INCBIN_U32("graphics/trainers/palettes/juggler.gbapal.lz");
+
+const u32 gTrainerFrontPic_Tamer[] = INCBIN_U32("graphics/trainers/front_pics/tamer_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Tamer[] = INCBIN_U32("graphics/trainers/palettes/tamer.gbapal.lz");
+
+const u32 gTrainerFrontPic_BirdKeeper[] = INCBIN_U32("graphics/trainers/front_pics/bird_keeper_front_pic.4bpp.lz");
+const u32 gTrainerPalette_BirdKeeper[] = INCBIN_U32("graphics/trainers/palettes/bird_keeper.gbapal.lz");
+
+const u32 gTrainerFrontPic_BlackBelt[] = INCBIN_U32("graphics/trainers/front_pics/black_belt_front_pic.4bpp.lz");
+const u32 gTrainerPalette_BlackBelt[] = INCBIN_U32("graphics/trainers/palettes/black_belt.gbapal.lz");
+
+const u32 gTrainerFrontPic_Rival1[] = INCBIN_U32("graphics/trainers/front_pics/rival_1_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Rival1[] = INCBIN_U32("graphics/trainers/palettes/rival_1.gbapal.lz");
+
+const u32 gTrainerFrontPic_Scientist[] = INCBIN_U32("graphics/trainers/front_pics/scientist_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Scientist[] = INCBIN_U32("graphics/trainers/palettes/scientist.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderGiovanni[] = INCBIN_U32("graphics/trainers/front_pics/leader_giovanni_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderGiovanni[] = INCBIN_U32("graphics/trainers/palettes/leader_giovanni.gbapal.lz");
+
+const u32 gTrainerFrontPic_RocketGruntM[] = INCBIN_U32("graphics/trainers/front_pics/rocket_grunt_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RocketGruntM[] = INCBIN_U32("graphics/trainers/palettes/rocket_grunt_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_CooltrainerM[] = INCBIN_U32("graphics/trainers/front_pics/cool_trainer_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CooltrainerM[] = INCBIN_U32("graphics/trainers/palettes/cool_trainer_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_CooltrainerF[] = INCBIN_U32("graphics/trainers/front_pics/cool_trainer_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CooltrainerF[] = INCBIN_U32("graphics/trainers/palettes/cool_trainer_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourLorelei[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_lorelei_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourLorelei[] = INCBIN_U32("graphics/trainers/palettes/elite_four_lorelei.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourBruno[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_bruno_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourBruno[] = INCBIN_U32("graphics/trainers/palettes/elite_four_bruno.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourAgatha[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_agatha_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourAgatha[] = INCBIN_U32("graphics/trainers/palettes/elite_four_agatha.gbapal.lz");
+
+const u32 gTrainerFrontPic_EliteFourLance[] = INCBIN_U32("graphics/trainers/front_pics/elite_four_lance_front_pic.4bpp.lz");
+const u32 gTrainerPalette_EliteFourLance[] = INCBIN_U32("graphics/trainers/palettes/elite_four_lance.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderBrock[] = INCBIN_U32("graphics/trainers/front_pics/leader_brock_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderBrock[] = INCBIN_U32("graphics/trainers/palettes/leader_brock.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderMisty[] = INCBIN_U32("graphics/trainers/front_pics/leader_misty_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderMisty[] = INCBIN_U32("graphics/trainers/palettes/leader_misty.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderLtSurge[] = INCBIN_U32("graphics/trainers/front_pics/leader_lt_surge_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderLtSurge[] = INCBIN_U32("graphics/trainers/palettes/leader_lt_surge.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderErika[] = INCBIN_U32("graphics/trainers/front_pics/leader_erika_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderErika[] = INCBIN_U32("graphics/trainers/palettes/leader_erika.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderKoga[] = INCBIN_U32("graphics/trainers/front_pics/leader_koga_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderKoga[] = INCBIN_U32("graphics/trainers/palettes/leader_koga.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderBlaine[] = INCBIN_U32("graphics/trainers/front_pics/leader_blaine_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderBlaine[] = INCBIN_U32("graphics/trainers/palettes/leader_blaine.gbapal.lz");
+
+const u32 gTrainerFrontPic_LeaderSabrina[] = INCBIN_U32("graphics/trainers/front_pics/leader_sabrina_front_pic.4bpp.lz");
+const u32 gTrainerPalette_LeaderSabrina[] = INCBIN_U32("graphics/trainers/palettes/leader_sabrina.gbapal.lz");
+
+const u32 gTrainerFrontPic_Gentleman[] = INCBIN_U32("graphics/trainers/front_pics/gentleman_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Gentleman[] = INCBIN_U32("graphics/trainers/palettes/gentleman.gbapal.lz");
+
+const u32 gTrainerFrontPic_Rival2[] = INCBIN_U32("graphics/trainers/front_pics/rival_2_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Rival2[] = INCBIN_U32("graphics/trainers/palettes/rival_2.gbapal.lz");
+
+const u32 gTrainerFrontPic_ChampionRival[] = INCBIN_U32("graphics/trainers/front_pics/champion_rival_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ChampionRival[] = INCBIN_U32("graphics/trainers/palettes/champion_rival.gbapal.lz");
+
+const u32 gTrainerFrontPic_Channeler[] = INCBIN_U32("graphics/trainers/front_pics/channeler_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Channeler[] = INCBIN_U32("graphics/trainers/palettes/channeler.gbapal.lz");
+
+const u32 gTrainerFrontPic_Twins[] = INCBIN_U32("graphics/trainers/front_pics/twins_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Twins[] = INCBIN_U32("graphics/trainers/palettes/twins.gbapal.lz");
+
+const u32 gTrainerFrontPic_CoolCouple[] = INCBIN_U32("graphics/trainers/front_pics/cool_couple_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CoolCouple[] = INCBIN_U32("graphics/trainers/palettes/cool_couple.gbapal.lz");
+
+const u32 gTrainerFrontPic_YoungCouple[] = INCBIN_U32("graphics/trainers/front_pics/young_couple_front_pic.4bpp.lz");
+const u32 gTrainerPalette_YoungCouple[] = INCBIN_U32("graphics/trainers/palettes/young_couple.gbapal.lz");
+
+const u32 gTrainerFrontPic_CrushKin[] = INCBIN_U32("graphics/trainers/front_pics/crush_kin_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CrushKin[] = INCBIN_U32("graphics/trainers/palettes/crush_kin.gbapal.lz");
+
+const u32 gTrainerFrontPic_SisAndBro[] = INCBIN_U32("graphics/trainers/front_pics/sis_and_bro_front_pic.4bpp.lz");
+const u32 gTrainerPalette_SisAndBro[] = INCBIN_U32("graphics/trainers/palettes/sis_and_bro.gbapal.lz");
+
+const u32 gTrainerFrontPic_ProfessorOak[] = INCBIN_U32("graphics/trainers/front_pics/professor_oak_front_pic.4bpp.lz");
+const u32 gTrainerPalette_ProfessorOak[] = INCBIN_U32("graphics/trainers/palettes/professor_oak.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSBrendan2[] = INCBIN_U32("graphics/trainers/front_pics/ruby_sapphire_brendan_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSBrendan2[] = INCBIN_U32("graphics/trainers/palettes/ruby_sapphire_brendan.gbapal.lz");
+
+const u32 gTrainerFrontPic_RSMay2[] = INCBIN_U32("graphics/trainers/front_pics/ruby_sapphire_may_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RSMay2[] = INCBIN_U32("graphics/trainers/palettes/ruby_sapphire_may.gbapal.lz");
+
+const u32 gTrainerFrontPic_Red[] = INCBIN_U32("graphics/trainers/front_pics/red_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Red[] = INCBIN_U32("graphics/trainers/palettes/red.gbapal.lz");
+
+const u32 gTrainerFrontPic_Leaf[] = INCBIN_U32("graphics/trainers/front_pics/leaf_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Leaf[] = INCBIN_U32("graphics/trainers/palettes/leaf.gbapal.lz");
+
+const u32 gTrainerFrontPic_RocketGruntF[] = INCBIN_U32("graphics/trainers/front_pics/rocket_grunt_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RocketGruntF[] = INCBIN_U32("graphics/trainers/palettes/rocket_grunt_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_PsychicF[] = INCBIN_U32("graphics/trainers/front_pics/psychic_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PsychicF[] = INCBIN_U32("graphics/trainers/palettes/psychic_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_CrushGirl[] = INCBIN_U32("graphics/trainers/front_pics/crush_girl_front_pic.4bpp.lz");
+const u32 gTrainerPalette_CrushGirl[] = INCBIN_U32("graphics/trainers/palettes/crush_girl.gbapal.lz");
+
+const u32 gTrainerFrontPic_TuberF[] = INCBIN_U32("graphics/trainers/front_pics/tuber_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_TuberF[] = INCBIN_U32("graphics/trainers/palettes/tuber_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokemonBreederF[] = INCBIN_U32("graphics/trainers/front_pics/pokemon_breeder_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokemonBreederF[] = INCBIN_U32("graphics/trainers/palettes/pokemon_breeder_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokemonRangerM[] = INCBIN_U32("graphics/trainers/front_pics/pokemon_ranger_m_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokemonRangerM[] = INCBIN_U32("graphics/trainers/palettes/pokemon_ranger_m.gbapal.lz");
+
+const u32 gTrainerFrontPic_PokemonRangerF[] = INCBIN_U32("graphics/trainers/front_pics/pokemon_ranger_f_front_pic.4bpp.lz");
+const u32 gTrainerPalette_PokemonRangerF[] = INCBIN_U32("graphics/trainers/palettes/pokemon_ranger_f.gbapal.lz");
+
+const u32 gTrainerFrontPic_AromaLady[] = INCBIN_U32("graphics/trainers/front_pics/aroma_lady_front_pic.4bpp.lz");
+const u32 gTrainerPalette_AromaLady[] = INCBIN_U32("graphics/trainers/palettes/aroma_lady.gbapal.lz");
+
+const u32 gTrainerFrontPic_RuinManiac[] = INCBIN_U32("graphics/trainers/front_pics/ruin_maniac_front_pic.4bpp.lz");
+const u32 gTrainerPalette_RuinManiac[] = INCBIN_U32("graphics/trainers/palettes/ruin_maniac.gbapal.lz");
+
+const u32 gTrainerFrontPic_Lady[] = INCBIN_U32("graphics/trainers/front_pics/lady_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Lady[] = INCBIN_U32("graphics/trainers/palettes/lady.gbapal.lz");
+
+const u32 gTrainerFrontPic_Painter[] = INCBIN_U32("graphics/trainers/front_pics/painter_front_pic.4bpp.lz");
+const u32 gTrainerPalette_Painter[] = INCBIN_U32("graphics/trainers/palettes/painter.gbapal.lz");
+
+const u8 gTrainerBackPic_Red[] = INCBIN_U8("graphics/trainers/back_pics/red_back_pic.4bpp");
+const u8 gTrainerBackPic_Leaf[] = INCBIN_U8("graphics/trainers/back_pics/leaf_back_pic.4bpp");
+const u8 gTrainerBackPic_Pokedude[] = INCBIN_U8("graphics/trainers/back_pics/pokedude_back_pic.4bpp");
+const u8 gTrainerBackPic_OldMan[] = INCBIN_U8("graphics/trainers/back_pics/old_man_back_pic.4bpp");
+
+const u8 gTrainerBackPic_RSBrendan[] = INCBIN_U8("graphics/trainers/back_pics/ruby_sapphire_brendan_back_pic.4bpp");
+const u8 gTrainerBackPic_RSMay[] = INCBIN_U8("graphics/trainers/back_pics/ruby_sapphire_may_back_pic.4bpp");
+
+const u32 gTrainerPalette_RedBackPic[] = INCBIN_U32("graphics/trainers/palettes/leaf_back_pic.gbapal.lz");
+const u32 gTrainerPalette_LeafBackPic[] = INCBIN_U32("graphics/trainers/palettes/red_back_pic.gbapal.lz");
+const u32 gTrainerPalette_PokedudeBackPic[] = INCBIN_U32("graphics/trainers/palettes/pokedude_back_pic.gbapal.lz");
+const u32 gTrainerPalette_OldManBackPic[] = INCBIN_U32("graphics/trainers/palettes/old_man_back_pic.gbapal.lz");
diff --git a/src/data/pokemon/trainer_class_lookups.h b/src/data/pokemon/trainer_class_lookups.h
index faf23bf31..2309f85a1 100644
--- a/src/data/pokemon/trainer_class_lookups.h
+++ b/src/data/pokemon/trainer_class_lookups.h
@@ -133,10 +133,10 @@ const u8 gFacilityClassToPicIndex[] =
     [FACILITY_CLASS_CRUSH_KIN] = 130,
     [FACILITY_CLASS_SIS_AND_BRO_2] = 131,
     [FACILITY_CLASS_PKMN_PROF] = 132,
-    [FACILITY_CLASS_PLAYER] = 133,
-    [FACILITY_CLASS_PLAYER_2] = 134,
-    [FACILITY_CLASS_PLAYER_3] = 135,
-    [FACILITY_CLASS_PLAYER_4] = 136,
+    [FACILITY_CLASS_BRENDAN] = TRAINER_PIC_RS_BRENDAN_2,
+    [FACILITY_CLASS_MAY] = TRAINER_PIC_RS_MAY_2,
+    [FACILITY_CLASS_RED] = TRAINER_PIC_RED,
+    [FACILITY_CLASS_LEAF] = TRAINER_PIC_LEAF,
     [FACILITY_CLASS_TEAM_ROCKET_2] = 137,
     [FACILITY_CLASS_PSYCHIC_4] = 138,
     [FACILITY_CLASS_CRUSH_GIRL] = 139,
@@ -287,10 +287,10 @@ const u8 gFacilityClassToTrainerClass[] =
     [FACILITY_CLASS_CRUSH_KIN] = CLASS_CRUSH_KIN,
     [FACILITY_CLASS_SIS_AND_BRO_2] = CLASS_SIS_AND_BRO_2,
     [FACILITY_CLASS_PKMN_PROF] = CLASS_PKMN_PROF,
-    [FACILITY_CLASS_PLAYER] = CLASS_PLAYER,
-    [FACILITY_CLASS_PLAYER_2] = CLASS_PLAYER,
-    [FACILITY_CLASS_PLAYER_3] = CLASS_PLAYER,
-    [FACILITY_CLASS_PLAYER_4] = CLASS_PLAYER,
+    [FACILITY_CLASS_BRENDAN] = CLASS_PLAYER,
+    [FACILITY_CLASS_MAY] = CLASS_PLAYER,
+    [FACILITY_CLASS_RED] = CLASS_PLAYER,
+    [FACILITY_CLASS_LEAF] = CLASS_PLAYER,
     [FACILITY_CLASS_TEAM_ROCKET_2] = CLASS_TEAM_ROCKET,
     [FACILITY_CLASS_PSYCHIC_4] = CLASS_PSYCHIC_2,
     [FACILITY_CLASS_CRUSH_GIRL] = CLASS_CRUSH_GIRL,
diff --git a/src/data/pokemon_graphics/palette_table.h b/src/data/pokemon_graphics/palette_table.h
index 35edcc76c..bb4f64a07 100644
--- a/src/data/pokemon_graphics/palette_table.h
+++ b/src/data/pokemon_graphics/palette_table.h
@@ -1,4 +1,5 @@
-const struct CompressedSpritePalette gMonPaletteTable[] =
+// A dirty hack because field_effect.c requires this not be const
+__attribute__((section(".rodata"))) struct CompressedSpritePalette gMonPaletteTable[] =
 {
     SPECIES_PAL(NONE, gMonPalette_CircledQuestionMark),
     SPECIES_PAL(BULBASAUR, gMonPalette_Bulbasaur),
diff --git a/src/data/text/quest_log.h b/src/data/text/quest_log.h
new file mode 100644
index 000000000..db65f6e47
--- /dev/null
+++ b/src/data/text/quest_log.h
@@ -0,0 +1,125 @@
+const u8 gText_QuestLog_PreviouslyOnYourQuest[] = _("Previously on your quest…");
+const u8 gText_QuestLog_SwitchMon1WithMon2[] = _("{PLAYER} switched the POKéMON\n{STR_VAR_1} with {STR_VAR_2}.");
+const u8 gText_QuestLog_SwappedHeldItemsOnMon[] = _("Took the item {STR_VAR_2} from\n{STR_VAR_1} and gave it the item\n{STR_VAR_3} to hold.");
+const u8 gText_QuestLog_TookHeldItemFromMon[] = _("Took the item {STR_VAR_2} from\n{STR_VAR_1}.");
+const u8 gText_QuestLog_UsedItemOnMonAtThisLocation[] = _("Used the item {STR_VAR_1} on {STR_VAR_2}\nat this location.");
+const u8 gText_QuestLog_UsedTheItem[] = _("{PLAYER} used the\n{STR_VAR_1}.");
+const u8 gText_QuestLog_UsedTheKeyItem[] = _("Used the item {STR_VAR_1}, which was\nin the KEY ITEMS POCKET.");
+const u8 gText_QuestLog_MonLearnedMoveFromTM[] = _("{STR_VAR_1} learned the move\n{STR_VAR_2} from a TM.");
+const u8 gText_QuestLog_MonReplacedMoveWithTM[] = _("{STR_VAR_1} learned the move\n{STR_VAR_2} from a TM and forgot\nthe move {STR_VAR_3}.");
+const u8 gText_QuestLog_MonsWereFullyRestoredAtCenter[] = _("POKéMON were fully restored\nat a POKéMON CENTER.");
+const u8 gText_QuestLog_PlayerBattledChampionRival[] = _("{DYNAMIC 0x00} had a marvelous battle\nwith the CHAMPION, {DYNAMIC 0x01}.");
+const u8 gText_QuestLog_PlayerSentOutMon1RivalSentOutMon2[] = _("In the end, {DYNAMIC 0x00} sent out {DYNAMIC 0x01}\nwhile {DYNAMIC 0x02} countered with\n{DYNAMIC 0x03}.");
+const u8 gText_QuestLog_WonTheMatchAsAResult[] = _("And, as a result of battling with every\nbit of power, {DYNAMIC 0x00} won\nthe match.");
+const u8 gText_QuestLog_StoredItemInPC[] = _("Removed the item {STR_VAR_1} from\nthe BAG's ITEMS POCKET and stored it\non the PC.");
+const u8 gText_QuestLog_WithdrewItemFromPC[] = _("{PLAYER} withdrew the item {STR_VAR_1}\nfrom the PC.");
+const u8 gText_QuestLog_TradedMon1ForPersonsMon2[] = _("Traded {STR_VAR_3} in exchange for\n{STR_VAR_1}'s {STR_VAR_2}.");
+const u8 gText_QuestLog_SingleBattleWithPersonResultedInOutcome[] = _("Took on {DYNAMIC 0x00} in a SINGLE BATTLE.\nIt was a hotly contested match that\nresulted in a {DYNAMIC 0x01}.");
+const u8 gText_QuestLog_DoubleBattleWithPersonResultedInOutcome[] = _("Took on {DYNAMIC 0x00} in a DOUBLE BATTLE.\nIt was an extended match that resulted\nin a {DYNAMIC 0x01}.");
+const u8 gText_QuestLog_MultiBattleWithPeopleResultedInOutcome[] = _("{DYNAMIC 0x00} and {DYNAMIC 0x01} took on\n{DYNAMIC 0x02} and {DYNAMIC 0x03} in a\nMULTI BATTLE and got a {DYNAMIC 0x04}.");
+const u8 gText_QuestLog_Win[] = _("win");
+const u8 gText_QuestLog_Loss[] = _("loss");
+const u8 gText_QuestLog_MingledInUnionRoom[] = _("Mingled with other TRAINERS in\nthe UNION ROOM.");
+const u8 gText_QuestLog_DepartedPlaceInTownForNextDestination[] = _("Departed {STR_VAR_2}\nin {STR_VAR_1} for the next\ndestination.");
+const u8 gText_QuestLog_SwitchedMonsBetweenBoxes[] = _("After consideration, switched\n{DYNAMIC 0x01} in {DYNAMIC 0x00} with\n{DYNAMIC 0x03} in {DYNAMIC 0x02}.");
+const u8 gText_QuestLog_MovedMonToNewBox[] = _("After deep thought, switched\n{DYNAMIC 0x01} in BOX “{DYNAMIC 0x00}” to\nthe BOX “{DYNAMIC 0x02}.”");
+const u8 gText_QuestLog_SwitchedMonsWithinBox[] = _("Switched around {DYNAMIC 0x01} and\n{DYNAMIC 0x02} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_MovedMonWithinBox[] = _("Moved {DYNAMIC 0x01} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_SwitchedPartyMonForPCMon[] = _("Switched {DYNAMIC 0x01} in {DYNAMIC 0x00}\nwith {DYNAMIC 0x02} in the party.");
+const u8 gText_QuestLog_WithdrewMonFromPC[] = _("Added {DYNAMIC 0x01} in {DYNAMIC 0x00}\nto the party.");
+const u8 gText_QuestLog_DepositedMonInPC[] = _("Moved {DYNAMIC 0x00} from the party\nto {DYNAMIC 0x01}.");
+const u8 gText_QuestLog_SwitchedMultipleMons[] = _("Moved a group of POKéMON in\n{DYNAMIC 0x00} to {DYNAMIC 0x01}.");
+const u8 gText_QuestLog_ADifferentSpot[] = _("a different spot");
+const u8 gText_QuestLog_GaveMonHeldItemFromPC[] = _("Removed the item {STR_VAR_1} from\n{PLAYER}'s PC and gave it to {STR_VAR_2}\nto hold.");
+const u8 gText_QuestLog_SwappedHeldItemFromPC[] = _("Removed the item {STR_VAR_1} from\na PC, gave it to {STR_VAR_2}, and put\nthe {STR_VAR_3} it held in the BAG.");
+const u8 gText_QuestLog_ChattedWithManyTrainers[] = _("Chatted with many TRAINERS.");
+const u8 gText_QuestLog_Handily[] = _("handily");
+const u8 gText_QuestLog_Tenaciously[] = _("tenaciously");
+const u8 gText_QuestLog_Somehow[] = _("somehow");
+const u8 gText_QuestLog_TradedMon1ForTrainersMon2[] = _("Met and traded with {STR_VAR_1}.\nObtained the TRAINER's {STR_VAR_2} in\nexchange for {STR_VAR_3}.");
+const u8 gText_QuestLog_BattledTrainerEndedInOutcome[] = _("Met and battled {STR_VAR_1}.\nThe match ended in a {STR_VAR_2}.");
+const u8 gText_QuestLog_BoughtItem[] = _("Went to the POKéMON MART in\n{DYNAMIC 0x00} and bought one \n{DYNAMIC 0x01}.");
+const u8 gText_QuestLog_BoughtItemsIncludingItem[] = _("Went to the POKéMON MART in\n{DYNAMIC 0x00} and spent ¥{DYNAMIC 0x02} for\nitems including {DYNAMIC 0x01}(s).");
+const u8 gText_QuestLog_SoldNumOfItem[] = _("{DYNAMIC 0x00} went to the POKéMON MART in\n{DYNAMIC 0x01} and sold {DYNAMIC 0x03} of\nthe item {DYNAMIC 0x02}.");
+const u8 gText_QuestLog_SoldItemsIncludingItem[] = _("Sold items including {DYNAMIC 0x01} at\nthe POKéMON MART in {DYNAMIC 0x00},\nworth ¥{DYNAMIC 0x02}.");
+const u8 gText_QuestLog_JustOne[] = _("just one");
+const u8 gText_QuestLog_Num[] = _("{DYNAMIC 0x04}");
+const u8 gText_QuestLog_UsedSoftboiled[] = _("{STR_VAR_1} shared its HP using the move\nSOFTBOILED.");
+const u8 gText_QuestLog_UsedMilkDrink[] = _("{STR_VAR_1} shared its HP using the move\nMILK DRINK.");
+const u8 gText_QuestLog_MonLearnedMoveFromHM[] = _("{STR_VAR_1} securely learned the move\n{STR_VAR_2} using an HM.");
+const u8 gText_QuestLog_MonReplacedMoveWithHM[] = _("{STR_VAR_1} securely learned the move\n{STR_VAR_2} using an HM and forgot\nthe move {STR_VAR_3}.");
+const u8 gText_QuestLog_DefeatedWildMon[] = _("{DYNAMIC 0x05} managed to defeat the POKéMON\n{DYNAMIC 0x01} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_DefeatedWildMons[] = _("Defeated {DYNAMIC 0x02} wild POKéMON including\n{DYNAMIC 0x01} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_CaughtWildMon[] = _("{DYNAMIC 0x05} managed to catch the POKéMON\n{DYNAMIC 0x03} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_CaughtWildMons[] = _("Threw POKé BALLS in a frenzy, catching\n{DYNAMIC 0x04} POKéMON including {DYNAMIC 0x03} here\nin {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_DefeatedWildMonAndCaughtWildMon[] = _("{DYNAMIC 0x05} defeated the POKéMON\n{DYNAMIC 0x01} and caught one {DYNAMIC 0x03}\nin {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_DefeatedWildMonAndCaughtWildMons[] = _("Defeated the POKéMON {DYNAMIC 0x01}\nand caught {DYNAMIC 0x04} POKéMON including\n{DYNAMIC 0x03} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_DefeatedWildMonsAndCaughtWildMon[] = _("{DYNAMIC 0x05} defeated {DYNAMIC 0x02} POKéMON including\n{DYNAMIC 0x01} and caught one {DYNAMIC 0x03}\nin {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_DefeatedWildMonsAndCaughtWildMons[] = _("Defeated {DYNAMIC 0x02} POKéMON including\n{DYNAMIC 0x01} and caught {DYNAMIC 0x04} POKéMON\nincluding {DYNAMIC 0x03} in {DYNAMIC 0x00}.");
+const u8 gText_QuestLog_GaveMonHeldItem[] = _("Made {STR_VAR_1} hold the item\n{STR_VAR_2}.");
+const u8 gText_QuestLog_GaveMonHeldItem2[] = _("{PLAYER} made {STR_VAR_1} hold the item\n{STR_VAR_2}.");
+const u8 gText_QuestLog_UsedCut[] = _("{STR_VAR_1} used the Hidden Move\nCUT here.");
+const u8 gText_QuestLog_UsedFly[] = _("{STR_VAR_1} used the Hidden Move\nFLY and flew to {STR_VAR_2}.");
+const u8 gText_QuestLog_UsedSurf[] = _("{STR_VAR_1} used the Hidden Move\nSURF and rode the waves.");
+const u8 gText_QuestLog_UsedStrength[] = _("{STR_VAR_1} used the Hidden Move\nSTRENGTH here.");
+const u8 gText_QuestLog_UsedFlash[] = _("{STR_VAR_1} used the Hidden Move\nFLASH and illuminated a pitch-black\ncave.");
+const u8 gText_QuestLog_UsedRockSmash[] = _("{STR_VAR_1} used the Hidden Move\nROCK SMASH here.");
+const u8 gText_QuestLog_UsedWaterfall[] = _("{STR_VAR_1} used the Hidden Move\nWATERFALL to scale a raging torrent."); // Unused
+const u8 gText_QuestLog_UsedDive[] = _("{STR_VAR_1}は　ふかい　ところを　めざし\nひでんわざ\nダイビングを　つかった！");
+const u8 gText_QuestLog_UsedDigInLocation[] = _("{STR_VAR_1} used DIG to escape from\n{STR_VAR_2}.");
+const u8 gText_QuestLog_UsedSweetScent[] = _("{STR_VAR_1} used SWEET SCENT to attract\nwild POKéMON.");
+const u8 gText_QuestLog_UsedTeleportToLocation[] = _("{STR_VAR_1} used TELEPORT, transporting\nthe party to {STR_VAR_2}'s\n{STR_VAR_3}.");
+const u8 gText_QuestLog_LeftTownsLocationForNextDestination[] = _("{PLAYER} left {STR_VAR_1}'s\n{STR_VAR_2} for the next\ndestination.");
+const u8 gText_QuestLog_PlayedGamesAtGameCorner[] = _("Played a lot of games at the ROCKET\nGAME CORNER in {STR_VAR_1}.");
+const u8 gText_QuestLog_RestedAtHome[] = _("{PLAYER} rested comfortably at home.");
+const u8 gText_QuestLog_LeftOaksLab[] = _("{PLAYER} left PROF. OAK's POKéMON\nRESEARCH LAB.");
+const u8 gText_QuestLog_GymWasFullOfToughTrainers[] = _("The GYM in {STR_VAR_1} was full of\ntough TRAINERS…\nPreparations had to be made.");
+const u8 gText_QuestLog_DepartedGym[] = _("Departed the GYM in {STR_VAR_1}.");
+const u8 gText_QuestLog_HadGreatTimeInSafariZone[] = _("{PLAYER} had a great time with POKéMON\nin the SAFARI ZONE.");
+const u8 gText_QuestLog_ManagedToGetOutOfLocation[] = _("Managed to get out of {STR_VAR_2}\nafter wandering about.");
+const u8 gText_QuestLog_TookOnGymLeadersMonWithMonAndWon[] = _("Took on {DYNAMIC 0x00} GYM LEADER\n{DYNAMIC 0x01}'s {DYNAMIC 0x02} with {DYNAMIC 0x03}\nand won {DYNAMIC 0x04}!");
+const u8 gText_QuestLog_TookOnEliteFoursMonWithMonAndWon[] = _("Took on ELITE FOUR {DYNAMIC 0x00}'s\n{DYNAMIC 0x01} with {DYNAMIC 0x02} and\nwon {DYNAMIC 0x03}!");
+const u8 gText_QuestLog_TookOnTrainersMonWithMonAndWon[] = _("In {DYNAMIC 0x00}, took on\n{DYNAMIC 0x01}'s {DYNAMIC 0x02} with {DYNAMIC 0x03}\nand won {DYNAMIC 0x04}!");
+const u8 gText_QuestLog_Coolly[] = _("coolly");
+const u8 gText_QuestLog_Barely[] = _("barely");
+const u8 gText_QuestLog_UsedEscapeRope[] = _("{PLAYER} used an ESCAPE ROPE to get\nout from {STR_VAR_2}.");
+const u8 gText_QuestLog_Draw[] = _("draw");
+const u8 gText_QuestLog_DepartedTheLocationForNextDestination[] = _("Departed from the {STR_VAR_2}\nfor the next destination.");
+const u8 gText_QuestLog_DepartedFromLocationToNextDestination[] = _("{PLAYER} departed from\n{STR_VAR_2} and made way\nto the next destination.");
+const u8 gText_QuestLog_ObtainedItemInLocation[] = _("Here in {STR_VAR_1}, {PLAYER}\nobtained the item {STR_VAR_2}.");
+const u8 gText_QuestLog_ArrivedInLocation[] = _("Arrived in {STR_VAR_1}.");
+const u8 gText_QuestLog_SavedGameAtLocation[] = _("And {PLAYER} saved the game at this\nlocation: {STR_VAR_1}.");
+const u8 gText_QuestLog_Home[] = _("HOME");
+const u8 gText_QuestLog_OakResearchLab[] = _("OAK RESEARCH LAB");
+const u8 gText_QuestLog_Gym[] = _("GYM");
+const u8 gText_QuestLog_PokemonLeagueGate[] = _("POKéMON LEAGUE GATE");
+const u8 gText_QuestLog_ViridianForest[] = _("VIRIDIAN FOREST");
+const u8 gText_QuestLog_PewterMuseumOfScience[] = _("PEWTER MUSEUM OF SCIENCE");
+const u8 gText_QuestLog_MtMoon[] = _("MT. MOON");
+const u8 gText_QuestLog_BikeShop[] = _("BIKE SHOP");
+const u8 gText_QuestLog_BillsHouse[] = _("BILL'S HOUSE");
+const u8 gText_QuestLog_DayCare[] = _("DAY CARE");
+const u8 gText_QuestLog_UndergroundPath[] = _("UNDERGROUND PATH");
+const u8 gText_QuestLog_PokemonFanClub[] = _("POKéMON FAN CLUB");
+const u8 gText_QuestLog_SSAnne[] = _("S.S. ANNE");
+const u8 gText_QuestLog_DiglettsCave[] = _("DIGLETT'S CAVE");
+const u8 gText_QuestLog_RockTunnel[] = _("ROCK TUNNEL");
+const u8 gText_QuestLog_PowerPlant[] = _("POWER PLANT");
+const u8 gText_QuestLog_PokemonTower[] = _("POKéMON TOWER");
+const u8 gText_QuestLog_VolunteerHouse[] = _("VOLUNTEER HOUSE");
+const u8 gText_QuestLog_NameRatersHouse[] = _("NAME RATER'S HOUSE");
+const u8 gText_QuestLog_CeladonDeptStore[] = _("CELADON DEPT. STORE");
+const u8 gText_QuestLog_CeladonMansion[] = _("CELADON MANSION");
+const u8 gText_QuestLog_RocketGameCorner[] = _("ROCKET GAME CORNER");
+const u8 gText_QuestLog_Restaurant[] = _("RESTAURANT");
+const u8 gText_QuestLog_RocketHideout[] = _("ROCKET HIDEOUT");
+const u8 gText_QuestLog_SafariZone[] = _("SAFARI ZONE");
+const u8 gText_QuestLog_WardensHome[] = _("WARDEN'S HOME");
+const u8 gText_QuestLog_FightingDojo[] = _("FIGHTING DOJO");
+const u8 gText_QuestLog_SilphCo[] = _("SILPH CO.");
+const u8 gText_QuestLog_SeafoamIslands[] = _("SEAFOAM ISLANDS");
+const u8 gText_QuestLog_PokemonMansion[] = _("POKéMON MANSION");
+const u8 gText_QuestLog_PokemonResearchLab[] = _("POKéMON RESEARCH LAB");
+const u8 gText_QuestLog_VictoryRoad[] = _("VICTORY ROAD");
+const u8 gText_QuestLog_PokemonLeague[] = _("POKéMON LEAGUE");
+const u8 gText_QuestLog_CeruleanCave[] = _("CERULEAN CAVE");
diff --git a/src/data/text/teachy_tv.h b/src/data/text/teachy_tv.h
new file mode 100644
index 000000000..3cfa41ff7
--- /dev/null
+++ b/src/data/text/teachy_tv.h
@@ -0,0 +1,198 @@
+const u8 gTeachyTvString_TeachBattle[] = _("Teach me how to battle.");
+const u8 gTeachyTvString_StatusProblems[] = _("What are status problems?");
+const u8 gTeachyTvString_TypeMatchups[] = _("What are type matchups?");
+const u8 gTeachyTvString_CatchPkmn[] = _("I want to catch POKéMON.");
+const u8 gTeachyTvString_AboutTMs[] = _("Teach me about TMs.");
+const u8 gTeachyTvString_RegisterItem[] = _("How do I register an item?");
+const u8 gTeachyTvString_Cancel[] = _("CANCEL");
+const u8 gTeachyTvText_PokedudeSaysHello[] = _(
+    "Hey, all you TRAINERS out there!\n"
+    "HELLO, TRAINERS!\p"
+    "……… ……… ………\p"
+    "Come on, let me hear you!\n"
+    "HELLO, TRAINERS!\l"
+    "It's me, the POKé DUDE!\p");
+const u8 gTeachyTvText_BattleScript1[] = _(
+    "Today, the POKé DUDE's here to\n"
+    "tell you about how you can battle\l"
+    "POKéMON!\p"
+    "Say you're out for a stroll when,\n"
+    "suddenly, a wild POKéMON appears!\p"
+    "It's up to you to smartly use your\n"
+    "POKéMON and their moves to reduce\l"
+    "the opponent's HP to nothing, and\l"
+    "claim victory!\p"
+    "I'll show you how to do that in\n"
+    "person and for sure!\p"
+    "All righty, here goes!\p"
+    "Keep your eyes glued to the super\n"
+    "POKé DUDE SHOW!");
+const u8 gTeachyTvText_BattleScript2[] = _(
+    "Well, did you get that?\p"
+    "Even if your own POKéMON's HP\n"
+    "falls to zero, and it becomes\l"
+    "unable to battle, not to worry!\p"
+    "Just take it to any POKéMON\n"
+    "CENTER and heal it!\p"
+    "All righty, be seeing you!\p"
+    "Remember, TRAINERS, a good deed\n"
+    "a day brings happiness to stay!");
+const u8 gTeachyTvText_StatusScript1[] = _(
+    "Today, the POKé DUDE's here to\n"
+    "tell you about status problems!\p"
+    "Status problems include poisoning,\n"
+    "paralysis, sleep, burn…\p"
+    "There are a couple others, but\n"
+    "they really are trouble.\p"
+    "Get any one, and your POKéMON\n"
+    "may become useless in battle.\p"
+    "You know, it hurts the POKé DUDE\n"
+    "to see a POKéMON suffer…\p"
+    "So, what should you do if your\n"
+    "POKéMON gets a status problem?\p"
+    "Well, you've got me to show you!\p"
+    "All righty, here goes!\p"
+    "Keep your eyes glued to the super\n"
+    "POKé DUDE SHOW!");
+const u8 gTeachyTvText_StatusScript2[] = _(
+    "Poisoning or paralysis don't go\n"
+    "away after a battle.\p"
+    "If a POKéMON is poisoned, it loses\n"
+    "HP even while you're walking.\p"
+    "You should heal POKéMON of these\n"
+    "kinds of problems right away.\p"
+    "Use an item, or try to get to a\n"
+    "POKéMON CENTER for healing.\p"
+    "That wasn't hard, was it?\n"
+    "All righty, be seeing you!\p"
+    "Remember, TRAINERS, a good deed\n"
+    "a day brings happiness to stay!");
+const u8 gTeachyTvText_MatchupsScript1[] = _(
+    "Does everyone know about type\n"
+    "matchups?\p"
+    "POKéMON and their moves all\n"
+    "belong to certain types.\p"
+    "For example, there are such types\n"
+    "as GRASS and WATER.\p"
+    "You need to consider the type of\n"
+    "the move used to attack…\p"
+    "And, the type of the POKéMON that\n"
+    "is hit by that attack.\p"
+    "Depending on how those two types\n"
+    "match up, the damage can change.\p"
+    "You see, it depends on whether\n"
+    "the type matchup is good or bad.\p"
+    "If you don't know how matchups\n"
+    "work, battles will be tough.\p"
+    "So, let me demonstrate exactly\n"
+    "what I mean.\p"
+    "All righty, here goes!\p"
+    "Keep your eyes glued to the super\n"
+    "POKé DUDE SHOW!");
+const u8 gTeachyTvText_MatchupsScript2[] = _(
+    "Is it possible to launch an attack\n"
+    "that will inflict heavy damage?\p"
+    "Does the opposing POKéMON pose\n"
+    "a threat to your POKéMON?\p"
+    "Is there any chance that it may\n"
+    "have disastrously tough moves?\p"
+    "Watch the type matchups to gain\n"
+    "the upper hand!\p"
+    "All righty, be seeing you!\p"
+    "Oh, for the COOL-type POKé DUDE,\n"
+    "AWESOME-type kids like you match\l"
+    "up perfectly!\p"
+    "Remember, a good deed a day\n"
+    "brings happiness to stay!");
+const u8 gTeachyTvText_CatchingScript1[] = _(
+    "Today, the POKé DUDE's going to\n"
+    "show you how to catch POKéMON!\p"
+    "Just imagine… A groovy POKéMON\n"
+    "suddenly appearing in the wild!\p"
+    "Oh, you want it!\n"
+    "You just can't help it!\p"
+    "Oh, you have to catch it!\n"
+    "You gotta have it!\p"
+    "Let me show you how you can make\n"
+    "it happen!\p"
+    "All righty, here goes!\p"
+    "Keep your eyes glued to the super\n"
+    "POKé DUDE SHOW!");
+const u8 gTeachyTvText_CatchingScript2[] = _(
+    "If your first POKé BALL fails to\n"
+    "catch the POKéMON, don't give up!\p"
+    "Keep throwing POKé BALLS…\n"
+    "It's bound to work sometime!\p"
+    "All righty, be seeing you!\p"
+    "Remember, TRAINERS, a good deed\n"
+    "a day brings happiness to stay!");
+const u8 gTeachyTvText_TMsScript1[] = _(
+    "Hey, everyone!\n"
+    "Do you all have TMs?\p"
+    "A TM, Technical Machine, is an\n"
+    "amazingly great item!\p"
+    "It teaches POKéMON a move that\n"
+    "it may not learn when leveling up!\p"
+    "Isn't that just great? What a\n"
+    "convenient world we live in!\p"
+    "Open the TM CASE and check out\n"
+    "the TMs you have.\p"
+    "You can check them out in detail,\n"
+    "too.");
+const u8 gPokedudeText_TMTypes[] = _(
+    "POKé DUDE: NORMAL, WATER, GRASS…\n"
+    "TMs also come in types.\p"
+    "Check the type and teach it to\n"
+    "a POKéMON that matches up well.\p"
+    "For example, WATER PULSE is\n"
+    "suitable for WATER-type POKéMON.\p"
+    "BULLET SEED is a move that most\n"
+    "GRASS-type POKéMON can learn.\p"
+    "There's one other thing!");
+const u8 gPokedudeText_ReadTMDescription[] = _(
+    "Don't just look at the type, read\n"
+    "the description, too.\p"
+    "It will contain hints about what\n"
+    "POKéMON might learn the move.\p"
+    "For example, take a move like\n"
+    "FOCUS PUNCH.\p"
+    "It doesn't sound like anything a\n"
+    "bird or fish POKéMON can learn.\p"
+    "So, try using it on POKéMON with\n"
+    "arms that can throw punches!");
+const u8 gTeachyTvText_TMsScript2[] = _(
+    "Wow, I talked a lot today!\n"
+    "All righty, be seeing you!\p"
+    "Remember, TRAINERS, a good deed\n"
+    "a day brings happiness to stay!");
+const u8 gTeachyTvText_RegisterScript1[] = _(
+    "A TRAINER's BAG has a bunch of\n"
+    "nifty, convenient features!\p"
+    "Take stuff in the KEY ITEMS\n"
+    "POCKET, for instance.\p"
+    "You can use a key item without\n"
+    "opening the BAG every time.\p"
+    "For example, let's pretend I have\n"
+    "a TEACHY TV in my BAG.\p"
+    "I can register it for instant use,\n"
+    "and I'll show you how!\p"
+    "All righty, here goes!\p"
+    "Keep your eyes glued to the sorta\n"
+    "super POKé DUDE SHOW!");
+const u8 gTeachyTvText_RegisterScript2[] = _(
+    "And now, your TEACHY TV is\n"
+    "registered.\p"
+    "How do you use it?\n"
+    "Well, here's how it works.\p"
+    "Once an item in the KEY ITEMS\n"
+    "POKCET is registered, you can use\l"
+    "it by pressing SELECT.\p"
+    "So, you've given yourself\n"
+    "one-touch access to TEACHY TV.\p"
+    "All it takes for you to see me is\n"
+    "pressing one button!\p"
+    "That kind of attention is a little\n"
+    "embarrassing!\p"
+    "All righty, be seeing you!\p"
+    "Remember, TRAINERS, a good deed\n"
+    "a day brings happiness to stay!");
diff --git a/src/data/trainers.h b/src/data/trainers.h
index 4cb0b8443..0c3a3f1ee 100644
--- a/src/data/trainers.h
+++ b/src/data/trainers.h
@@ -22,7 +22,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1A0}
     },
     [TRAINER_TEAM_AQUA_1] = {
@@ -34,7 +34,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1A8}
     },
     [TRAINER_TEAM_AQUA_2] = {
@@ -46,7 +46,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1B0}
     },
     [TRAINER_AROMA_LADY_1] = {
@@ -58,7 +58,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1B8}
     },
     [TRAINER_RUIN_MANIAC_1] = {
@@ -70,7 +70,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1C0}
     },
     [TRAINER_INTERVIEWER_1] = {
@@ -82,7 +82,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1C8}
     },
     [TRAINER_TUBER_1] = {
@@ -94,7 +94,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1D0}
     },
     [TRAINER_TUBER_2] = {
@@ -106,7 +106,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1D8}
     },
     [TRAINER_COOLTRAINER_1] = {
@@ -118,7 +118,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1E0}
     },
     [TRAINER_COOLTRAINER_2] = {
@@ -130,7 +130,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1E8}
     },
     [TRAINER_HEX_MANIAC_1] = {
@@ -142,7 +142,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1F0}
     },
     [TRAINER_LADY_1] = {
@@ -154,7 +154,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A1F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A1F8}
     },
     [TRAINER_BEAUTY_1] = {
@@ -166,7 +166,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A200),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A200}
     },
     [TRAINER_RICH_BOY_1] = {
@@ -178,7 +178,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A208),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A208}
     },
     [TRAINER_POKEMANIAC_1] = {
@@ -190,7 +190,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A210),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A210}
     },
     [TRAINER_SWIMMER_MALE_1] = {
@@ -202,7 +202,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A218),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A218}
     },
     [TRAINER_BLACK_BELT_1] = {
@@ -214,7 +214,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A220),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A220}
     },
     [TRAINER_GUITARIST_1] = {
@@ -226,7 +226,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A228),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A228}
     },
     [TRAINER_KINDLER_1] = {
@@ -238,7 +238,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A230),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A230}
     },
     [TRAINER_CAMPER_1] = {
@@ -250,7 +250,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A238),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A238}
     },
     [TRAINER_BUG_MANIAC_1] = {
@@ -262,7 +262,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A240),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A240}
     },
     [TRAINER_PSYCHIC_1] = {
@@ -274,7 +274,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A248),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A248}
     },
     [TRAINER_PSYCHIC_2] = {
@@ -286,7 +286,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A250),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A250}
     },
     [TRAINER_GENTLEMAN_1] = {
@@ -298,7 +298,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A258),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A258}
     },
     [TRAINER_ELITE_FOUR_SIDNEY] = {
@@ -310,7 +310,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A260),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A260}
     },
     [TRAINER_ELITE_FOUR_PHOEBE] = {
@@ -322,7 +322,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A268),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A268}
     },
     [TRAINER_LEADER_ROXANNE] = {
@@ -334,7 +334,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A270),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A270}
     },
     [TRAINER_LEADER_BRAWLY] = {
@@ -346,7 +346,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A278),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A278}
     },
     [TRAINER_LEADER_TATE_LIZA] = {
@@ -358,7 +358,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A280),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A280}
     },
     [TRAINER_SCHOOL_KID_1] = {
@@ -370,7 +370,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A288),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A288}
     },
     [TRAINER_SCHOOL_KID_2] = {
@@ -382,7 +382,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A290),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A290}
     },
     [TRAINER_SR_AND_JR_1] = {
@@ -394,7 +394,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A298),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A298}
     },
     [TRAINER_POKEFAN_1] = {
@@ -406,7 +406,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2A0}
     },
     [TRAINER_POKEFAN_2] = {
@@ -418,7 +418,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2A8}
     },
     [TRAINER_EXPERT_1] = {
@@ -430,7 +430,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2B0}
     },
     [TRAINER_EXPERT_2] = {
@@ -442,7 +442,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2B8}
     },
     [TRAINER_YOUNGSTER_1] = {
@@ -454,7 +454,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2C0}
     },
     [TRAINER_CHAMPION_1] = {
@@ -466,7 +466,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2C8}
     },
     [TRAINER_FISHERMAN_1] = {
@@ -478,7 +478,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2D0}
     },
     [TRAINER_TRIATHLETE_1] = {
@@ -490,7 +490,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2D8}
     },
     [TRAINER_TRIATHLETE_2] = {
@@ -502,7 +502,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2E0}
     },
     [TRAINER_TRIATHLETE_3] = {
@@ -514,7 +514,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2E8}
     },
     [TRAINER_TRIATHLETE_4] = {
@@ -526,7 +526,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2F0}
     },
     [TRAINER_TRIATHLETE_5] = {
@@ -538,7 +538,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A2F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A2F8}
     },
     [TRAINER_TRIATHLETE_6] = {
@@ -550,7 +550,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A300),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A300}
     },
     [TRAINER_DRAGON_TAMER_1] = {
@@ -562,7 +562,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A308),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A308}
     },
     [TRAINER_BIRD_KEEPER_1] = {
@@ -574,7 +574,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A310),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A310}
     },
     [TRAINER_NINJA_BOY_1] = {
@@ -586,7 +586,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A318),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A318}
     },
     [TRAINER_BATTLE_GIRL_1] = {
@@ -598,7 +598,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A320),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A320}
     },
     [TRAINER_PARASOL_LADY_1] = {
@@ -610,7 +610,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A328),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A328}
     },
     [TRAINER_SWIMMER_FEMALE_1] = {
@@ -622,7 +622,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A330),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A330}
     },
     [TRAINER_PICNICKER_1] = {
@@ -634,7 +634,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A338),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A338}
     },
     [TRAINER_TWINS_1] = {
@@ -646,7 +646,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A340),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A340}
     },
     [TRAINER_SAILOR_1] = {
@@ -658,7 +658,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A348),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A348}
     },
     [TRAINER_BOARDER_1] = {
@@ -670,7 +670,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A350),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A350}
     },
     [TRAINER_BOARDER_2] = {
@@ -682,7 +682,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A358),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A358}
     },
     [TRAINER_COLLECTOR_1] = {
@@ -694,7 +694,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A360),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A360}
     },
     [TRAINER_PKMN_TRAINER_2] = {
@@ -706,7 +706,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A368),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A368}
     },
     [TRAINER_PKMN_TRAINER_3] = {
@@ -718,7 +718,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A370),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A370}
     },
     [TRAINER_PKMN_TRAINER_4] = {
@@ -730,7 +730,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A378),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A378}
     },
     [TRAINER_PKMN_TRAINER_5] = {
@@ -742,7 +742,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A380),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A380}
     },
     [TRAINER_PKMN_TRAINER_6] = {
@@ -754,7 +754,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A388),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A388}
     },
     [TRAINER_PKMN_TRAINER_7] = {
@@ -766,7 +766,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A390),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A390}
     },
     [TRAINER_PKMN_TRAINER_8] = {
@@ -778,7 +778,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A398),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A398}
     },
     [TRAINER_PKMN_BREEDER_1] = {
@@ -790,7 +790,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3A0}
     },
     [TRAINER_PKMN_BREEDER_2] = {
@@ -802,7 +802,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3A8}
     },
     [TRAINER_PKMN_RANGER_1] = {
@@ -814,7 +814,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3B0}
     },
     [TRAINER_PKMN_RANGER_2] = {
@@ -826,7 +826,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3B8}
     },
     [TRAINER_MAGMA_LEADER_1] = {
@@ -838,7 +838,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3C0}
     },
     [TRAINER_TEAM_MAGMA_1] = {
@@ -850,7 +850,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3C8}
     },
     [TRAINER_TEAM_MAGMA_2] = {
@@ -862,7 +862,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3D0}
     },
     [TRAINER_LASS_1] = {
@@ -874,7 +874,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3D8}
     },
     [TRAINER_BUG_CATCHER_1] = {
@@ -886,7 +886,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3E0}
     },
     [TRAINER_HIKER_1] = {
@@ -898,7 +898,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A3E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3E8}
     },
     [TRAINER_YOUNG_COUPLE_1] = {
@@ -910,7 +910,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A3F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A3F0}
     },
     [TRAINER_OLD_COUPLE_1] = {
@@ -922,7 +922,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A400),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A400}
     },
     [TRAINER_SIS_AND_BRO_1] = {
@@ -934,7 +934,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A408),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A408}
     },
     [TRAINER_AQUA_ADMIN_MATT] = {
@@ -946,7 +946,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A410),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A410}
     },
     [TRAINER_AQUA_ADMIN_SHELLY] = {
@@ -958,7 +958,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A418),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A418}
     },
     [TRAINER_MAGMA_ADMIN_TABITHA] = {
@@ -970,7 +970,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A420),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A420}
     },
     [TRAINER_MAGMA_ADMIN_COURTNEY] = {
@@ -982,7 +982,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A428),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A428}
     },
     [TRAINER_LEADER_WATTSON] = {
@@ -994,7 +994,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A430),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A430}
     },
     [TRAINER_LEADER_FLANNERY] = {
@@ -1006,7 +1006,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A438),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A438}
     },
     [TRAINER_LEADER_NORMAN] = {
@@ -1018,7 +1018,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A440),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A440}
     },
     [TRAINER_LEADER_WINONA] = {
@@ -1030,7 +1030,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A448),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A448}
     },
     [TRAINER_LEADER_WALLACE] = {
@@ -1042,7 +1042,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A450),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A450}
     },
     [TRAINER_ELITE_FOUR_GLACIA] = {
@@ -1054,7 +1054,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A458),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A458}
     },
     [TRAINER_ELITE_FOUR_DRAKE] = {
@@ -1066,7 +1066,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A460),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A460}
     },
     [TRAINER_YOUNGSTER_BEN] = {
@@ -1078,7 +1078,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A468),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A468}
     },
     [TRAINER_YOUNGSTER_CALVIN] = {
@@ -1090,7 +1090,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A478),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A478}
     },
     [TRAINER_YOUNGSTER_JOSH] = {
@@ -1102,7 +1102,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A480),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A480}
     },
     [TRAINER_YOUNGSTER_TIMMY] = {
@@ -1114,7 +1114,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A498),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A498}
     },
     [TRAINER_YOUNGSTER_JOEY] = {
@@ -1126,7 +1126,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A4A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4A8}
     },
     [TRAINER_YOUNGSTER_DAN] = {
@@ -1138,7 +1138,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A4B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4B8}
     },
     [TRAINER_YOUNGSTER_CHAD] = {
@@ -1150,7 +1150,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A4C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4C0}
     },
     [TRAINER_YOUNGSTER_TYLER] = {
@@ -1162,7 +1162,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A4D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4D0}
     },
     [TRAINER_YOUNGSTER_EDDIE] = {
@@ -1174,7 +1174,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A4D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4D8}
     },
     [TRAINER_YOUNGSTER_DILLON] = {
@@ -1186,7 +1186,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A4E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4E0}
     },
     [TRAINER_YOUNGSTER_YASU] = {
@@ -1198,7 +1198,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A4F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A4F0}
     },
     [TRAINER_YOUNGSTER_DAVE] = {
@@ -1210,7 +1210,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A508),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A508}
     },
     [TRAINER_YOUNGSTER_BEN_2] = {
@@ -1222,7 +1222,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A518),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A518}
     },
     [TRAINER_BUG_CATCHER_RICK] = {
@@ -1234,7 +1234,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A528),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A528}
     },
     [TRAINER_BUG_CATCHER_DOUG] = {
@@ -1246,7 +1246,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A538),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A538}
     },
     [TRAINER_BUG_CATCHER_SAMMY] = {
@@ -1258,7 +1258,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A550),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A550}
     },
     [TRAINER_BUG_CATCHER_COLTON] = {
@@ -1270,7 +1270,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A558),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A558}
     },
     [TRAINER_BUG_CATCHER_GREG] = {
@@ -1282,7 +1282,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823A570),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A570}
     },
     [TRAINER_BUG_CATCHER_JAMES] = {
@@ -1294,7 +1294,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A590),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A590}
     },
     [TRAINER_BUG_CATCHER_KENT] = {
@@ -1306,7 +1306,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A5A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A5A0}
     },
     [TRAINER_BUG_CATCHER_ROBBY] = {
@@ -1318,7 +1318,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A5B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A5B0}
     },
     [TRAINER_BUG_CATCHER_CALE] = {
@@ -1330,7 +1330,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823A5C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A5C8}
     },
     [TRAINER_BUG_CATCHER_KEIGO] = {
@@ -1342,7 +1342,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A5E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A5E8}
     },
     [TRAINER_BUG_CATCHER_ELIJAH] = {
@@ -1354,7 +1354,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A600),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A600}
     },
     [TRAINER_BUG_CATCHER_2] = {
@@ -1366,7 +1366,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A608),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A608}
     },
     [TRAINER_BUG_CATCHER_BRENT] = {
@@ -1378,7 +1378,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A620),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A620}
     },
     [TRAINER_BUG_CATCHER_CONNER] = {
@@ -1390,7 +1390,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A630),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A630}
     },
     [TRAINER_LASS_JANICE] = {
@@ -1402,7 +1402,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A648),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A648}
     },
     [TRAINER_LASS_SALLY] = {
@@ -1414,7 +1414,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A658),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A658}
     },
     [TRAINER_LASS_ROBIN] = {
@@ -1426,7 +1426,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A668),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A668}
     },
     [TRAINER_LASS_CRISSY] = {
@@ -1438,7 +1438,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A670),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A670}
     },
     [TRAINER_LASS_MIRIAM] = {
@@ -1450,7 +1450,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A688),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A688}
     },
     [TRAINER_LASS_IRIS] = {
@@ -1462,7 +1462,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A698),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A698}
     },
     [TRAINER_LASS_RELI] = {
@@ -1474,7 +1474,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A6A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A6A0}
     },
     [TRAINER_LASS_ALI] = {
@@ -1486,7 +1486,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A6B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A6B0}
     },
     [TRAINER_LASS_2] = {
@@ -1498,7 +1498,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A6C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A6C8}
     },
     [TRAINER_LASS_HALEY] = {
@@ -1510,7 +1510,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A6D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A6D8}
     },
     [TRAINER_LASS_ANN] = {
@@ -1522,7 +1522,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A6F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A6F0}
     },
     [TRAINER_LASS_DAWN] = {
@@ -1534,7 +1534,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A700),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A700}
     },
     [TRAINER_LASS_PAIGE] = {
@@ -1546,7 +1546,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A710),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A710}
     },
     [TRAINER_LASS_ANDREA] = {
@@ -1558,7 +1558,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A720),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A720}
     },
     [TRAINER_LASS_MEGAN] = {
@@ -1570,7 +1570,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823A738),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A738}
     },
     [TRAINER_LASS_JULIA] = {
@@ -1582,7 +1582,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A760),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A760}
     },
     [TRAINER_LASS_KAY] = {
@@ -1594,7 +1594,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A770),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A770}
     },
     [TRAINER_LASS_LISA] = {
@@ -1606,7 +1606,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A780),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A780}
     },
     [TRAINER_SAILOR_EDMOND] = {
@@ -1618,7 +1618,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A790),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A790}
     },
     [TRAINER_SAILOR_TREVOR] = {
@@ -1630,7 +1630,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A7A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7A0}
     },
     [TRAINER_SAILOR_LEONARD] = {
@@ -1642,7 +1642,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A7B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7B0}
     },
     [TRAINER_SAILOR_DUNCAN] = {
@@ -1654,7 +1654,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A7B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7B8}
     },
     [TRAINER_SAILOR_HUEY] = {
@@ -1666,7 +1666,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A7D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7D0}
     },
     [TRAINER_SAILOR_DYLAN] = {
@@ -1678,7 +1678,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A7E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7E0}
     },
     [TRAINER_SAILOR_PHILLIP] = {
@@ -1690,7 +1690,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A7F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A7F8}
     },
     [TRAINER_SAILOR_DWAYNE] = {
@@ -1702,7 +1702,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A800),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A800}
     },
     [TRAINER_CAMPER_LIAM] = {
@@ -1714,7 +1714,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A810),
         .party = {.NoItemCustomMoves = sTrainerMons_823A810}
     },
     [TRAINER_CAMPER_SHANE] = {
@@ -1726,7 +1726,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A830),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A830}
     },
     [TRAINER_CAMPER_ETHAN] = {
@@ -1738,7 +1738,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A840),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A840}
     },
     [TRAINER_CAMPER_RICKY] = {
@@ -1750,7 +1750,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A848),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A848}
     },
     [TRAINER_CAMPER_JEFF] = {
@@ -1762,7 +1762,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A850),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A850}
     },
     [TRAINER_CAMPER_2] = {
@@ -1774,7 +1774,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A860),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A860}
     },
     [TRAINER_CAMPER_CHRIS] = {
@@ -1786,7 +1786,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A868),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A868}
     },
     [TRAINER_CAMPER_DREW] = {
@@ -1798,7 +1798,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823A878),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A878}
     },
     [TRAINER_PICNICKER_DIANA] = {
@@ -1810,7 +1810,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A898),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A898}
     },
     [TRAINER_PICNICKER_NANCY] = {
@@ -1822,7 +1822,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A8A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A8A0}
     },
     [TRAINER_PICNICKER_ISABELLE] = {
@@ -1834,7 +1834,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A8B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A8B0}
     },
     [TRAINER_PICNICKER_KELSEY] = {
@@ -1846,7 +1846,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A8C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A8C8}
     },
     [TRAINER_PICNICKER_ALICIA] = {
@@ -1858,7 +1858,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823A8D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A8D8}
     },
     [TRAINER_PICNICKER_CAITLIN] = {
@@ -1870,7 +1870,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A8F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A8F8}
     },
     [TRAINER_PICNICKER_HEIDI] = {
@@ -1882,7 +1882,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A900),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A900}
     },
     [TRAINER_PICNICKER_CAROL] = {
@@ -1894,7 +1894,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A910),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A910}
     },
     [TRAINER_PICNICKER_SOFIA] = {
@@ -1906,7 +1906,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A920),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A920}
     },
     [TRAINER_PICNICKER_MARTHA] = {
@@ -1918,7 +1918,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A938),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A938}
     },
     [TRAINER_PICNICKER_TINA] = {
@@ -1930,7 +1930,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A948),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A948}
     },
     [TRAINER_PICNICKER_HANNAH] = {
@@ -1942,7 +1942,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823A958),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A958}
     },
     [TRAINER_POKEMANIAC_MARK] = {
@@ -1954,7 +1954,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A980),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A980}
     },
     [TRAINER_POKEMANIAC_HERMAN] = {
@@ -1966,7 +1966,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A990),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A990}
     },
     [TRAINER_POKEMANIAC_COOPER] = {
@@ -1978,7 +1978,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A9A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9A0}
     },
     [TRAINER_POKEMANIAC_STEVE] = {
@@ -1990,7 +1990,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A9B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9B8}
     },
     [TRAINER_POKEMANIAC_WINSTON] = {
@@ -2002,7 +2002,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823A9C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9C8}
     },
     [TRAINER_POKEMANIAC_DAWSON] = {
@@ -2014,7 +2014,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823A9D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9D0}
     },
     [TRAINER_POKEMANIAC_ASHTON] = {
@@ -2026,7 +2026,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A9E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9E8}
     },
     [TRAINER_SUPER_NERD_JOVAN] = {
@@ -2038,7 +2038,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823A9F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823A9F8}
     },
     [TRAINER_SUPER_NERD_MIGUEL] = {
@@ -2050,7 +2050,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AA08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AA08}
     },
     [TRAINER_SUPER_NERD_AIDAN] = {
@@ -2062,7 +2062,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AA20),
         .party = {.NoItemCustomMoves = sTrainerMons_823AA20}
     },
     [TRAINER_SUPER_NERD_GLENN] = {
@@ -2074,7 +2074,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AA60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AA60}
     },
     [TRAINER_SUPER_NERD_LESLIE] = {
@@ -2086,7 +2086,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AA78),
         .party = {.NoItemCustomMoves = sTrainerMons_823AA78}
     },
     [TRAINER_SUPER_NERD_1] = {
@@ -2098,7 +2098,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AA88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AA88}
     },
     [TRAINER_SUPER_NERD_2] = {
@@ -2110,7 +2110,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AAA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AAA0}
     },
     [TRAINER_SUPER_NERD_3] = {
@@ -2122,7 +2122,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AAC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AAC0}
     },
     [TRAINER_SUPER_NERD_ERIK] = {
@@ -2134,7 +2134,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AAD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AAD0}
     },
     [TRAINER_SUPER_NERD_AVERY] = {
@@ -2146,7 +2146,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AAE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AAE8}
     },
     [TRAINER_SUPER_NERD_DEREK] = {
@@ -2158,7 +2158,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AB08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB08}
     },
     [TRAINER_SUPER_NERD_ZAC] = {
@@ -2170,7 +2170,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AB10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB10}
     },
     [TRAINER_HIKER_MARCOS] = {
@@ -2182,7 +2182,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AB20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB20}
     },
     [TRAINER_HIKER_FRANKLIN] = {
@@ -2194,7 +2194,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AB38),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB38}
     },
     [TRAINER_HIKER_NOB] = {
@@ -2206,7 +2206,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AB48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB48}
     },
     [TRAINER_HIKER_WAYNE] = {
@@ -2218,7 +2218,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AB68),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB68}
     },
     [TRAINER_HIKER_ALAN] = {
@@ -2230,7 +2230,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AB70),
         .party = {.NoItemCustomMoves = sTrainerMons_823AB70}
     },
     [TRAINER_HIKER_BRICE] = {
@@ -2242,7 +2242,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AB90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AB90}
     },
     [TRAINER_HIKER_CLARK] = {
@@ -2254,7 +2254,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823ABA8),
         .party = {.NoItemCustomMoves = sTrainerMons_823ABA8}
     },
     [TRAINER_HIKER_TRENT] = {
@@ -2266,7 +2266,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823ABC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823ABC8}
     },
     [TRAINER_HIKER_DUDLEY] = {
@@ -2278,7 +2278,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823ABD8),
         .party = {.NoItemCustomMoves = sTrainerMons_823ABD8}
     },
     [TRAINER_HIKER_ALLEN] = {
@@ -2290,7 +2290,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AC08),
         .party = {.NoItemCustomMoves = sTrainerMons_823AC08}
     },
     [TRAINER_HIKER_ERIC] = {
@@ -2302,7 +2302,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AC18),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AC18}
     },
     [TRAINER_HIKER_LENNY] = {
@@ -2314,7 +2314,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AC28),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AC28}
     },
     [TRAINER_HIKER_OLIVER] = {
@@ -2326,7 +2326,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AC48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AC48}
     },
     [TRAINER_HIKER_LUCAS] = {
@@ -2338,7 +2338,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AC60),
         .party = {.NoItemCustomMoves = sTrainerMons_823AC60}
     },
     [TRAINER_BIKER_JARED] = {
@@ -2350,7 +2350,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AC80),
         .party = {.NoItemCustomMoves = sTrainerMons_823AC80}
     },
     [TRAINER_BIKER_MALIK] = {
@@ -2362,7 +2362,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823ACB0),
         .party = {.NoItemCustomMoves = sTrainerMons_823ACB0}
     },
     [TRAINER_BIKER_ERNEST] = {
@@ -2374,7 +2374,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823ACD0),
         .party = {.NoItemCustomMoves = sTrainerMons_823ACD0}
     },
     [TRAINER_BIKER_ALEX] = {
@@ -2386,7 +2386,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AD20),
         .party = {.NoItemCustomMoves = sTrainerMons_823AD20}
     },
     [TRAINER_BIKER_LAO] = {
@@ -2398,7 +2398,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AD50),
         .party = {.NoItemCustomMoves = sTrainerMons_823AD50}
     },
     [TRAINER_BIKER_1] = {
@@ -2410,7 +2410,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AD70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AD70}
     },
     [TRAINER_BIKER_HIDEO] = {
@@ -2422,7 +2422,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AD78),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AD78}
     },
     [TRAINER_BIKER_RUBEN] = {
@@ -2434,7 +2434,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AD80),
         .party = {.NoItemCustomMoves = sTrainerMons_823AD80}
     },
     [TRAINER_BIKER_BILLY] = {
@@ -2446,7 +2446,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823ADB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823ADB0}
     },
     [TRAINER_BIKER_NIKOLAS] = {
@@ -2458,7 +2458,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823ADB8),
         .party = {.NoItemCustomMoves = sTrainerMons_823ADB8}
     },
     [TRAINER_BIKER_JAXON] = {
@@ -2470,7 +2470,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823ADD8),
         .party = {.NoItemCustomMoves = sTrainerMons_823ADD8}
     },
     [TRAINER_BIKER_WILLIAM] = {
@@ -2482,7 +2482,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823ADF8),
         .party = {.NoItemCustomMoves = sTrainerMons_823ADF8}
     },
     [TRAINER_BIKER_LUKAS] = {
@@ -2494,7 +2494,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823AE48),
         .party = {.NoItemCustomMoves = sTrainerMons_823AE48}
     },
     [TRAINER_BIKER_ISAAC] = {
@@ -2506,7 +2506,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AE88),
         .party = {.NoItemCustomMoves = sTrainerMons_823AE88}
     },
     [TRAINER_BIKER_GERALD] = {
@@ -2518,7 +2518,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AEB8),
         .party = {.NoItemCustomMoves = sTrainerMons_823AEB8}
     },
     [TRAINER_BURGLAR_1] = {
@@ -2530,7 +2530,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AED8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AED8}
     },
     [TRAINER_BURGLAR_2] = {
@@ -2542,7 +2542,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AEE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AEE8}
     },
     [TRAINER_BURGLAR_3] = {
@@ -2554,7 +2554,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AEF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AEF0}
     },
     [TRAINER_BURGLAR_QUINN] = {
@@ -2566,7 +2566,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AF08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF08}
     },
     [TRAINER_BURGLAR_RAMON] = {
@@ -2578,7 +2578,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AF20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF20}
     },
     [TRAINER_BURGLAR_DUSTY] = {
@@ -2590,7 +2590,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AF28),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF28}
     },
     [TRAINER_BURGLAR_ARNIE] = {
@@ -2602,7 +2602,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AF38),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF38}
     },
     [TRAINER_BURGLAR_4] = {
@@ -2614,7 +2614,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AF48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF48}
     },
     [TRAINER_BURGLAR_SIMON] = {
@@ -2626,7 +2626,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AF58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF58}
     },
     [TRAINER_BURGLAR_LEWIS] = {
@@ -2638,7 +2638,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AF60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF60}
     },
     [TRAINER_ENGINEER_BAILY] = {
@@ -2650,7 +2650,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AF70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF70}
     },
     [TRAINER_ENGINEER_BRAXTON] = {
@@ -2662,7 +2662,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AF80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF80}
     },
     [TRAINER_ENGINEER_BERNIE] = {
@@ -2674,7 +2674,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AF88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AF88}
     },
     [TRAINER_FISHERMAN_DALE] = {
@@ -2686,7 +2686,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AFA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AFA0}
     },
     [TRAINER_FISHERMAN_BARNY] = {
@@ -2698,7 +2698,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AFB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AFB8}
     },
     [TRAINER_FISHERMAN_NED] = {
@@ -2710,7 +2710,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823AFD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AFD0}
     },
     [TRAINER_FISHERMAN_CHIP] = {
@@ -2722,7 +2722,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823AFE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AFE8}
     },
     [TRAINER_FISHERMAN_HANK] = {
@@ -2734,7 +2734,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823AFF8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823AFF8}
     },
     [TRAINER_FISHERMAN_ELLIOT] = {
@@ -2746,7 +2746,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B000),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B000}
     },
     [TRAINER_FISHERMAN_RONALD] = {
@@ -2758,7 +2758,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B020),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B020}
     },
     [TRAINER_FISHERMAN_CLAUDE] = {
@@ -2770,7 +2770,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B040),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B040}
     },
     [TRAINER_FISHERMAN_WADE] = {
@@ -2782,7 +2782,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823B050),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B050}
     },
     [TRAINER_FISHERMAN_NOLAN] = {
@@ -2794,7 +2794,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B080),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B080}
     },
     [TRAINER_FISHERMAN_ANDREW] = {
@@ -2806,7 +2806,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B090),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B090}
     },
     [TRAINER_SWIMMER_MALE_LUIS] = {
@@ -2818,7 +2818,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B0A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B0A0}
     },
     [TRAINER_SWIMMER_MALE_RICHARD] = {
@@ -2830,7 +2830,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B0B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B0B0}
     },
     [TRAINER_SWIMMER_MALE_REECE] = {
@@ -2842,7 +2842,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B0C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B0C0}
     },
     [TRAINER_SWIMMER_MALE_MATTHEW] = {
@@ -2854,7 +2854,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B0D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B0D8}
     },
     [TRAINER_SWIMMER_MALE_DOUGLAS] = {
@@ -2866,7 +2866,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B0E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B0E8}
     },
     [TRAINER_SWIMMER_MALE_DAVID] = {
@@ -2878,7 +2878,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B108),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B108}
     },
     [TRAINER_SWIMMER_MALE_TONY] = {
@@ -2890,7 +2890,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B120),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B120}
     },
     [TRAINER_SWIMMER_MALE_AXLE] = {
@@ -2902,7 +2902,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823B130),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B130}
     },
     [TRAINER_SWIMMER_MALE_BARRY] = {
@@ -2914,7 +2914,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B158),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B158}
     },
     [TRAINER_SWIMMER_MALE_DEAN] = {
@@ -2926,7 +2926,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B168),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B168}
     },
     [TRAINER_SWIMMER_MALE_DARRIN] = {
@@ -2938,7 +2938,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B170),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B170}
     },
     [TRAINER_SWIMMER_MALE_SPENCER] = {
@@ -2950,7 +2950,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B190),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B190}
     },
     [TRAINER_SWIMMER_MALE_JACK] = {
@@ -2962,7 +2962,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B1A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1A0}
     },
     [TRAINER_SWIMMER_MALE_JEROME] = {
@@ -2974,7 +2974,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B1A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1A8}
     },
     [TRAINER_SWIMMER_MALE_ROLAND] = {
@@ -2986,7 +2986,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B1B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1B8}
     },
     [TRAINER_CUE_BALL_KOJI] = {
@@ -2998,7 +2998,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B1D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1D0}
     },
     [TRAINER_CUE_BALL_LUKE] = {
@@ -3010,7 +3010,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B1E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1E8}
     },
     [TRAINER_CUE_BALL_CAMRON] = {
@@ -3022,7 +3022,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B1F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B1F8}
     },
     [TRAINER_CUE_BALL_RAUL] = {
@@ -3034,7 +3034,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B208),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B208}
     },
     [TRAINER_CUE_BALL_ISAIAH] = {
@@ -3046,7 +3046,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B218),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B218}
     },
     [TRAINER_CUE_BALL_ZEEK] = {
@@ -3058,7 +3058,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B228),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B228}
     },
     [TRAINER_CUE_BALL_JAMAL] = {
@@ -3070,7 +3070,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B230),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B230}
     },
     [TRAINER_CUE_BALL_COREY] = {
@@ -3082,7 +3082,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B250),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B250}
     },
     [TRAINER_CUE_BALL_CHASE] = {
@@ -3094,7 +3094,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B260),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B260}
     },
     [TRAINER_GAMER_HUGO] = {
@@ -3106,7 +3106,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B278),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B278}
     },
     [TRAINER_GAMER_JASPER] = {
@@ -3118,7 +3118,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B288),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B288}
     },
     [TRAINER_GAMER_DIRK] = {
@@ -3130,7 +3130,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B298),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B298}
     },
     [TRAINER_GAMER_DARIAN] = {
@@ -3142,7 +3142,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B2A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B2A8}
     },
     [TRAINER_GAMER_STAN] = {
@@ -3154,7 +3154,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B2B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B2B8}
     },
     [TRAINER_GAMER_1] = {
@@ -3166,7 +3166,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B2D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B2D0}
     },
     [TRAINER_GAMER_RICH] = {
@@ -3178,7 +3178,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B2D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B2D8}
     },
     [TRAINER_BEAUTY_BRIDGET] = {
@@ -3190,7 +3190,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B2E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B2E8}
     },
     [TRAINER_BEAUTY_TAMIA] = {
@@ -3202,7 +3202,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B308),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B308}
     },
     [TRAINER_BEAUTY_LORI] = {
@@ -3214,7 +3214,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B318),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B318}
     },
     [TRAINER_BEAUTY_LOLA] = {
@@ -3226,7 +3226,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B320),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B320}
     },
     [TRAINER_BEAUTY_SHEILA] = {
@@ -3238,7 +3238,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B338),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B338}
     },
     [TRAINER_SWIMMER_FEMALE_TIFFANY] = {
@@ -3250,7 +3250,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B348),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B348}
     },
     [TRAINER_SWIMMER_FEMALE_NORA] = {
@@ -3262,7 +3262,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B350),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B350}
     },
     [TRAINER_SWIMMER_FEMALE_MELISSA] = {
@@ -3274,7 +3274,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B368),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B368}
     },
     [TRAINER_BEAUTY_GRACE] = {
@@ -3286,7 +3286,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B378),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B378}
     },
     [TRAINER_BEAUTY_OLIVIA] = {
@@ -3298,7 +3298,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B388),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B388}
     },
     [TRAINER_BEAUTY_LAUREN] = {
@@ -3310,7 +3310,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B398),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B398}
     },
     [TRAINER_SWIMMER_FEMALE_ANYA] = {
@@ -3322,7 +3322,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823B3B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B3B0}
     },
     [TRAINER_SWIMMER_FEMALE_ALICE] = {
@@ -3334,7 +3334,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B3D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B3D8}
     },
     [TRAINER_SWIMMER_FEMALE_CONNIE] = {
@@ -3346,7 +3346,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B3E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B3E8}
     },
     [TRAINER_SWIMMER_FEMALE_SHIRLEY] = {
@@ -3358,7 +3358,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B400),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B400}
     },
     [TRAINER_PSYCHIC_JOHAN] = {
@@ -3370,7 +3370,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B418),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B418}
     },
     [TRAINER_PSYCHIC_TYRON] = {
@@ -3382,7 +3382,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B438),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B438}
     },
     [TRAINER_PSYCHIC_CAMERON] = {
@@ -3394,7 +3394,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B448),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B448}
     },
     [TRAINER_PSYCHIC_PRESTON] = {
@@ -3406,7 +3406,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B460),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B460}
     },
     [TRAINER_ROCKER_RANDALL] = {
@@ -3418,7 +3418,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B468),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B468}
     },
     [TRAINER_ROCKER_LUCA] = {
@@ -3430,7 +3430,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B480),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B480}
     },
     [TRAINER_JUGGLER_DALTON] = {
@@ -3442,7 +3442,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B490),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B490}
     },
     [TRAINER_JUGGLER_NELSON] = {
@@ -3454,7 +3454,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B4A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B4A0}
     },
     [TRAINER_JUGGLER_KIRK] = {
@@ -3466,7 +3466,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B4C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B4C0}
     },
     [TRAINER_JUGGLER_SHAWN] = {
@@ -3478,7 +3478,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B4E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B4E0}
     },
     [TRAINER_JUGGLER_GREGORY] = {
@@ -3490,7 +3490,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B4F0),
         .party = {.NoItemCustomMoves = sTrainerMons_823B4F0}
     },
     [TRAINER_JUGGLER_EDWARD] = {
@@ -3502,7 +3502,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B500),
         .party = {.NoItemCustomMoves = sTrainerMons_823B500}
     },
     [TRAINER_JUGGLER_KAYDEN] = {
@@ -3514,7 +3514,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B540),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B540}
     },
     [TRAINER_JUGGLER_NATE] = {
@@ -3526,7 +3526,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B548),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B548}
     },
     [TRAINER_TAMER_PHIL] = {
@@ -3538,7 +3538,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B558),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B558}
     },
     [TRAINER_TAMER_EDGAR] = {
@@ -3550,7 +3550,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B568),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B568}
     },
     [TRAINER_TAMER_JASON] = {
@@ -3562,7 +3562,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B580),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B580}
     },
     [TRAINER_TAMER_COLE] = {
@@ -3574,7 +3574,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B588),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B588}
     },
     [TRAINER_TAMER_VINCENT] = {
@@ -3586,7 +3586,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B598),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B598}
     },
     [TRAINER_TAMER_JOHN] = {
@@ -3598,7 +3598,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B5A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B5A8}
     },
     [TRAINER_BIRD_KEEPER_SEBASTIAN] = {
@@ -3610,7 +3610,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B5C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B5C8}
     },
     [TRAINER_BIRD_KEEPER_PERRY] = {
@@ -3622,7 +3622,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823B5D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B5D8}
     },
     [TRAINER_BIRD_KEEPER_ROBERT] = {
@@ -3634,7 +3634,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B600),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B600}
     },
     [TRAINER_BIRD_KEEPER_DONALD] = {
@@ -3646,7 +3646,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B620),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B620}
     },
     [TRAINER_BIRD_KEEPER_BENNY] = {
@@ -3658,7 +3658,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B628),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B628}
     },
     [TRAINER_BIRD_KEEPER_EDWIN] = {
@@ -3670,7 +3670,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B638),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B638}
     },
     [TRAINER_BIRD_KEEPER_CHESTER] = {
@@ -3682,7 +3682,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B658),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B658}
     },
     [TRAINER_BIRD_KEEPER_WILTON] = {
@@ -3694,7 +3694,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B670),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B670}
     },
     [TRAINER_BIRD_KEEPER_RAMIRO] = {
@@ -3706,7 +3706,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B680),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B680}
     },
     [TRAINER_BIRD_KEEPER_JACOB] = {
@@ -3718,7 +3718,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B688),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B688}
     },
     [TRAINER_BIRD_KEEPER_ROGER] = {
@@ -3730,7 +3730,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B6A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B6A8}
     },
     [TRAINER_BIRD_KEEPER_REED] = {
@@ -3742,7 +3742,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B6C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B6C0}
     },
     [TRAINER_BIRD_KEEPER_KEITH] = {
@@ -3754,7 +3754,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B6E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B6E0}
     },
     [TRAINER_BIRD_KEEPER_CARTER] = {
@@ -3766,7 +3766,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B6F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B6F0}
     },
     [TRAINER_BIRD_KEEPER_MITCH] = {
@@ -3778,7 +3778,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B708),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B708}
     },
     [TRAINER_BIRD_KEEPER_BECK] = {
@@ -3790,7 +3790,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B728),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B728}
     },
     [TRAINER_BIRD_KEEPER_MARLON] = {
@@ -3802,7 +3802,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B738),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B738}
     },
     [TRAINER_BLACK_BELT_KOICHI] = {
@@ -3814,7 +3814,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B750),
         .party = {.ItemDefaultMoves = sTrainerMons_823B750}
     },
     [TRAINER_BLACK_BELT_MIKE] = {
@@ -3826,7 +3826,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B760),
         .party = {.ItemDefaultMoves = sTrainerMons_823B760}
     },
     [TRAINER_BLACK_BELT_HIDEKI] = {
@@ -3838,7 +3838,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B778),
         .party = {.ItemDefaultMoves = sTrainerMons_823B778}
     },
     [TRAINER_BLACK_BELT_AARON] = {
@@ -3850,7 +3850,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B788),
         .party = {.ItemDefaultMoves = sTrainerMons_823B788}
     },
     [TRAINER_BLACK_BELT_HITOSHI] = {
@@ -3862,7 +3862,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B790),
         .party = {.ItemDefaultMoves = sTrainerMons_823B790}
     },
     [TRAINER_BLACK_BELT_ATSUSHI] = {
@@ -3874,7 +3874,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B7A8),
         .party = {.ItemDefaultMoves = sTrainerMons_823B7A8}
     },
     [TRAINER_BLACK_BELT_KIYO] = {
@@ -3886,7 +3886,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B7B8),
         .party = {.ItemDefaultMoves = sTrainerMons_823B7B8}
     },
     [TRAINER_BLACK_BELT_TAKASHI] = {
@@ -3898,7 +3898,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B7C0),
         .party = {.ItemDefaultMoves = sTrainerMons_823B7C0}
     },
     [TRAINER_BLACK_BELT_DAISUKE] = {
@@ -3910,7 +3910,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B7D8),
         .party = {.ItemDefaultMoves = sTrainerMons_823B7D8}
     },
     [TRAINER_RIVAL_OAKS_LAB_SQUIRTLE] = {
@@ -3922,7 +3922,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B7F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B7F0}
     },
     [TRAINER_RIVAL_OAKS_LAB_BULBASAUR] = {
@@ -3934,7 +3934,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B7F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B7F8}
     },
     [TRAINER_RIVAL_OAKS_LAB_CHARMANDER] = {
@@ -3946,7 +3946,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B800),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B800}
     },
     [TRAINER_RIVAL_ROUTE22_EARLY_SQUIRTLE] = {
@@ -3958,7 +3958,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B808),
         .party = {.NoItemCustomMoves = sTrainerMons_823B808}
     },
     [TRAINER_RIVAL_ROUTE22_EARLY_BULBASAUR] = {
@@ -3970,7 +3970,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B828),
         .party = {.NoItemCustomMoves = sTrainerMons_823B828}
     },
     [TRAINER_RIVAL_ROUTE22_EARLY_CHARMANDER] = {
@@ -3982,7 +3982,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B848),
         .party = {.NoItemCustomMoves = sTrainerMons_823B848}
     },
     [TRAINER_RIVAL_CERULEAN_SQUIRTLE] = {
@@ -3994,7 +3994,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B868),
         .party = {.NoItemCustomMoves = sTrainerMons_823B868}
     },
     [TRAINER_RIVAL_CERULEAN_BULBASAUR] = {
@@ -4006,7 +4006,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B8A8),
         .party = {.NoItemCustomMoves = sTrainerMons_823B8A8}
     },
     [TRAINER_RIVAL_CERULEAN_CHARMANDER] = {
@@ -4018,7 +4018,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B8E8),
         .party = {.NoItemCustomMoves = sTrainerMons_823B8E8}
     },
     [TRAINER_SCIENTIST_TED] = {
@@ -4030,7 +4030,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B928),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B928}
     },
     [TRAINER_SCIENTIST_CONNOR] = {
@@ -4042,7 +4042,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B938),
         .party = {.NoItemCustomMoves = sTrainerMons_823B938}
     },
     [TRAINER_SCIENTIST_JERRY] = {
@@ -4054,7 +4054,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823B978),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B978}
     },
     [TRAINER_SCIENTIST_JOSE] = {
@@ -4066,7 +4066,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823B990),
         .party = {.NoItemCustomMoves = sTrainerMons_823B990}
     },
     [TRAINER_SCIENTIST_RODNEY] = {
@@ -4078,7 +4078,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823B9B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823B9B0}
     },
     [TRAINER_SCIENTIST_BEAU] = {
@@ -4090,7 +4090,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823B9B8),
         .party = {.NoItemCustomMoves = sTrainerMons_823B9B8}
     },
     [TRAINER_SCIENTIST_TAYLOR] = {
@@ -4102,7 +4102,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823B9F8),
         .party = {.NoItemCustomMoves = sTrainerMons_823B9F8}
     },
     [TRAINER_SCIENTIST_JOSHUA] = {
@@ -4114,7 +4114,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BA48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BA48}
     },
     [TRAINER_SCIENTIST_PARKER] = {
@@ -4126,7 +4126,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BA58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BA58}
     },
     [TRAINER_SCIENTIST_ED] = {
@@ -4138,7 +4138,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BA68),
         .party = {.NoItemCustomMoves = sTrainerMons_823BA68}
     },
     [TRAINER_SCIENTIST_TRAVIS] = {
@@ -4150,7 +4150,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BA98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BA98}
     },
     [TRAINER_SCIENTIST_BRAYDON] = {
@@ -4162,7 +4162,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BAA8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BAA8}
     },
     [TRAINER_SCIENTIST_IVAN] = {
@@ -4174,7 +4174,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BAC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BAC0}
     },
     [TRAINER_BOSS_GIOVANNI] = {
@@ -4186,7 +4186,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BAD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BAD0}
     },
     [TRAINER_BOSS_GIOVANNI_2] = {
@@ -4198,7 +4198,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823BAE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BAE8}
     },
     [TRAINER_LEADER_GIOVANNI] = {
@@ -4210,7 +4210,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION, ITEM_HYPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BB08),
         .party = {.NoItemCustomMoves = sTrainerMons_823BB08}
     },
     [TRAINER_TEAM_ROCKET_GRUNT] = {
@@ -4222,7 +4222,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BB58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BB58}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_2] = {
@@ -4234,7 +4234,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BB68),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BB68}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_3] = {
@@ -4246,7 +4246,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BB80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BB80}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_4] = {
@@ -4258,7 +4258,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BB90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BB90}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_5] = {
@@ -4270,7 +4270,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BBA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BBA0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_6] = {
@@ -4282,7 +4282,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BBB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BBB0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_7] = {
@@ -4294,7 +4294,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BBC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BBC0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_8] = {
@@ -4306,7 +4306,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BBD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BBD0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_9] = {
@@ -4318,7 +4318,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BBE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BBE0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_10] = {
@@ -4330,7 +4330,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BBF0),
         .party = {.NoItemCustomMoves = sTrainerMons_823BBF0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_11] = {
@@ -4342,7 +4342,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823BC20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BC20}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_12] = {
@@ -4354,7 +4354,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BC40),
         .party = {.NoItemCustomMoves = sTrainerMons_823BC40}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_13] = {
@@ -4366,7 +4366,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BC60),
         .party = {.NoItemCustomMoves = sTrainerMons_823BC60}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_14] = {
@@ -4378,7 +4378,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BCB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BCB0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_15] = {
@@ -4390,7 +4390,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BCC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BCC8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_16] = {
@@ -4402,7 +4402,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BCD8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BCD8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_17] = {
@@ -4414,7 +4414,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BCF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BCF0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_18] = {
@@ -4426,7 +4426,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BD08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD08}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_19] = {
@@ -4438,7 +4438,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BD18),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD18}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_20] = {
@@ -4450,7 +4450,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BD30),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD30}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_21] = {
@@ -4462,7 +4462,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823BD40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD40}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_22] = {
@@ -4474,7 +4474,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BD60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD60}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_23] = {
@@ -4486,7 +4486,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BD70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD70}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_24] = {
@@ -4498,7 +4498,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BD80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BD80}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_25] = {
@@ -4510,7 +4510,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BDA8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDA8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_26] = {
@@ -4522,7 +4522,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BDC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDC0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_27] = {
@@ -4534,7 +4534,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BDD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDD0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_28] = {
@@ -4546,7 +4546,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823BDE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDE8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_29] = {
@@ -4558,7 +4558,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823BDF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDF0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_30] = {
@@ -4570,7 +4570,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BDF8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BDF8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_31] = {
@@ -4582,7 +4582,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BE08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BE08}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_32] = {
@@ -4594,7 +4594,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823BE20),
         .party = {.NoItemCustomMoves = sTrainerMons_823BE20}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_33] = {
@@ -4606,7 +4606,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BE60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BE60}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_34] = {
@@ -4618,7 +4618,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823BE70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BE70}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_35] = {
@@ -4630,7 +4630,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823BE80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BE80}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_36] = {
@@ -4642,7 +4642,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BEA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BEA0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_37] = {
@@ -4654,7 +4654,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BEB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BEB8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_38] = {
@@ -4666,7 +4666,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BED0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BED0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_39] = {
@@ -4678,7 +4678,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823BEE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BEE8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_40] = {
@@ -4690,7 +4690,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BEF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BEF0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_41] = {
@@ -4702,7 +4702,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823BF18),
         .party = {.NoItemDefaultMoves = sTrainerMons_823BF18}
     },
     [TRAINER_COOLTRAINER_SAMUEL] = {
@@ -4714,7 +4714,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_SUPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BF30),
         .party = {.NoItemCustomMoves = sTrainerMons_823BF30}
     },
     [TRAINER_COOLTRAINER_GEORGE] = {
@@ -4726,7 +4726,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BF80),
         .party = {.NoItemCustomMoves = sTrainerMons_823BF80}
     },
     [TRAINER_COOLTRAINER_COLBY] = {
@@ -4738,7 +4738,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823BFD0),
         .party = {.NoItemCustomMoves = sTrainerMons_823BFD0}
     },
     [TRAINER_COOLTRAINER_PAUL] = {
@@ -4750,7 +4750,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C020),
         .party = {.NoItemCustomMoves = sTrainerMons_823C020}
     },
     [TRAINER_COOLTRAINER_ROLANDO] = {
@@ -4762,7 +4762,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C070),
         .party = {.NoItemCustomMoves = sTrainerMons_823C070}
     },
     [TRAINER_COOLTRAINER_GILBERT] = {
@@ -4774,7 +4774,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C0C0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C0C0}
     },
     [TRAINER_COOLTRAINER_OWEN] = {
@@ -4786,7 +4786,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C110),
         .party = {.NoItemCustomMoves = sTrainerMons_823C110}
     },
     [TRAINER_COOLTRAINER_BERKE] = {
@@ -4798,7 +4798,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C160),
         .party = {.NoItemCustomMoves = sTrainerMons_823C160}
     },
     [TRAINER_COOLTRAINER_YUJI] = {
@@ -4810,7 +4810,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C1B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C1B0}
     },
     [TRAINER_COOLTRAINER_WARREN] = {
@@ -4822,7 +4822,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C200),
         .party = {.NoItemCustomMoves = sTrainerMons_823C200}
     },
     [TRAINER_COOLTRAINER_MARY] = {
@@ -4834,7 +4834,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_SUPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C250),
         .party = {.NoItemCustomMoves = sTrainerMons_823C250}
     },
     [TRAINER_COOLTRAINER_CAROLINE] = {
@@ -4846,7 +4846,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C2A0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C2A0}
     },
     [TRAINER_COOLTRAINER_ALEXA] = {
@@ -4858,7 +4858,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C2F0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C2F0}
     },
     [TRAINER_COOLTRAINER_SHANNON] = {
@@ -4870,7 +4870,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C340),
         .party = {.NoItemCustomMoves = sTrainerMons_823C340}
     },
     [TRAINER_COOLTRAINER_NAOMI] = {
@@ -4882,7 +4882,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C390),
         .party = {.NoItemCustomMoves = sTrainerMons_823C390}
     },
     [TRAINER_COOLTRAINER_BROOKE] = {
@@ -4894,7 +4894,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C3E0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C3E0}
     },
     [TRAINER_COOLTRAINER_AUSTINA] = {
@@ -4906,7 +4906,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C430),
         .party = {.NoItemCustomMoves = sTrainerMons_823C430}
     },
     [TRAINER_COOLTRAINER_JULIE] = {
@@ -4918,7 +4918,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C480),
         .party = {.NoItemCustomMoves = sTrainerMons_823C480}
     },
     [TRAINER_ELITE_FOUR_LORELEI] = {
@@ -4930,7 +4930,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C4D0),
         .party = {.ItemCustomMoves = sTrainerMons_823C4D0}
     },
     [TRAINER_ELITE_FOUR_BRUNO] = {
@@ -4942,7 +4942,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C520),
         .party = {.ItemCustomMoves = sTrainerMons_823C520}
     },
     [TRAINER_ELITE_FOUR_AGATHA] = {
@@ -4954,7 +4954,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C570),
         .party = {.ItemCustomMoves = sTrainerMons_823C570}
     },
     [TRAINER_ELITE_FOUR_LANCE] = {
@@ -4966,7 +4966,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C5C0),
         .party = {.ItemCustomMoves = sTrainerMons_823C5C0}
     },
     [TRAINER_LEADER_BROCK] = {
@@ -4978,7 +4978,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823C610),
         .party = {.NoItemCustomMoves = sTrainerMons_823C610}
     },
     [TRAINER_LEADER_MISTY] = {
@@ -4990,7 +4990,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_SUPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823C630),
         .party = {.NoItemCustomMoves = sTrainerMons_823C630}
     },
     [TRAINER_LEADER_LT_SURGE] = {
@@ -5002,7 +5002,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_SUPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823C650),
         .party = {.NoItemCustomMoves = sTrainerMons_823C650}
     },
     [TRAINER_LEADER_ERIKA] = {
@@ -5014,7 +5014,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823C680),
         .party = {.NoItemCustomMoves = sTrainerMons_823C680}
     },
     [TRAINER_LEADER_KOGA] = {
@@ -5026,7 +5026,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION, ITEM_HYPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C6B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C6B0}
     },
     [TRAINER_LEADER_BLAINE] = {
@@ -5038,7 +5038,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION, ITEM_HYPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C6F0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C6F0}
     },
     [TRAINER_LEADER_SABRINA] = {
@@ -5050,7 +5050,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION, ITEM_HYPER_POTION, ITEM_FULL_HEAL},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C730),
         .party = {.NoItemCustomMoves = sTrainerMons_823C730}
     },
     [TRAINER_GENTLEMAN_THOMAS] = {
@@ -5062,7 +5062,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823C770),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C770}
     },
     [TRAINER_GENTLEMAN_ARTHUR] = {
@@ -5074,7 +5074,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823C780),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C780}
     },
     [TRAINER_GENTLEMAN_TUCKER] = {
@@ -5086,7 +5086,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823C790),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C790}
     },
     [TRAINER_GENTLEMAN_NORTON] = {
@@ -5098,7 +5098,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823C798),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C798}
     },
     [TRAINER_GENTLEMAN_WALTER] = {
@@ -5110,7 +5110,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823C7A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C7A0}
     },
     [TRAINER_RIVAL_SS_ANNE_SQUIRTLE] = {
@@ -5122,7 +5122,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C7B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C7B0}
     },
     [TRAINER_RIVAL_SS_ANNE_BULBASAUR] = {
@@ -5134,7 +5134,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C7D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C7D0}
     },
     [TRAINER_RIVAL_SS_ANNE_CHARMANDER] = {
@@ -5146,7 +5146,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823C7F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C7F0}
     },
     [TRAINER_RIVAL_POKENON_TOWER_SQUIRTLE] = {
@@ -5158,7 +5158,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C810),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C810}
     },
     [TRAINER_RIVAL_POKENON_TOWER_BULBASAUR] = {
@@ -5170,7 +5170,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C838),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C838}
     },
     [TRAINER_RIVAL_POKENON_TOWER_CHARMANDER] = {
@@ -5182,7 +5182,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C860),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C860}
     },
     [TRAINER_RIVAL_SILPH_SQUIRTLE] = {
@@ -5194,7 +5194,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C888),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C888}
     },
     [TRAINER_RIVAL_SILPH_BULBASAUR] = {
@@ -5206,7 +5206,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C8B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C8B0}
     },
     [TRAINER_RIVAL_SILPH_CHARMANDER] = {
@@ -5218,7 +5218,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823C8D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823C8D8}
     },
     [TRAINER_RIVAL_ROUTE22_LATE_SQUIRTLE] = {
@@ -5230,7 +5230,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823C900),
         .party = {.NoItemCustomMoves = sTrainerMons_823C900}
     },
     [TRAINER_RIVAL_ROUTE22_LATE_BULBASAUR] = {
@@ -5242,7 +5242,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823C960),
         .party = {.NoItemCustomMoves = sTrainerMons_823C960}
     },
     [TRAINER_RIVAL_ROUTE22_LATE_CHARMANDER] = {
@@ -5254,7 +5254,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823C9C0),
         .party = {.NoItemCustomMoves = sTrainerMons_823C9C0}
     },
     [TRAINER_CHAMPION_FIRST_SQUIRTLE] = {
@@ -5266,7 +5266,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823CA20),
         .party = {.ItemCustomMoves = sTrainerMons_823CA20}
     },
     [TRAINER_CHAMPION_FIRST_BULBASAUR] = {
@@ -5278,7 +5278,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823CA80),
         .party = {.ItemCustomMoves = sTrainerMons_823CA80}
     },
     [TRAINER_CHAMPION_FIRST_CHARMANDER] = {
@@ -5290,7 +5290,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823CAE0),
         .party = {.ItemCustomMoves = sTrainerMons_823CAE0}
     },
     [TRAINER_CHANNELER_PATRICIA] = {
@@ -5302,7 +5302,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB40}
     },
     [TRAINER_CHANNELER_CARLY] = {
@@ -5314,7 +5314,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB48}
     },
     [TRAINER_CHANNELER_HOPE] = {
@@ -5326,7 +5326,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB50),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB50}
     },
     [TRAINER_CHANNELER_PAULA] = {
@@ -5338,7 +5338,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB58}
     },
     [TRAINER_CHANNELER_LAUREL] = {
@@ -5350,7 +5350,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CB60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB60}
     },
     [TRAINER_CHANNELER_JODY] = {
@@ -5362,7 +5362,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB70}
     },
     [TRAINER_CHANNELER_TAMMY] = {
@@ -5374,7 +5374,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB78),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB78}
     },
     [TRAINER_CHANNELER_RUTH] = {
@@ -5386,7 +5386,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB80}
     },
     [TRAINER_CHANNELER_KARINA] = {
@@ -5398,7 +5398,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB88}
     },
     [TRAINER_CHANNELER_JANAE] = {
@@ -5410,7 +5410,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CB90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB90}
     },
     [TRAINER_CHANNELER_ANGELICA] = {
@@ -5422,7 +5422,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CB98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CB98}
     },
     [TRAINER_CHANNELER_EMILIA] = {
@@ -5434,7 +5434,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBB0}
     },
     [TRAINER_CHANNELER_JENNIFER] = {
@@ -5446,7 +5446,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBB8}
     },
     [TRAINER_CHANNELER_1] = {
@@ -5458,7 +5458,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBC0}
     },
     [TRAINER_CHANNELER_2] = {
@@ -5470,7 +5470,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBC8}
     },
     [TRAINER_CHANNELER_3] = {
@@ -5482,7 +5482,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBD0}
     },
     [TRAINER_CHANNELER_4] = {
@@ -5494,7 +5494,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBD8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBD8}
     },
     [TRAINER_CHANNELER_5] = {
@@ -5506,7 +5506,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CBE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBE0}
     },
     [TRAINER_CHANNELER_6] = {
@@ -5518,7 +5518,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CBE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CBE8}
     },
     [TRAINER_CHANNELER_7] = {
@@ -5530,7 +5530,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CC00),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC00}
     },
     [TRAINER_CHANNELER_8] = {
@@ -5542,7 +5542,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CC08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC08}
     },
     [TRAINER_CHANNELER_AMANDA] = {
@@ -5554,7 +5554,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CC10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC10}
     },
     [TRAINER_CHANNELER_STACY] = {
@@ -5566,7 +5566,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CC20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC20}
     },
     [TRAINER_CHANNELER_TASHA] = {
@@ -5578,7 +5578,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CC28),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC28}
     },
     [TRAINER_HIKER_JEREMY] = {
@@ -5590,7 +5590,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CC40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC40}
     },
     [TRAINER_PICNICKER_ALMA] = {
@@ -5602,7 +5602,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CC50),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC50}
     },
     [TRAINER_PICNICKER_SUSIE] = {
@@ -5614,7 +5614,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823CC68),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC68}
     },
     [TRAINER_PICNICKER_VALERIE] = {
@@ -5626,7 +5626,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CC90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CC90}
     },
     [TRAINER_PICNICKER_GWEN] = {
@@ -5638,7 +5638,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823CCA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CCA0}
     },
     [TRAINER_BIKER_VIRGIL] = {
@@ -5650,7 +5650,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CCC0),
         .party = {.NoItemCustomMoves = sTrainerMons_823CCC0}
     },
     [TRAINER_CAMPER_FLINT] = {
@@ -5662,7 +5662,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CCF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CCF0}
     },
     [TRAINER_PICNICKER_MISSY] = {
@@ -5674,7 +5674,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CD00),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD00}
     },
     [TRAINER_PICNICKER_IRENE] = {
@@ -5686,7 +5686,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CD10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD10}
     },
     [TRAINER_PICNICKER_DANA] = {
@@ -5698,7 +5698,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CD28),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD28}
     },
     [TRAINER_PICNICKER_ARIANA] = {
@@ -5710,7 +5710,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823CD40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD40}
     },
     [TRAINER_PICNICKER_LEAH] = {
@@ -5722,7 +5722,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CD60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD60}
     },
     [TRAINER_CAMPER_JUSTIN] = {
@@ -5734,7 +5734,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CD70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD70}
     },
     [TRAINER_PICNICKER_YAZMIN] = {
@@ -5746,7 +5746,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CD80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD80}
     },
     [TRAINER_PICNICKER_KINDRA] = {
@@ -5758,7 +5758,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CD98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CD98}
     },
     [TRAINER_PICNICKER_BECKY] = {
@@ -5770,7 +5770,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CDB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CDB0}
     },
     [TRAINER_PICNICKER_CELIA] = {
@@ -5782,7 +5782,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CDC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CDC0}
     },
     [TRAINER_GENTLEMAN_BROOKS] = {
@@ -5794,7 +5794,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CDC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CDC8}
     },
     [TRAINER_GENTLEMAN_LAMAR] = {
@@ -5806,7 +5806,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CDD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CDD0}
     },
     [TRAINER_TWINS_ELI_ANNE] = {
@@ -5818,7 +5818,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CDE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CDE0}
     },
     [TRAINER_COOL_COUPLE_RAY_TYRA] = {
@@ -5830,7 +5830,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CDF0),
         .party = {.NoItemCustomMoves = sTrainerMons_823CDF0}
     },
     [TRAINER_YOUNG_COUPLE_GIA_JES] = {
@@ -5842,7 +5842,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE10}
     },
     [TRAINER_TWINS_KIRI_JAN] = {
@@ -5854,7 +5854,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE20}
     },
     [TRAINER_CRUSH_KIN_RON_MYA] = {
@@ -5866,7 +5866,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE30),
         .party = {.ItemDefaultMoves = sTrainerMons_823CE30}
     },
     [TRAINER_YOUNG_COUPLE_LEA_JED] = {
@@ -5878,7 +5878,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE40}
     },
     [TRAINER_SIS_AND_BRO_LIA_LUC] = {
@@ -5890,7 +5890,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE50),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE50}
     },
     [TRAINER_SIS_AND_BRO_LIL_IAN] = {
@@ -5902,7 +5902,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CE60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE60}
     },
     [TRAINER_BUG_CATCHER_3] = {
@@ -5914,7 +5914,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE70}
     },
     [TRAINER_BUG_CATCHER_4] = {
@@ -5926,7 +5926,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE78),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE78}
     },
     [TRAINER_BUG_CATCHER_5] = {
@@ -5938,7 +5938,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE80}
     },
     [TRAINER_BUG_CATCHER_6] = {
@@ -5950,7 +5950,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE88}
     },
     [TRAINER_BUG_CATCHER_7] = {
@@ -5962,7 +5962,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE90}
     },
     [TRAINER_BUG_CATCHER_8] = {
@@ -5974,7 +5974,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CE98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CE98}
     },
     [TRAINER_YOUNGSTER_BEN_3] = {
@@ -5986,7 +5986,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CEA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CEA0}
     },
     [TRAINER_YOUNGSTER_BEN_4] = {
@@ -5998,7 +5998,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CEB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CEB0}
     },
     [TRAINER_YOUNGSTER_CHAD_2] = {
@@ -6010,7 +6010,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CEC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CEC0}
     },
     [TRAINER_LASS_RELI_2] = {
@@ -6022,7 +6022,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CED0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CED0}
     },
     [TRAINER_LASS_RELI_3] = {
@@ -6034,7 +6034,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CEE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CEE0}
     },
     [TRAINER_YOUNGSTER_TIMMY_2] = {
@@ -6046,7 +6046,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CEF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CEF0}
     },
     [TRAINER_YOUNGSTER_TIMMY_3] = {
@@ -6058,7 +6058,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CF08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF08}
     },
     [TRAINER_YOUNGSTER_TIMMY_4] = {
@@ -6070,7 +6070,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CF20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF20}
     },
     [TRAINER_YOUNGSTER_CHAD_3] = {
@@ -6082,7 +6082,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CF38),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF38}
     },
     [TRAINER_LASS_JANICE_2] = {
@@ -6094,7 +6094,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CF48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF48}
     },
     [TRAINER_LASS_JANICE_3] = {
@@ -6106,7 +6106,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CF58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF58}
     },
     [TRAINER_YOUNGSTER_CHAD_4] = {
@@ -6118,7 +6118,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CF68),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF68}
     },
     [TRAINER_HIKER_FRANKLIN_2] = {
@@ -6130,7 +6130,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CF78),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF78}
     },
     [TRAINER_PKMN_PROF_PROF_OAK] = {
@@ -6142,7 +6142,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CF88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF88}
     },
     [TRAINER_PLAYER_BRENDAN] = {
@@ -6154,7 +6154,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CF90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF90}
     },
     [TRAINER_PLAYER_MAY] = {
@@ -6166,7 +6166,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CF98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CF98}
     },
     [TRAINER_PLAYER_RED] = {
@@ -6178,7 +6178,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CFA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CFA0}
     },
     [TRAINER_PLAYER_LEAF] = {
@@ -6190,7 +6190,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823CFA8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CFA8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_42] = {
@@ -6202,7 +6202,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CFB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823CFB0}
     },
     [TRAINER_PSYCHIC_JACLYN] = {
@@ -6214,7 +6214,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823CFC0),
         .party = {.NoItemCustomMoves = sTrainerMons_823CFC0}
     },
     [TRAINER_CRUSH_GIRL_SHARON] = {
@@ -6226,7 +6226,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823CFF0),
         .party = {.ItemDefaultMoves = sTrainerMons_823CFF0}
     },
     [TRAINER_TUBER_AMIRA] = {
@@ -6238,7 +6238,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D000),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D000}
     },
     [TRAINER_PKMN_BREEDER_ALIZE] = {
@@ -6250,7 +6250,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D018),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D018}
     },
     [TRAINER_PKMN_RANGER_NICOLAS] = {
@@ -6262,7 +6262,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D030),
         .party = {.NoItemCustomMoves = sTrainerMons_823D030}
     },
     [TRAINER_PKMN_RANGER_MADELINE] = {
@@ -6274,7 +6274,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D050),
         .party = {.NoItemCustomMoves = sTrainerMons_823D050}
     },
     [TRAINER_AROMA_LADY_NIKKI] = {
@@ -6286,7 +6286,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D070),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D070}
     },
     [TRAINER_RUIN_MANIAC_STANLY] = {
@@ -6298,7 +6298,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D080),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D080}
     },
     [TRAINER_LADY_JACKI] = {
@@ -6310,7 +6310,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D098),
         .party = {.ItemDefaultMoves = sTrainerMons_823D098}
     },
     [TRAINER_PAINTER_DAISY] = {
@@ -6322,7 +6322,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D0A8),
         .party = {.NoItemCustomMoves = sTrainerMons_823D0A8}
     },
     [TRAINER_BIKER_GOON] = {
@@ -6334,7 +6334,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D0B8),
         .party = {.NoItemCustomMoves = sTrainerMons_823D0B8}
     },
     [TRAINER_BIKER_GOON_2] = {
@@ -6346,7 +6346,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D0D8),
         .party = {.NoItemCustomMoves = sTrainerMons_823D0D8}
     },
     [TRAINER_BIKER_GOON_3] = {
@@ -6358,7 +6358,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D0E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D0E8}
     },
     [TRAINER_BIKER_2] = {
@@ -6370,7 +6370,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D0F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D0F0}
     },
     [TRAINER_BUG_CATCHER_ANTHONY] = {
@@ -6382,7 +6382,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D0F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D0F8}
     },
     [TRAINER_BUG_CATCHER_CHARLIE] = {
@@ -6394,7 +6394,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D108),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D108}
     },
     [TRAINER_TWINS_ELI_ANNE_2] = {
@@ -6406,7 +6406,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D120),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D120}
     },
     [TRAINER_YOUNGSTER_JOHNSON] = {
@@ -6418,7 +6418,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D130),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D130}
     },
     [TRAINER_BIKER_RICARDO] = {
@@ -6430,7 +6430,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D148),
         .party = {.NoItemCustomMoves = sTrainerMons_823D148}
     },
     [TRAINER_BIKER_JAREN] = {
@@ -6442,7 +6442,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D178),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D178}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_43] = {
@@ -6454,7 +6454,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D188),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D188}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_44] = {
@@ -6466,7 +6466,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D198),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D198}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_45] = {
@@ -6478,7 +6478,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D1B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D1B8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_46] = {
@@ -6490,7 +6490,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D1D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D1D0}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_47] = {
@@ -6502,7 +6502,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D1E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D1E8}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_48] = {
@@ -6514,7 +6514,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D200),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D200}
     },
     [TRAINER_TEAM_ROCKET_ADMIN] = {
@@ -6526,7 +6526,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D210),
         .party = {.NoItemCustomMoves = sTrainerMons_823D210}
     },
     [TRAINER_TEAM_ROCKET_ADMIN_2] = {
@@ -6538,7 +6538,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D240),
         .party = {.NoItemCustomMoves = sTrainerMons_823D240}
     },
     [TRAINER_SCIENTIST_GIDEON] = {
@@ -6550,7 +6550,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823D270),
         .party = {.NoItemCustomMoves = sTrainerMons_823D270}
     },
     [TRAINER_SWIMMER_FEMALE_AMARA] = {
@@ -6562,7 +6562,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D2C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D2C0}
     },
     [TRAINER_SWIMMER_FEMALE_MARIA] = {
@@ -6574,7 +6574,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D2D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D2D8}
     },
     [TRAINER_SWIMMER_FEMALE_ABIGAIL] = {
@@ -6586,7 +6586,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D2E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D2E8}
     },
     [TRAINER_SWIMMER_MALE_FINN] = {
@@ -6598,7 +6598,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D300),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D300}
     },
     [TRAINER_SWIMMER_MALE_GARRETT] = {
@@ -6610,7 +6610,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D308),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D308}
     },
     [TRAINER_FISHERMAN_TOMMY] = {
@@ -6622,7 +6622,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823D320),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D320}
     },
     [TRAINER_CRUSH_GIRL_TANYA] = {
@@ -6634,7 +6634,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D348),
         .party = {.ItemDefaultMoves = sTrainerMons_823D348}
     },
     [TRAINER_BLACK_BELT_SHEA] = {
@@ -6646,7 +6646,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D358),
         .party = {.ItemDefaultMoves = sTrainerMons_823D358}
     },
     [TRAINER_BLACK_BELT_HUGH] = {
@@ -6658,7 +6658,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D368),
         .party = {.ItemDefaultMoves = sTrainerMons_823D368}
     },
     [TRAINER_CAMPER_BRYCE] = {
@@ -6670,7 +6670,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D378),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D378}
     },
     [TRAINER_PICNICKER_CLAIRE] = {
@@ -6682,7 +6682,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D390),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D390}
     },
     [TRAINER_CRUSH_KIN_MIK_KIA] = {
@@ -6694,7 +6694,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D3B0),
         .party = {.ItemDefaultMoves = sTrainerMons_823D3B0}
     },
     [TRAINER_AROMA_LADY_VIOLET] = {
@@ -6706,7 +6706,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D3C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D3C0}
     },
     [TRAINER_TUBER_ALEXIS] = {
@@ -6718,7 +6718,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D3D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D3D8}
     },
     [TRAINER_TWINS_JOY_MEG] = {
@@ -6730,7 +6730,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D3F8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D3F8}
     },
     [TRAINER_SWIMMER_FEMALE_TISHA] = {
@@ -6742,7 +6742,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D408),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D408}
     },
     [TRAINER_PAINTER_CELINA] = {
@@ -6754,7 +6754,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D410),
         .party = {.NoItemCustomMoves = sTrainerMons_823D410}
     },
     [TRAINER_PAINTER_RAYNA] = {
@@ -6766,7 +6766,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D420),
         .party = {.NoItemCustomMoves = sTrainerMons_823D420}
     },
     [TRAINER_LADY_GILLIAN] = {
@@ -6778,7 +6778,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D430),
         .party = {.ItemDefaultMoves = sTrainerMons_823D430}
     },
     [TRAINER_YOUNGSTER_DESTIN] = {
@@ -6790,7 +6790,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D448),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D448}
     },
     [TRAINER_SWIMMER_MALE_TOBY] = {
@@ -6802,7 +6802,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D458),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D458}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_49] = {
@@ -6814,7 +6814,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D470),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D470}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_50] = {
@@ -6826,7 +6826,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D488),
         .party = {.NoItemCustomMoves = sTrainerMons_823D488}
     },
     [TRAINER_TEAM_ROCKET_GRUNT_51] = {
@@ -6838,7 +6838,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D4A8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D4A8}
     },
     [TRAINER_BIRD_KEEPER_MILO] = {
@@ -6850,7 +6850,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D4C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D4C0}
     },
     [TRAINER_BIRD_KEEPER_CHAZ] = {
@@ -6862,7 +6862,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D4D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D4D0}
     },
     [TRAINER_BIRD_KEEPER_HAROLD] = {
@@ -6874,7 +6874,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D4E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D4E0}
     },
     [TRAINER_FISHERMAN_TYLOR] = {
@@ -6886,7 +6886,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D4F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D4F0}
     },
     [TRAINER_SWIMMER_MALE_MYMO] = {
@@ -6898,7 +6898,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D500),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D500}
     },
     [TRAINER_SWIMMER_FEMALE_NICOLE] = {
@@ -6910,7 +6910,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D510),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D510}
     },
     [TRAINER_SIS_AND_BRO_AVA_GEB] = {
@@ -6922,7 +6922,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D518),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D518}
     },
     [TRAINER_AROMA_LADY_ROSE] = {
@@ -6934,7 +6934,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D528),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D528}
     },
     [TRAINER_SWIMMER_MALE_SAMIR] = {
@@ -6946,7 +6946,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D538),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D538}
     },
     [TRAINER_SWIMMER_FEMALE_DENISE] = {
@@ -6958,7 +6958,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D540),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D540}
     },
     [TRAINER_TWINS_MIU_MIA] = {
@@ -6970,7 +6970,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D550),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D550}
     },
     [TRAINER_HIKER_EARL] = {
@@ -6982,7 +6982,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D560),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D560}
     },
     [TRAINER_RUIN_MANIAC_FOSTER] = {
@@ -6994,7 +6994,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D570),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D570}
     },
     [TRAINER_RUIN_MANIAC_LARRY] = {
@@ -7006,7 +7006,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D578),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D578}
     },
     [TRAINER_HIKER_DARYL] = {
@@ -7018,7 +7018,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D588),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D588}
     },
     [TRAINER_POKEMANIAC_HECTOR] = {
@@ -7030,7 +7030,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D590),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D590}
     },
     [TRAINER_PSYCHIC_DARIO] = {
@@ -7042,7 +7042,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D5A0),
         .party = {.NoItemCustomMoves = sTrainerMons_823D5A0}
     },
     [TRAINER_PSYCHIC_RODETTE] = {
@@ -7054,7 +7054,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D5B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823D5B0}
     },
     [TRAINER_AROMA_LADY_MIAH] = {
@@ -7066,7 +7066,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D5E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D5E0}
     },
     [TRAINER_YOUNG_COUPLE_EVE_JON] = {
@@ -7078,7 +7078,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D5F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D5F0}
     },
     [TRAINER_JUGGLER_MASON] = {
@@ -7090,7 +7090,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D600),
         .party = {.NoItemCustomMoves = sTrainerMons_823D600}
     },
     [TRAINER_CRUSH_GIRL_CYNDY] = {
@@ -7102,7 +7102,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D640),
         .party = {.ItemDefaultMoves = sTrainerMons_823D640}
     },
     [TRAINER_CRUSH_GIRL_JOCELYN] = {
@@ -7114,7 +7114,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D658),
         .party = {.ItemDefaultMoves = sTrainerMons_823D658}
     },
     [TRAINER_TAMER_EVAN] = {
@@ -7126,7 +7126,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D668),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D668}
     },
     [TRAINER_POKEMANIAC_MARK_2] = {
@@ -7138,7 +7138,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D680),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D680}
     },
     [TRAINER_PKMN_RANGER_LOGAN] = {
@@ -7150,7 +7150,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D690),
         .party = {.NoItemCustomMoves = sTrainerMons_823D690}
     },
     [TRAINER_PKMN_RANGER_JACKSON] = {
@@ -7162,7 +7162,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D6B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823D6B0}
     },
     [TRAINER_PKMN_RANGER_BETH] = {
@@ -7174,7 +7174,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D6E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D6E0}
     },
     [TRAINER_PKMN_RANGER_KATELYN] = {
@@ -7186,7 +7186,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D6F8),
         .party = {.NoItemCustomMoves = sTrainerMons_823D6F8}
     },
     [TRAINER_COOLTRAINER_LEROY] = {
@@ -7198,7 +7198,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823D708),
         .party = {.NoItemCustomMoves = sTrainerMons_823D708}
     },
     [TRAINER_COOLTRAINER_MICHELLE] = {
@@ -7210,7 +7210,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823D758),
         .party = {.NoItemCustomMoves = sTrainerMons_823D758}
     },
     [TRAINER_COOL_COUPLE_LEX_NYA] = {
@@ -7222,7 +7222,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D7A8),
         .party = {.NoItemCustomMoves = sTrainerMons_823D7A8}
     },
     [TRAINER_RUIN_MANIAC_BRANDON] = {
@@ -7234,7 +7234,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D7C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D7C8}
     },
     [TRAINER_RUIN_MANIAC_BENJAMIN] = {
@@ -7246,7 +7246,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D7D0),
         .party = {.NoItemCustomMoves = sTrainerMons_823D7D0}
     },
     [TRAINER_PAINTER_EDNA] = {
@@ -7258,7 +7258,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D800),
         .party = {.NoItemCustomMoves = sTrainerMons_823D800}
     },
     [TRAINER_GENTLEMAN_CLIFFORD] = {
@@ -7270,7 +7270,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D810),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D810}
     },
     [TRAINER_LADY_SELPHY] = {
@@ -7282,7 +7282,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D820),
         .party = {.ItemCustomMoves = sTrainerMons_823D820}
     },
     [TRAINER_RUIN_MANIAC_LAWSON] = {
@@ -7294,7 +7294,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D840),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D840}
     },
     [TRAINER_PSYCHIC_LAURA] = {
@@ -7306,7 +7306,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D858),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D858}
     },
     [TRAINER_PKMN_BREEDER_BETHANY] = {
@@ -7318,7 +7318,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D870),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D870}
     },
     [TRAINER_PKMN_BREEDER_ALLISON] = {
@@ -7330,7 +7330,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D878),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D878}
     },
     [TRAINER_BUG_CATCHER_GARRET] = {
@@ -7342,7 +7342,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D890),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D890}
     },
     [TRAINER_BUG_CATCHER_JONAH] = {
@@ -7354,7 +7354,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D898),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D898}
     },
     [TRAINER_BUG_CATCHER_VANCE] = {
@@ -7366,7 +7366,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D8B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D8B8}
     },
     [TRAINER_YOUNGSTER_NASH] = {
@@ -7378,7 +7378,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D8C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D8C8}
     },
     [TRAINER_YOUNGSTER_CORDELL] = {
@@ -7390,7 +7390,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D8E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D8E0}
     },
     [TRAINER_LASS_DALIA] = {
@@ -7402,7 +7402,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823D8F0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D8F0}
     },
     [TRAINER_LASS_JOANA] = {
@@ -7414,7 +7414,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D910),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D910}
     },
     [TRAINER_CAMPER_RILEY] = {
@@ -7426,7 +7426,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D918),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D918}
     },
     [TRAINER_PICNICKER_MARCY] = {
@@ -7438,7 +7438,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D928),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D928}
     },
     [TRAINER_RUIN_MANIAC_LAYTON] = {
@@ -7450,7 +7450,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D940),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D940}
     },
     [TRAINER_PICNICKER_KELSEY_2] = {
@@ -7462,7 +7462,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D958),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D958}
     },
     [TRAINER_PICNICKER_KELSEY_3] = {
@@ -7474,7 +7474,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D968),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D968}
     },
     [TRAINER_PICNICKER_KELSEY_4] = {
@@ -7486,7 +7486,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D978),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D978}
     },
     [TRAINER_CAMPER_RICKY_2] = {
@@ -7498,7 +7498,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D988),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D988}
     },
     [TRAINER_CAMPER_RICKY_3] = {
@@ -7510,7 +7510,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D990),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D990}
     },
     [TRAINER_CAMPER_RICKY_4] = {
@@ -7522,7 +7522,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823D998),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D998}
     },
     [TRAINER_CAMPER_JEFF_2] = {
@@ -7534,7 +7534,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D9A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D9A0}
     },
     [TRAINER_CAMPER_JEFF_3] = {
@@ -7546,7 +7546,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D9B0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D9B0}
     },
     [TRAINER_CAMPER_JEFF_4] = {
@@ -7558,7 +7558,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823D9C0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D9C0}
     },
     [TRAINER_PICNICKER_ISABELLE_2] = {
@@ -7570,7 +7570,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D9D0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D9D0}
     },
     [TRAINER_PICNICKER_ISABELLE_3] = {
@@ -7582,7 +7582,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823D9E8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823D9E8}
     },
     [TRAINER_PICNICKER_ISABELLE_4] = {
@@ -7594,7 +7594,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DA00),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA00}
     },
     [TRAINER_YOUNGSTER_YASU_2] = {
@@ -7606,7 +7606,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DA18),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA18}
     },
     [TRAINER_YOUNGSTER_YASU_3] = {
@@ -7618,7 +7618,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DA30),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA30}
     },
     [TRAINER_ENGINEER_BERNIE_2] = {
@@ -7630,7 +7630,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DA48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA48}
     },
     [TRAINER_GAMER_DARIAN_2] = {
@@ -7642,7 +7642,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DA60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA60}
     },
     [TRAINER_CAMPER_CHRIS_2] = {
@@ -7654,7 +7654,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DA70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA70}
     },
     [TRAINER_CAMPER_CHRIS_3] = {
@@ -7666,7 +7666,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DA80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA80}
     },
     [TRAINER_CAMPER_CHRIS_4] = {
@@ -7678,7 +7678,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DA90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DA90}
     },
     [TRAINER_PICNICKER_ALICIA_2] = {
@@ -7690,7 +7690,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DAA0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAA0}
     },
     [TRAINER_PICNICKER_ALICIA_3] = {
@@ -7702,7 +7702,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DAA8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAA8}
     },
     [TRAINER_PICNICKER_ALICIA_4] = {
@@ -7714,7 +7714,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DAB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAB0}
     },
     [TRAINER_HIKER_JEREMY_2] = {
@@ -7726,7 +7726,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DAB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAB8}
     },
     [TRAINER_POKEMANIAC_MARK_3] = {
@@ -7738,7 +7738,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DAC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAC8}
     },
     [TRAINER_POKEMANIAC_HERMAN_2] = {
@@ -7750,7 +7750,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DAD8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAD8}
     },
     [TRAINER_POKEMANIAC_HERMAN_3] = {
@@ -7762,7 +7762,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DAE8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAE8}
     },
     [TRAINER_HIKER_TRENT_2] = {
@@ -7774,7 +7774,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DAF8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DAF8}
     },
     [TRAINER_LASS_MEGAN_2] = {
@@ -7786,7 +7786,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823DB08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB08}
     },
     [TRAINER_LASS_MEGAN_3] = {
@@ -7798,7 +7798,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823DB30),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB30}
     },
     [TRAINER_SUPER_NERD_GLENN_2] = {
@@ -7810,7 +7810,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DB58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB58}
     },
     [TRAINER_GAMER_RICH_2] = {
@@ -7822,7 +7822,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DB70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB70}
     },
     [TRAINER_BIKER_JAREN_2] = {
@@ -7834,7 +7834,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DB80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB80}
     },
     [TRAINER_FISHERMAN_ELLIOT_2] = {
@@ -7846,7 +7846,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DB90),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DB90}
     },
     [TRAINER_ROCKER_LUCA_2] = {
@@ -7858,7 +7858,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DBB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DBB0}
     },
     [TRAINER_BEAUTY_SHEILA_2] = {
@@ -7870,7 +7870,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DBC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DBC0}
     },
     [TRAINER_BIRD_KEEPER_ROBERT_2] = {
@@ -7882,7 +7882,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DBD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DBD0}
     },
     [TRAINER_BIRD_KEEPER_ROBERT_3] = {
@@ -7894,7 +7894,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DBF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DBF0}
     },
     [TRAINER_PICNICKER_SUSIE_2] = {
@@ -7906,7 +7906,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823DC10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DC10}
     },
     [TRAINER_PICNICKER_SUSIE_3] = {
@@ -7918,7 +7918,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823DC38),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DC38}
     },
     [TRAINER_PICNICKER_SUSIE_4] = {
@@ -7930,7 +7930,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823DC60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DC60}
     },
     [TRAINER_BIKER_LUKAS_2] = {
@@ -7942,7 +7942,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DC88),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DC88}
     },
     [TRAINER_BIRD_KEEPER_BENNY_2] = {
@@ -7954,7 +7954,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DCA8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DCA8}
     },
     [TRAINER_BIRD_KEEPER_BENNY_3] = {
@@ -7966,7 +7966,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DCB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DCB8}
     },
     [TRAINER_BIRD_KEEPER_MARLON_2] = {
@@ -7978,7 +7978,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DCC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DCC8}
     },
     [TRAINER_BIRD_KEEPER_MARLON_3] = {
@@ -7990,7 +7990,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DCE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DCE0}
     },
     [TRAINER_BEAUTY_GRACE_2] = {
@@ -8002,7 +8002,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DCF8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DCF8}
     },
     [TRAINER_BIRD_KEEPER_CHESTER_2] = {
@@ -8014,7 +8014,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DD08),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD08}
     },
     [TRAINER_BIRD_KEEPER_CHESTER_3] = {
@@ -8026,7 +8026,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DD20),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD20}
     },
     [TRAINER_PICNICKER_BECKY_2] = {
@@ -8038,7 +8038,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD38),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD38}
     },
     [TRAINER_PICNICKER_BECKY_3] = {
@@ -8050,7 +8050,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD48),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD48}
     },
     [TRAINER_PICNICKER_BECKY_4] = {
@@ -8062,7 +8062,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD58),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD58}
     },
     [TRAINER_CRUSH_KIN_RON_MYA_2] = {
@@ -8074,7 +8074,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD68),
         .party = {.ItemDefaultMoves = sTrainerMons_823DD68}
     },
     [TRAINER_CRUSH_KIN_RON_MYA_3] = {
@@ -8086,7 +8086,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD78),
         .party = {.ItemDefaultMoves = sTrainerMons_823DD78}
     },
     [TRAINER_CRUSH_KIN_RON_MYA_4] = {
@@ -8098,7 +8098,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DD88),
         .party = {.ItemDefaultMoves = sTrainerMons_823DD88}
     },
     [TRAINER_BIKER_RUBEN_2] = {
@@ -8110,7 +8110,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DD98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DD98}
     },
     [TRAINER_CUE_BALL_CAMRON_2] = {
@@ -8122,7 +8122,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DDB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DDB0}
     },
     [TRAINER_BIKER_JAXON_2] = {
@@ -8134,7 +8134,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DDC0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DDC0}
     },
     [TRAINER_CUE_BALL_ISAIAH_2] = {
@@ -8146,7 +8146,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DDD0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DDD0}
     },
     [TRAINER_CUE_BALL_COREY_2] = {
@@ -8158,7 +8158,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DDE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DDE0}
     },
     [TRAINER_BIRD_KEEPER_JACOB_2] = {
@@ -8170,7 +8170,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DDF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DDF0}
     },
     [TRAINER_BIRD_KEEPER_JACOB_3] = {
@@ -8182,7 +8182,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DE10),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE10}
     },
     [TRAINER_SWIMMER_FEMALE_ALICE_2] = {
@@ -8194,7 +8194,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DE30),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE30}
     },
     [TRAINER_SWIMMER_MALE_DARRIN_2] = {
@@ -8206,7 +8206,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823DE40),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE40}
     },
     [TRAINER_PICNICKER_MISSY_2] = {
@@ -8218,7 +8218,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DE60),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE60}
     },
     [TRAINER_PICNICKER_MISSY_3] = {
@@ -8230,7 +8230,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DE70),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE70}
     },
     [TRAINER_FISHERMAN_WADE_2] = {
@@ -8242,7 +8242,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823DE80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DE80}
     },
     [TRAINER_SWIMMER_MALE_JACK_2] = {
@@ -8254,7 +8254,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DEB0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DEB0}
     },
     [TRAINER_SIS_AND_BRO_LIL_IAN_2] = {
@@ -8266,7 +8266,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DEB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DEB8}
     },
     [TRAINER_SIS_AND_BRO_LIL_IAN_3] = {
@@ -8278,7 +8278,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DEC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DEC8}
     },
     [TRAINER_SWIMMER_MALE_FINN_2] = {
@@ -8290,7 +8290,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DED8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DED8}
     },
     [TRAINER_CRUSH_GIRL_SHARON_2] = {
@@ -8302,7 +8302,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DEE0),
         .party = {.ItemDefaultMoves = sTrainerMons_823DEE0}
     },
     [TRAINER_CRUSH_GIRL_SHARON_3] = {
@@ -8314,7 +8314,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DEF0),
         .party = {.ItemDefaultMoves = sTrainerMons_823DEF0}
     },
     [TRAINER_CRUSH_GIRL_TANYA_2] = {
@@ -8326,7 +8326,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF00),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF00}
     },
     [TRAINER_CRUSH_GIRL_TANYA_3] = {
@@ -8338,7 +8338,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF10),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF10}
     },
     [TRAINER_BLACK_BELT_SHEA_2] = {
@@ -8350,7 +8350,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF20),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF20}
     },
     [TRAINER_BLACK_BELT_SHEA_3] = {
@@ -8362,7 +8362,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF30),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF30}
     },
     [TRAINER_BLACK_BELT_HUGH_2] = {
@@ -8374,7 +8374,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF40),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF40}
     },
     [TRAINER_BLACK_BELT_HUGH_3] = {
@@ -8386,7 +8386,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF50),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF50}
     },
     [TRAINER_CRUSH_KIN_MIK_KIA_2] = {
@@ -8398,7 +8398,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF60),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF60}
     },
     [TRAINER_CRUSH_KIN_MIK_KIA_3] = {
@@ -8410,7 +8410,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF70),
         .party = {.ItemDefaultMoves = sTrainerMons_823DF70}
     },
     [TRAINER_TUBER_AMIRA_2] = {
@@ -8422,7 +8422,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DF80),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DF80}
     },
     [TRAINER_TWINS_JOY_MEG_2] = {
@@ -8434,7 +8434,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DF98),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DF98}
     },
     [TRAINER_PAINTER_RAYNA_2] = {
@@ -8446,7 +8446,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823DFA8),
         .party = {.NoItemCustomMoves = sTrainerMons_823DFA8}
     },
     [TRAINER_YOUNGSTER_DESTIN_2] = {
@@ -8458,7 +8458,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DFB8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DFB8}
     },
     [TRAINER_PKMN_BREEDER_ALIZE_2] = {
@@ -8470,7 +8470,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823DFC8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DFC8}
     },
     [TRAINER_YOUNG_COUPLE_GIA_JES_2] = {
@@ -8482,7 +8482,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DFE0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DFE0}
     },
     [TRAINER_YOUNG_COUPLE_GIA_JES_3] = {
@@ -8494,7 +8494,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823DFF0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823DFF0}
     },
     [TRAINER_BIRD_KEEPER_MILO_2] = {
@@ -8506,7 +8506,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E000),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E000}
     },
     [TRAINER_BIRD_KEEPER_CHAZ_2] = {
@@ -8518,7 +8518,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E010),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E010}
     },
     [TRAINER_BIRD_KEEPER_HAROLD_2] = {
@@ -8530,7 +8530,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E020),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E020}
     },
     [TRAINER_SWIMMER_FEMALE_NICOLE_2] = {
@@ -8542,7 +8542,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823E030),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E030}
     },
     [TRAINER_PSYCHIC_JACLYN_2] = {
@@ -8554,7 +8554,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E038),
         .party = {.NoItemCustomMoves = sTrainerMons_823E038}
     },
     [TRAINER_SWIMMER_MALE_SAMIR_2] = {
@@ -8566,7 +8566,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823E068),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E068}
     },
     [TRAINER_HIKER_EARL_2] = {
@@ -8578,7 +8578,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E070),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E070}
     },
     [TRAINER_RUIN_MANIAC_LARRY_2] = {
@@ -8590,7 +8590,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E080),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E080}
     },
     [TRAINER_POKEMANIAC_HECTOR_2] = {
@@ -8602,7 +8602,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E090),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E090}
     },
     [TRAINER_PSYCHIC_DARIO_2] = {
@@ -8614,7 +8614,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823E0A0),
         .party = {.NoItemCustomMoves = sTrainerMons_823E0A0}
     },
     [TRAINER_PSYCHIC_RODETTE_2] = {
@@ -8626,7 +8626,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E0B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823E0B0}
     },
     [TRAINER_JUGGLER_MASON_2] = {
@@ -8638,7 +8638,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 4,
+        .partySize = NELEMS(sTrainerMons_823E0E0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E0E0}
     },
     [TRAINER_PKMN_RANGER_NICOLAS_2] = {
@@ -8650,7 +8650,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E100),
         .party = {.NoItemCustomMoves = sTrainerMons_823E100}
     },
     [TRAINER_PKMN_RANGER_MADELINE_2] = {
@@ -8662,7 +8662,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E120),
         .party = {.NoItemCustomMoves = sTrainerMons_823E120}
     },
     [TRAINER_CRUSH_GIRL_CYNDY_2] = {
@@ -8674,7 +8674,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E140),
         .party = {.ItemDefaultMoves = sTrainerMons_823E140}
     },
     [TRAINER_TAMER_EVAN_2] = {
@@ -8686,7 +8686,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E158),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E158}
     },
     [TRAINER_PKMN_RANGER_JACKSON_2] = {
@@ -8698,7 +8698,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E170),
         .party = {.NoItemCustomMoves = sTrainerMons_823E170}
     },
     [TRAINER_PKMN_RANGER_KATELYN_2] = {
@@ -8710,7 +8710,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 1,
+        .partySize = NELEMS(sTrainerMons_823E1A0),
         .party = {.NoItemCustomMoves = sTrainerMons_823E1A0}
     },
     [TRAINER_COOLTRAINER_LEROY_2] = {
@@ -8722,7 +8722,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E1B0),
         .party = {.NoItemCustomMoves = sTrainerMons_823E1B0}
     },
     [TRAINER_COOLTRAINER_MICHELLE_2] = {
@@ -8734,7 +8734,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_HYPER_POTION},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E200),
         .party = {.NoItemCustomMoves = sTrainerMons_823E200}
     },
     [TRAINER_COOL_COUPLE_LEX_NYA_2] = {
@@ -8746,7 +8746,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = TRUE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E250),
         .party = {.NoItemCustomMoves = sTrainerMons_823E250}
     },
     [TRAINER_BUG_CATCHER_COLTON_2] = {
@@ -8758,7 +8758,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E270),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E270}
     },
     [TRAINER_BUG_CATCHER_COLTON_3] = {
@@ -8770,7 +8770,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E288),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E288}
     },
     [TRAINER_BUG_CATCHER_COLTON_4] = {
@@ -8782,7 +8782,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 3,
+        .partySize = NELEMS(sTrainerMons_823E2A0),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E2A0}
     },
     [TRAINER_SWIMMER_MALE_MATTHEW_2] = {
@@ -8794,7 +8794,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E2B8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E2B8}
     },
     [TRAINER_SWIMMER_MALE_TONY_2] = {
@@ -8806,7 +8806,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E2C8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E2C8}
     },
     [TRAINER_SWIMMER_FEMALE_MELISSA_2] = {
@@ -8818,7 +8818,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E2D8),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E2D8}
     },
     [TRAINER_ELITE_FOUR_LORELEI_2] = {
@@ -8830,7 +8830,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E2E8),
         .party = {.ItemCustomMoves = sTrainerMons_823E2E8}
     },
     [TRAINER_ELITE_FOUR_BRUNO_2] = {
@@ -8842,7 +8842,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E338),
         .party = {.ItemCustomMoves = sTrainerMons_823E338}
     },
     [TRAINER_ELITE_FOUR_AGATHA_2] = {
@@ -8854,7 +8854,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E388),
         .party = {.ItemCustomMoves = sTrainerMons_823E388}
     },
     [TRAINER_ELITE_FOUR_LANCE_2] = {
@@ -8866,7 +8866,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 5,
+        .partySize = NELEMS(sTrainerMons_823E3D8),
         .party = {.ItemCustomMoves = sTrainerMons_823E3D8}
     },
     [TRAINER_CHAMPION_REMATCH_SQUIRTLE] = {
@@ -8878,7 +8878,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823E428),
         .party = {.ItemCustomMoves = sTrainerMons_823E428}
     },
     [TRAINER_CHAMPION_REMATCH_BULBASAUR] = {
@@ -8890,7 +8890,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823E488),
         .party = {.ItemCustomMoves = sTrainerMons_823E488}
     },
     [TRAINER_CHAMPION_REMATCH_CHARMANDER] = {
@@ -8902,7 +8902,7 @@ const struct Trainer gTrainers[] = {
         .items = {ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE, ITEM_FULL_RESTORE},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_TRY_TO_FAINT | AI_SCRIPT_CHECK_VIABILITY,
-        .partySize = 6,
+        .partySize = NELEMS(sTrainerMons_823E4E8),
         .party = {.ItemCustomMoves = sTrainerMons_823E4E8}
     },
     [TRAINER_CUE_BALL_PAXTON] = {
@@ -8914,7 +8914,7 @@ const struct Trainer gTrainers[] = {
         .items = {},
         .doubleBattle = FALSE,
         .aiFlags = AI_SCRIPT_CHECK_BAD_MOVE,
-        .partySize = 2,
+        .partySize = NELEMS(sTrainerMons_823E548),
         .party = {.NoItemDefaultMoves = sTrainerMons_823E548}
     },
 };
diff --git a/src/daycare.c b/src/daycare.c
index 277a382c7..0a19c6c9b 100644
--- a/src/daycare.c
+++ b/src/daycare.c
@@ -1,7 +1,6 @@
 #include "global.h"
 #include "gflib.h"
 #include "battle.h"
-#include "daycare.h"
 #include "constants/species.h"
 #include "constants/items.h"
 #include "mail_data.h"
@@ -29,7 +28,7 @@
 #include "field_fadetransition.h"
 #include "trade.h"
 #include "constants/daycare.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 
 // Combination of RSE's Day-Care (re-used on Four Island), FRLG's Day-Care, and egg_hatch.c
 
@@ -1816,7 +1815,7 @@ static void CB2_EggHatch_0(void)
         break;
     case 2:
         DecompressAndLoadBgGfxUsingHeap(0, gBattleTextboxTiles, 0, 0, 0);
-        CopyToBgTilemapBuffer(0, gFile_graphics_interface_menu_map_tilemap, 0, 0);
+        CopyToBgTilemapBuffer(0, gBattleTextboxTilemap, 0, 0);
         LoadCompressedPalette(gBattleTextboxPalette, 0, 0x20);
         gMain.state++;
         break;
@@ -1968,7 +1967,7 @@ static void CB2_EggHatch_1(void)
             species = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_SPECIES);
             gender = GetMonGender(&gPlayerParty[sEggHatchData->eggPartyID]);
             personality = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_PERSONALITY, 0);
-            DoNamingScreen(3, gStringVar3, species, gender, personality, EggHatchSetMonNickname);
+            DoNamingScreen(NAMING_SCREEN_NAME_RATER, gStringVar3, species, gender, personality, EggHatchSetMonNickname);
             break;
         case 1:
         case -1:
diff --git a/src/decompress.c b/src/decompress.c
index caeda738a..3f0c82bce 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -2,7 +2,6 @@
 #include "malloc.h"
 #include "decompress.h"
 #include "pokemon.h"
-#include "text.h"
 #include "constants/species.h"
 
 extern const struct CompressedSpriteSheet gMonFrontPicTable[];
diff --git a/src/digit_obj_util.c b/src/digit_obj_util.c
new file mode 100644
index 000000000..82af5dcab
--- /dev/null
+++ b/src/digit_obj_util.c
@@ -0,0 +1,452 @@
+#include "global.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "digit_obj_util.h"
+#include "main.h"
+
+struct DigitPrinterAlloc
+{
+    u32 count;
+    struct DigitPrinter
+    {
+        bool8 isActive;
+        u8 firstOamId;
+        u8 strConvMode;
+        u8 oamCount;
+        u8 palTagIndex;
+        u8 size;
+        u8 shape;
+        u8 priority;
+        u8 xDelta;
+        u8 tilesPerImage;
+        u16 tileStart;
+        s16 x;
+        s16 y;
+        u16 tileTag;
+        u16 palTag;
+        u32 pow10;
+        s32 lastPrinted;
+    } *array;
+};
+
+// this file's functions
+static u8 GetFirstOamId(u8 oamCount);
+static void CopyWorkToOam(struct DigitPrinter *objWork);
+static void DrawNumObjsLeadingZeros(struct DigitPrinter *objWork, s32 num, bool32 sign);
+static void DrawNumObjsMinusInFront(struct DigitPrinter *objWork, s32 num, bool32 sign);
+static void DrawNumObjsMinusInBack(struct DigitPrinter *objWork, s32 num, bool32 sign);
+static bool32 SharesTileWithAnyActive(u32 id);
+static bool32 SharesPalWithAnyActive(u32 id);
+static u8 GetTilesPerImage(u32 shape, u32 size);
+
+// ewram
+static EWRAM_DATA struct DigitPrinterAlloc *sOamWork = {0};
+
+// const rom data
+static const u8 sTilesPerImage[4][4] =
+{
+    [ST_OAM_SQUARE]      = {
+        [ST_OAM_SIZE_0] = 0x01, // SPRITE_SIZE_8x8
+        [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_16x16
+        [ST_OAM_SIZE_2] = 0x10, // SPRITE_SIZE_32x32
+        [ST_OAM_SIZE_3] = 0x40  // SPRITE_SIZE_64x64
+    },
+    [ST_OAM_H_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = 0x02, // SPRITE_SIZE_16x8
+        [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_32x8
+        [ST_OAM_SIZE_2] = 0x08, // SPRITE_SIZE_32x16
+        [ST_OAM_SIZE_3] = 0x20  // SPRITE_SIZE_64x32
+    },
+    [ST_OAM_V_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = 0x02, // SPRITE_SIZE_8x16
+        [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_8x32
+        [ST_OAM_SIZE_2] = 0x08, // SPRITE_SIZE_16x32
+        [ST_OAM_SIZE_3] = 0x20  // SPRITE_SIZE_32x64
+    }
+};
+
+const u16 gUnknown_8479668[] = INCBIN_U16("graphics/misc/unk_8479688.gbapal");
+const u32 gUnknown_8479688[] = INCBIN_U32("graphics/misc/unk_8479688.4bpp.lz");
+const u32 gUnknown_8479748[] = INCBIN_U32("graphics/misc/unk_8479748.4bpp.lz");
+
+// code
+bool32 DigitObjUtil_Init(u32 count)
+{
+    u32 i;
+
+    if (sOamWork != NULL)
+        DigitObjUtil_Teardown();
+
+    sOamWork = Alloc(sizeof(*sOamWork));
+    if (sOamWork == NULL)
+        return FALSE;
+
+    sOamWork->array = Alloc(sizeof(struct DigitPrinter) * count);
+    if (sOamWork->array == NULL)
+    {
+        Free(sOamWork);
+        return FALSE;
+    }
+
+    sOamWork->count = count;
+    for (i = 0; i < count; i++)
+    {
+        sOamWork->array[i].isActive = FALSE;
+        sOamWork->array[i].firstOamId = 0xFF;
+    }
+
+    return TRUE;
+}
+
+void DigitObjUtil_Teardown(void)
+{
+    if (sOamWork != NULL)
+    {
+        if (sOamWork->array != NULL)
+        {
+            u32 i;
+
+            for (i = 0; i < sOamWork->count; i++)
+                DigitObjUtil_DeletePrinter(i);
+
+            Free(sOamWork->array);
+        }
+
+        FREE_AND_SET_NULL(sOamWork);
+    }
+}
+
+bool32 DigitObjUtil_CreatePrinter(u32 id, s32 num, const struct DigitObjUtilTemplate *template)
+{
+    u32 i;
+
+    if (sOamWork == NULL)
+        return FALSE;
+    if (sOamWork->array[id].isActive)
+        return FALSE;
+
+    sOamWork->array[id].firstOamId = GetFirstOamId(template->oamCount);
+    if (sOamWork->array[id].firstOamId == 0xFF)
+        return FALSE;
+
+    sOamWork->array[id].tileStart = GetSpriteTileStartByTag(template->spriteSheet.uncompressed->tag);
+    if (sOamWork->array[id].tileStart == 0xFFFF)
+    {
+        if (template->spriteSheet.uncompressed->size != 0)
+        {
+            sOamWork->array[id].tileStart = LoadSpriteSheet(template->spriteSheet.uncompressed);
+        }
+        else
+        {
+            struct CompressedSpriteSheet compObjectPic;
+
+            compObjectPic = *template->spriteSheet.compressed;
+            compObjectPic.size = GetDecompressedDataSize((const void *)template->spriteSheet.compressed->data);
+            sOamWork->array[id].tileStart = LoadCompressedSpriteSheet(&compObjectPic);
+        }
+
+        if (sOamWork->array[id].tileStart == 0xFFFF)
+            return FALSE;
+    }
+
+    sOamWork->array[id].palTagIndex = IndexOfSpritePaletteTag(template->spritePal->tag);
+    if (sOamWork->array[id].palTagIndex == 0xFF)
+        sOamWork->array[id].palTagIndex = LoadSpritePalette(template->spritePal);
+
+    sOamWork->array[id].strConvMode = template->strConvMode;
+    sOamWork->array[id].oamCount = template->oamCount;
+    sOamWork->array[id].x = template->x;
+    sOamWork->array[id].y = template->y;
+    sOamWork->array[id].shape = template->shape;
+    sOamWork->array[id].size = template->size;
+    sOamWork->array[id].priority = template->priority;
+    sOamWork->array[id].xDelta = template->xDelta;
+    sOamWork->array[id].tilesPerImage = GetTilesPerImage(template->shape, template->size);
+    sOamWork->array[id].tileTag = template->spriteSheet.uncompressed->tag;
+    sOamWork->array[id].palTag = template->spritePal->tag;
+    sOamWork->array[id].isActive = TRUE;
+
+    // Decimal left shift
+    sOamWork->array[id].pow10 = 1;
+    for (i = 1; i < template->oamCount; i++)
+        sOamWork->array[id].pow10 *= 10;
+
+    CopyWorkToOam(&sOamWork->array[id]);
+    DigitObjUtil_PrintNumOn(id, num);
+
+    return TRUE;
+}
+
+static void CopyWorkToOam(struct DigitPrinter *objWork)
+{
+    u32 i;
+    u32 oamId = objWork->firstOamId;
+    u32 x = objWork->x;
+    u32 oamCount = objWork->oamCount + 1;
+
+    CpuFill16(0, &gMain.oamBuffer[oamId], sizeof(struct OamData) * oamCount);
+    for (i = 0, oamId = objWork->firstOamId; i < oamCount; i++, oamId++)
+    {
+        gMain.oamBuffer[oamId].y = objWork->y;
+        gMain.oamBuffer[oamId].x = x;
+        gMain.oamBuffer[oamId].shape = objWork->shape;
+        gMain.oamBuffer[oamId].size = objWork->size;
+        gMain.oamBuffer[oamId].tileNum = objWork->tileStart;
+        gMain.oamBuffer[oamId].priority = objWork->priority;
+        gMain.oamBuffer[oamId].paletteNum = objWork->palTagIndex;
+
+        x += objWork->xDelta;
+    }
+
+    oamId--;
+    gMain.oamBuffer[oamId].x = objWork->x - objWork->xDelta;
+    gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+    gMain.oamBuffer[oamId].tileNum = objWork->tileStart + (objWork->tilesPerImage * 10);
+}
+
+void DigitObjUtil_PrintNumOn(u32 id, s32 num)
+{
+    bool32 sign;
+
+    if (sOamWork == NULL)
+        return;
+    if (!sOamWork->array[id].isActive)
+        return;
+
+    sOamWork->array[id].lastPrinted = num;
+    if (num < 0)
+    {
+        sign = TRUE;
+        num *= -1;
+    }
+    else
+    {
+        sign = FALSE;
+    }
+
+    switch (sOamWork->array[id].strConvMode)
+    {
+    case 0:
+    default:
+        DrawNumObjsLeadingZeros(&sOamWork->array[id], num, sign);
+        break;
+    case 1:
+        DrawNumObjsMinusInFront(&sOamWork->array[id], num, sign);
+        break;
+    case 2:
+        DrawNumObjsMinusInBack(&sOamWork->array[id], num, sign);
+        break;
+    }
+}
+
+static void DrawNumObjsLeadingZeros(struct DigitPrinter *objWork, s32 num, bool32 sign)
+{
+    u32 pow10 = objWork->pow10;
+    u32 oamId = objWork->firstOamId;
+
+    while (pow10 != 0)
+    {
+        u32 digit = num / pow10;
+        num -= (digit * pow10);
+        pow10 /= 10;
+
+        gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart;
+        oamId++;
+    }
+
+    if (sign)
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+    else
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+}
+
+static void DrawNumObjsMinusInFront(struct DigitPrinter *objWork, s32 num, bool32 sign)
+{
+    u32 pow10 = objWork->pow10;
+    static int oamId;
+    static int curDigit;
+    static int firstDigit;
+
+    oamId = objWork->firstOamId;
+    curDigit = 0;
+    firstDigit = -1;
+
+    while (pow10 != 0)
+    {
+        u32 digit = num / pow10;
+        num -= (digit * pow10);
+        pow10 /= 10;
+
+        if (digit != 0 || firstDigit != -1 || pow10 == 0)
+        {
+            gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart;
+            gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+
+            if (firstDigit == -1)
+                firstDigit = curDigit;
+        }
+        else
+        {
+            gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+        }
+
+        oamId++;
+        curDigit++;
+    }
+
+    if (sign)
+    {
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+        gMain.oamBuffer[oamId].x = objWork->x + ((firstDigit - 1) * objWork->xDelta);
+    }
+    else
+    {
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+    }
+}
+
+static void DrawNumObjsMinusInBack(struct DigitPrinter *objWork, s32 num, bool32 sign)
+{
+    u32 pow10 = objWork->pow10;
+    u32 oamId = objWork->firstOamId;
+    u32 printingDigits = 0;
+    s32 nsprites = 0;
+
+    while (pow10 != 0)
+    {
+        u32 digit = num / pow10;
+        num -= (digit * pow10);
+        pow10 /= 10;
+
+        if (digit != 0 || printingDigits != 0 || pow10 == 0)
+        {
+            printingDigits = 1;
+            gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart;
+            gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+
+            oamId++;
+            nsprites++;
+        }
+    }
+
+    while (nsprites < objWork->oamCount)
+    {
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+        oamId++;
+        nsprites++;
+    }
+
+    if (sign)
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+    else
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+}
+
+void DigitObjUtil_DeletePrinter(u32 id)
+{
+    s32 oamId, oamCount, i;
+
+    if (sOamWork == NULL)
+        return;
+    if (!sOamWork->array[id].isActive)
+        return;
+
+    oamCount = sOamWork->array[id].oamCount + 1;
+    oamId = sOamWork->array[id].firstOamId;
+
+    for (i = 0; i < oamCount; i++, oamId++)
+        gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+
+    if (!SharesTileWithAnyActive(id))
+        FreeSpriteTilesByTag(sOamWork->array[id].tileTag);
+    if (!SharesPalWithAnyActive(id))
+        FreeSpritePaletteByTag(sOamWork->array[id].palTag);
+
+    sOamWork->array[id].isActive = FALSE;
+}
+
+void DigitObjUtil_HideOrShow(u32 id, bool32 hide)
+{
+    s32 oamId, oamCount, i;
+
+    if (sOamWork == NULL)
+        return;
+    if (!sOamWork->array[id].isActive)
+        return;
+
+    oamCount = sOamWork->array[id].oamCount + 1;
+    oamId = sOamWork->array[id].firstOamId;
+    if (hide)
+    {
+        for (i = 0; i < oamCount; i++, oamId++)
+            gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE;
+    }
+    else
+    {
+        for (i = 0; i < oamCount; i++, oamId++)
+            gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF;
+
+        DigitObjUtil_PrintNumOn(id, sOamWork->array[id].lastPrinted);
+    }
+}
+
+static u8 GetFirstOamId(u8 oamCount)
+{
+    u32 i;
+    u16 firstOamId = 64;
+
+    for (i = 0; i < sOamWork->count; i++)
+    {
+        if (!sOamWork->array[i].isActive)
+        {
+            if (sOamWork->array[i].firstOamId != 0xFF && sOamWork->array[i].oamCount <= oamCount)
+                return sOamWork->array[i].firstOamId;
+        }
+        else
+        {
+            firstOamId += 1 + sOamWork->array[i].oamCount;
+        }
+    }
+
+    if (firstOamId + oamCount + 1 > 128)
+        return 0xFF;
+    else
+        return firstOamId;
+}
+
+static bool32 SharesTileWithAnyActive(u32 id)
+{
+    u32 i;
+
+    for (i = 0; i < sOamWork->count; i++)
+    {
+        if (sOamWork->array[i].isActive && i != id
+            && sOamWork->array[i].tileTag == sOamWork->array[id].tileTag)
+        {
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static bool32 SharesPalWithAnyActive(u32 id)
+{
+    u32 i;
+
+    for (i = 0; i < sOamWork->count; i++)
+    {
+        if (sOamWork->array[i].isActive && i != id
+            && sOamWork->array[i].palTag == sOamWork->array[id].palTag)
+        {
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static u8 GetTilesPerImage(u32 shape, u32 size)
+{
+    return sTilesPerImage[shape][size];
+}
diff --git a/src/diploma.c b/src/diploma.c
index afb22400b..f702eebd5 100644
--- a/src/diploma.c
+++ b/src/diploma.c
@@ -4,7 +4,6 @@
 #include "dynamic_placeholder_text_util.h"
 #include "gba/macro.h"
 #include "gpu_regs.h"
-#include "gpu_regs.h"
 #include "main.h"
 #include "malloc.h"
 #include "menu.h"
@@ -19,7 +18,6 @@
 #include "task.h"
 #include "text.h"
 #include "window.h"
-#include "diploma.h"
 
 struct Diploma
 {
diff --git a/src/dodrio_berry_picking.c b/src/dodrio_berry_picking.c
index 1860f1917..ea6d46df2 100644
--- a/src/dodrio_berry_picking.c
+++ b/src/dodrio_berry_picking.c
@@ -1,162 +1,145 @@
 #include "global.h"
-#include "bg.h"
+#include "gflib.h"
+#include "dodrio_berry_picking.h"
+#include "event_data.h"
+#include "item.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "m4a.h"
+#include "minigame_countdown.h"
+#include "random.h"
+#include "script.h"
 #include "strings.h"
-#include "window.h"
-
-/*static*/ void sub_8150C78(void);
-/*static*/ void sub_8150CBC(void);
-/*static*/ void sub_8150CF4(void);
-/*static*/ void sub_8150D7C(void);
-/*static*/ void sub_8150DA4(void);
-/*static*/ void sub_8150FDC(void);
-/*static*/ void sub_8151198(void);
-/*static*/ void sub_81512B4(void);
-/*static*/ void sub_8151488(void);
-/*static*/ void sub_81514F0(void);
-/*static*/ void sub_815159C(void);
-/*static*/ void sub_8150F40(void);
-/*static*/ void sub_8150E68(void);
-/*static*/ void sub_815109C(void);
-/*static*/ void sub_8150FC4(void);
-/*static*/ void nullsub_97(struct Sprite *sprite);
-/*static*/ void sub_81543E8(struct Sprite *sprite);
-/*static*/ void sub_8154A2C(void);
-/*static*/ void sub_8154B34(void);
-/*static*/ void sub_8154F80(void);
-/*static*/ void sub_81556E0(void);
-/*static*/ void sub_8155A78(void);
-/*static*/ void sub_8155B4C(void);
-/*static*/ void sub_8155C2C(void);
-/*static*/ void sub_8155C80(void);
-/*static*/ void unused_0(void);
-/*static*/ void nullsub_98(void);
-
-// const rom data
-/*static*/ const u8 sUnknown_8471F50[5][5][11] =
+#include "task.h"
+#include "text_window.h"
+#include "constants/songs.h"
+#include "constants/fanfares.h"
+#include "constants/items.h"
+#include "constants/species.h"
+
+struct DodrioStruct
 {
-    {
-        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
-    },
-    {
-        {0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 0},
-        {0, 1, 2, 5, 6, 3, 4, 5, 8, 9, 0},
-    },
-    {
-        {0, 1, 2, 3, 4, 5, 6, 7, 2, 9, 0},
-        {0, 1, 4, 5, 6, 7, 2, 3, 4, 9, 0},
-        {0, 1, 6, 7, 2, 3, 4, 5, 6, 9, 0},
-    },
-    {
-        {0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 0},
-        {0, 3, 4, 5, 6, 7, 8, 1, 2, 3, 0},
-        {0, 5, 6, 7, 8, 1, 2, 3, 4, 5, 0},
-        {0, 7, 8, 1, 2, 3, 4, 5, 6, 7, 0},
-    },
-    {
-        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
-        {2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2},
-        {4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4},
-        {6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6},
-        {8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8},
-    },
-};
+    /*0x0000*/ void (*savedCallback)(void);
+    /*0x0004*/ u8 ALIGNED(4) unk04;
+    /*0x0008*/ u8 ALIGNED(4) unk08;
+    /*0x000C*/ u8 ALIGNED(4) unk0C;
+    /*0x0010*/ u8 ALIGNED(4) unk10;
+    /*0x0014*/ u8 ALIGNED(4) unk14;
+    /*0x0018*/ u8 ALIGNED(4) unk18;
+    /*0x001C*/ u8 ALIGNED(4) unk1C;
+    /*0x0020*/ u8 ALIGNED(4) unk20;
+    /*0x0024*/ u8 ALIGNED(4) unk24;
+    /*0x0028*/ u8 ALIGNED(4) multiplayerId;
+    /*0x0030*/ u8 ALIGNED(8) unk30;
+    /*0x0034*/ u8 ALIGNED(4) unk34[5];
+    /*0x003C*/ u8 ALIGNED(4) unk3C;
+    /*0x0040*/ u8 ALIGNED(4) unk40;
+    /*0x0044*/ u8 ALIGNED(4) unk44;
+    /*0x0048*/ u8 ALIGNED(4) unk48;
+    /*0x004A*/ u16 unk4A[5][6];
+    /*0x0086*/ u16 unk86[5];
+    /*0x0090*/ u8 ALIGNED(4) unk90[5];
+    /*0x0098*/ u8 ALIGNED(4) unk98[4];
+    /*0x009C*/ u8 ALIGNED(4) unk9C[11];
+    /*0x00A8*/ u8 ALIGNED(4) unkA8[5];
+    /*0x00B0*/ u8 ALIGNED(4) unkB0[5];
+    /*0x00B8*/ u8 ALIGNED(4) unkB8[11];
+    /*0x00C4*/ u8 ALIGNED(4) unkC4[11];
+    /*0x00D0*/ u8 ALIGNED(4) unkD0[11];
+    /*0x00DC*/ u8 ALIGNED(4) unkDC[11];
+    /*0x00E8*/ u8 ALIGNED(4) unkE8[11];
+    /*0x00F4*/ u8 ALIGNED(4) unkF4[11][2];
+    /*0x010C*/ u8 ALIGNED(4) unk10C[5];
+    /*0x0112*/ u16 unk112;
+    /*0x0114*/ u16 unk114;
+    /*0x0118*/ u32 unk118;
+    /*0x011C*/ u32 unk11C;
+    /*0x0120*/ u32 unk120;
+    /*0x0124*/ u8 ALIGNED(4) unk124;
+    /*0x0128*/ u8 ALIGNED(4) unk128;
+    /*0x012C*/ u32 unk12C;
+    /*0x0130*/ u32 unk130[5];
+    /*0x0144*/ u8 ALIGNED(4) unk144;
+    /*0x0148*/ u8 ALIGNED(4) unk148[11];
+    /*0x0154*/ u8 ALIGNED(4) unk154;
+    /*0x0158*/ u8 ALIGNED(4) unk158[5];
+    /*0x0160*/ struct DodrioSubstruct_0160 unk160;
+    /*0x318C*/ struct DodrioSubstruct_318C unk318C[5];
+    /*0x31A0*/ struct DodrioSubstruct_31A0 unk31A0[5];
+    /*0x32CC*/ struct DodrioSubstruct_31A0 unk32CC;
+    /*0x3308*/ struct DodrioSubstruct_3308 unk3308[5];
+}; // size = 0x3330
+
+static EWRAM_DATA struct DodrioStruct * gUnknown_203F3E0 = NULL;
+
+static bool32 gUnknown_3002044;
+
+static void sub_81508D8(void);
+static void sub_81508EC(struct DodrioStruct * dodrio);
+static void sub_8150A84(u8 taskId);
+static void sub_8150C78(void);
+static void sub_8150CBC(void);
+static void sub_8150CF4(void);
+static void sub_8150D7C(void);
+static void sub_8150DA4(void);
+static void sub_8150E68(void);
+static void sub_8150F40(void);
+static void sub_8150FC4(void);
+static void sub_8150FDC(void);
+static void sub_815109C(void);
+static void sub_8151198(void);
+static void sub_81512B4(void);
+static void sub_8151488(void);
+static void sub_81514F0(void);
+static void sub_815159C(void);
+static void sub_81516DC(u8 taskId);
+static void sub_8151750(u8 taskId);
+static void sub_8151B54(void);
+static void sub_8151BA0(void);
+static void sub_8151C5C(void);
+static void sub_8151D28(void);
+static void sub_8151D98(void);
+static void sub_8151E94(void);
+static void sub_815201C(void);
+static void sub_8152034(void);
+static void sub_8152048(struct DodrioSubstruct_318C * dodrioMon, struct Pokemon * partyMon);
+static void sub_815205C(TaskFunc func, u8 priority);
+static void sub_815206C(TaskFunc func);
+static void sub_8152090(u8 a0);
+static bool32 sub_81520B4(void);
+static void sub_8152110(void);
+static bool32 sub_8152484(u8 a0, u8 a1, u8 a2);
+static void sub_815256C(void);
+static void sub_815293C(void);
+static void sub_8152970(void);
+static bool32 sub_8152A00(void);
+static void sub_8152A70(void);
+static void sub_81529A4(u8 a0, u8 *a1, u8 *a2);
+static bool32 sub_8152A98(void);
+static bool32 sub_8152AD8(void);
+static void sub_8152B64(u8 a0);
+static u8 sub_8152BD4(u8 a0);
+static u8 sub_8152BF8(u8 a0, u8 a1);
+static u8 sub_8152CB8(u8 arg0, u8 arg1);
+static void sub_8152D34(u8 a0, u8 a1, u8 a2);
+static void sub_8152F94(bool32 a0);
+static void sub_8153004(void);
+static void sub_8153048(void);
+static void sub_8153150(void);
+static void sub_81531FC(void);
+static u8 sub_815327C(u8);
+static void sub_81532B8(void);
+static void sub_815336C(void);
+static u32 sub_8153424(u8 mpId);
+static void Task_ShowDodrioBerryPickingRecords(u8 taskId);
+static void sub_81538D0(u8 windowId);
 
-/*static*/ const u8 sUnknown_8472063[5][5][3] =
-{
-    {
-        {4, 5, 6},
-    },
-    {
-        {3, 4, 5},
-        {5, 6, 3},
-    },
-    {
-        {4, 5, 6},
-        {6, 7, 2},
-        {2, 3, 4},
-    },
-    {
-        {3, 4, 5},
-        {5, 6, 7},
-        {7, 8, 1},
-        {1, 2, 3},
-    },
-    {
-        {4, 5, 6},
-        {6, 7, 8},
-        {8, 9, 0},
-        {0, 1, 2},
-        {2, 3, 4},
-    },
-};
-
-/*static*/ const u8 sUnknown_84720AE[5][5][3] =
-{
-    {
-        {1, 0, 1},
-    },
-    {
-        {1, 0, 1},
-        {0, 1, 0},
-    },
-    {
-        {2, 0, 1},
-        {0, 1, 2},
-        {1, 2, 0},
-    },
-    {
-        {3, 0, 1},
-        {0, 1, 2},
-        {1, 2, 3},
-        {2, 3, 0},
-    },
-    {
-        {4, 0, 1},
-        {0, 1, 2},
-        {1, 2, 3},
-        {2, 3, 4},
-        {3, 4, 0},
-    },
-};
-
-ALIGNED(4)
-/*static*/ const u8 sUnknown_84720FC[5][11] =
-{
-    {9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 9},
-    {9, 9, 9, 0, 0, 1, 1, 0, 9, 9, 9},
-    {9, 9, 2, 2, 0, 0, 1, 1, 1, 9, 9},
-    {9, 3, 3, 0, 0, 1, 1, 2, 2, 3, 9},
-    {3, 3, 4, 4, 0, 0, 1, 1, 2, 2, 3},
-};
+// const rom data
 
-/*static*/ const u8 sUnknown_8472133[5][5] =
-{
-    {5},
-    {4, 6},
-    {3, 5, 7},
-    {2, 4, 6, 8},
-    {1, 3, 5, 6, 9},
-};
+// Assets in this header are duplicated
+#include "data/dodrio_berry_picking.h"
 
-// Duplicate and unused gfx. Feel free to remove.
-/*static*/ const u32 sDuplicateGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_bg1.gbapal",
-                                     "graphics/link_games/dodrioberry_bg2.gbapal",
-                                     "graphics/link_games/dodrioberry_pkmn.gbapal",
-                                     "graphics/link_games/dodrioberry_shiny.gbapal",
-                                     "graphics/link_games/dodrioberry_status.gbapal",
-                                     "graphics/link_games/dodrioberry_berrysprites.gbapal",
-                                     "graphics/link_games/dodrioberry_berrysprites.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_platform.gbapal",
-                                     "graphics/link_games/dodrioberry_bg1.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_bg2.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_status.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_platform.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_pkmn.4bpp.lz",
-                                     "graphics/link_games/dodrioberry_bg1.bin.lz",
-                                     "graphics/link_games/dodrioberry_bg2right.bin.lz",
-                                     "graphics/link_games/dodrioberry_bg2left.bin.lz");
-
-/*static*/ const u8 sUnknown_847553C[][3] =
+static const u8 sUnknown_847553C[][3] =
 {
     {40, 24, 13},
     {32, 19, 10},
@@ -164,20 +147,20 @@ ALIGNED(4)
 };
 
 ALIGNED(4)
-/*static*/ const u8 sUnknown_8475548[] = {8, 5, 8, 11, 15};
+static const u8 sUnknown_8475548[] = {8, 5, 8, 11, 15};
 
 ALIGNED(4)
-/*static*/ const u8 sUnknown_8475550[] = {5, 10, 20, 30, 50, 70, 100};
+static const u8 sUnknown_8475550[] = {5, 10, 20, 30, 50, 70, 100};
 
 ALIGNED(4)
-/*static*/ const u8 sUnknown_8475558[][10] =
+static const u8 sUnknown_8475558[][10] =
 {
     {15, 16, 17, 18, 19, 19, 18, 17, 16, 15},
     {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
     {30, 31, 32, 33, 34, 34, 33, 32, 31, 30},
 };
 
-/*static*/ void (*const sUnknown_8475578[])(void) =
+static void (*const sUnknown_8475578[])(void) =
 {
     sub_8150C78,
     sub_8150CBC,
@@ -193,7 +176,7 @@ ALIGNED(4)
     sub_8150F40
 };
 
-/*static*/ void (*const sUnknown_84755A8[])(void) =
+static void (*const sUnknown_84755A8[])(void) =
 {
     sub_8150C78,
     sub_8150CBC,
@@ -209,540 +192,2245 @@ ALIGNED(4)
     sub_8150FC4
 };
 
-/*static*/ const s16 sUnknown_84755D8[] = {10, 30, 50, 50};
+void StartDodrioBerryPicking(u16 a0, MainCallback callback)
+{
+    gUnknown_3002044 = FALSE;
 
-// Data related to printing saved results.
-/*static*/ const struct WindowTemplate sUnknown_84755E0 =
+    if (gReceivedRemoteLinkPlayers && (gUnknown_203F3E0 = AllocZeroed(sizeof(*gUnknown_203F3E0))) != NULL)
+    {
+        sub_81508D8();
+        sub_81508EC(gUnknown_203F3E0);
+        gUnknown_203F3E0->savedCallback = callback;
+        gUnknown_203F3E0->multiplayerId = GetMultiplayerId();
+        gUnknown_203F3E0->unk32CC = gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId];
+        sub_8152048(&gUnknown_203F3E0->unk318C[gUnknown_203F3E0->multiplayerId], &gPlayerParty[a0]);
+        CreateTask(sub_8150A84, 1);
+        SetMainCallback2(sub_815201C);
+        sub_8153150();
+        sub_81529A4(gUnknown_203F3E0->unk24, &gUnknown_203F3E0->unk44, &gUnknown_203F3E0->unk48);
+        StopMapMusic();
+        PlayNewMapMusic(MUS_KINOMIKUI);
+    }
+    else
+    {
+        SetMainCallback2(callback);
+        return;
+    }
+}
+
+static void sub_81508D8(void)
 {
-    .bg = 0,
-    .tilemapLeft = 1,
-    .tilemapTop = 1,
-    .width = 28,
-    .height = 11,
-    .paletteNum = 15,
-    .baseBlock = 1,
-};
+    ResetTasks();
+    ResetSpriteData();
+    FreeAllSpritePalettes();
+}
 
-/*static*/ const u8 *const sUnknown_84755E8[] = {gText_BerryPickingRecords, gText_BerriesPicked, gText_BestScore, gText_BerriesInRowFivePlayers};
-/*static*/ const u8 sUnknown_84755F8[] = {4, 7, 4};
+static void sub_81508EC(struct DodrioStruct * data)
+{
+    u8 i;
+
+    data->unk0C = 0;
+    data->unk10 = 0;
+    data->unk14 = 0;
+    data->unk18 = 0;
+    data->unk1C = 0;
+    data->unk11C = 0;
+    data->unk120 = 0;
+    data->unk30 = 0;
+    data->unk40 = 0;
+    data->unk3C = 0;
+    data->unk12C = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        data->unk98[i] = 0;
+    }
 
-ALIGNED(4)
-/*static*/ const u8 sUnknown_84755FC[][2] = {{24}, {40}, {56}};
-/*static*/ const u8 sUnknown_8475602[][2] = {{24}, {40}, {70}};
+    for (i = 0; i < 5; i++)
+    {
+        data->unkA8[i] = 0;
+        data->unkB0[i] = 0;
+        data->unk4A[i][0] = 0;
+        data->unk4A[i][1] = 0;
+        data->unk4A[i][2] = 0;
+        data->unk4A[i][3] = 0;
+        data->unk4A[i][5] = 0;
+        data->unk10C[i] = 0;
+        data->unk130[i] = 0;
+    }
 
-// Debug functions?
-/*static*/ const u16 sUnknown_8475608[][4] =
+    for (i = 0; i < 11; i++)
+    {
+        data->unkD0[i] = 0;
+        data->unkDC[i] = 0;
+        data->unkC4[i] = 0;
+        data->unkF4[i][0] = 0xFF;
+        data->unkF4[i][1] = 0xFF;
+    }
+
+    data->unk20 = GetMultiplayerId() == 0 ? 1 : 0;
+    data->unk24 = GetLinkPlayerCount();
+    data->unk34[0] = GetMultiplayerId();
+    for (i = 1; i < data->unk24; i++)
+    {
+        data->unk34[i] = data->unk34[i - 1] + 1;
+        if (data->unk34[i] > data->unk24 - 1)
+            data->unk34[i] %= data->unk24;
+    }
+}
+
+static void sub_8150A84(u8 taskId)
 {
-    {9999, 0, 90, 9999},
-    {9999, 9999, 70, 9999},
-    {9999, 0, 9999, 0},
-    {9999, 9999, 60, 0},
-    {9999, 9999, 9999, 0},
-};
+    u8 r4, r5;
 
-/*static*/ const u8 sUnknown_8475630[] = _("あいうえおかき");
-/*static*/ const u8 sUnknown_8475638[] = _("ABCDEFG");
-/*static*/ const u8 sUnknown_8475640[] = _("0123456");
+    switch (gUnknown_203F3E0->unk0C)
+    {
+    case 0:
+        SetVBlankCallback(NULL);
+        sub_815205C(sub_8151750, 4);
+        gUnknown_203F3E0->unk0C++;
+        break;
+    case 1:
+        if (!FuncIsActiveTask(sub_8151750))
+        {
+            sub_8154968(&gUnknown_203F3E0->unk160);
+            gUnknown_203F3E0->unk0C++;
+        }
+        break;
+    case 2:
+        if (!sub_8155E68())
+        {
+            LinkRfu_SetRfuFuncToSend6600();
+            gUnknown_203F3E0->unk0C++;
+        }
+        break;
+    case 3:
+        if (IsLinkTaskFinished())
+        {
+            if (gReceivedRemoteLinkPlayers)
+            {
+                LoadWirelessStatusIndicatorSpriteGfx();
+                CreateWirelessStatusIndicatorSprite(0, 0);
+            }
+            gUnknown_203F3E0->unk0C++;
+        }
+        break;
+    case 4:
+        r5 = gUnknown_203F3E0->unk24;
+        sub_8153A9C();
+        for (r4 = 0; r4 < r5; r4++)
+        {
+            sub_8153AFC(&gUnknown_203F3E0->unk318C[gUnknown_203F3E0->unk34[r4]], r4, gUnknown_203F3E0->unk34[r4], gUnknown_203F3E0->unk24);
+        }
+        sub_8153D80(FALSE, gUnknown_203F3E0->unk24);
+        gUnknown_203F3E0->unk0C++;
+        break;
+    case 5:
+        sub_8154128();
+        sub_815417C();
+        sub_8154438();
+        sub_8153E28();
+        gUnknown_203F3E0->unk0C++;
+        break;
+    case 6:
+        BlendPalettes(0xFFFFFFFF, 0x10, RGB_BLACK);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+        SetVBlankCallback(sub_8152034);
+        gUnknown_203F3E0->unk0C++;
+        break;
+    case 7:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            gUnknown_203F3E0->unk0C++;
+        }
+        break;
+    default:
+        DestroyTask(taskId);
+        sub_815206C(sub_81516DC);
+        break;
+    }
+}
 
-/*static*/ const u8 *const sUnknown_8475648[] =
+static void sub_8150C08(u8 taskId)
 {
-    sUnknown_8475630,
-    sUnknown_8475630,
-    sUnknown_8475630,
-    sUnknown_8475638,
-    sUnknown_8475640
-};
+    sub_8151B54();
+    sUnknown_8475578[gUnknown_203F3E0->unk18]();
+    if (!gUnknown_3002044)
+    {
+        sub_815293C();
+    }
+    sub_8151BA0();
+}
 
-// Large chunk of data
-/*static*/ const struct BgTemplate sUnknown_847565C[] =
-{
-    {
-        .bg = 0,
-        .charBaseIndex = 0,
-        .mapBaseIndex = 30,
-        .screenSize = 0,
-        .paletteMode = 0,
-        .priority = 0,
-        .baseTile = 0
-    },
-    {
-        .bg = 1,
-        .charBaseIndex = 2,
-        .mapBaseIndex = 12,
-        .screenSize = 1,
-        .paletteMode = 0,
-        .priority = 1,
-        .baseTile = 0
-    },
-    {
-        .bg = 2,
-        .charBaseIndex = 2,
-        .mapBaseIndex = 14,
-        .screenSize = 1,
-        .paletteMode = 0,
-        .priority = 1,
-        .baseTile = 0
-    },
-    {
-        .bg = 3,
-        .charBaseIndex = 3,
-        .mapBaseIndex = 31,
-        .screenSize = 0,
-        .paletteMode = 0,
-        .priority = 2,
-        .baseTile = 0
-    },
-};
+static void sub_8150C40(u8 taskId)
+{
+    sub_8151C5C();
+    sUnknown_84755A8[gUnknown_203F3E0->unk18]();
+    if (!gUnknown_3002044)
+    {
+        sub_8152970();
+    }
+    sub_8151D28();
+}
 
-// Unknown unreferenced data, feel free to remove.
-/*static*/ const u32 sUnused[] = {255, 0};
+static void sub_8150C78(void)
+{
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        sub_8153BF8(1);
+        sub_81549D4(1);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (!sub_8155E68())
+            sub_8152090(1);
+        break;
+    }
+}
 
-/*static*/ const struct WindowTemplate sUnknown_8475674[] =
+static void sub_8150CBC(void)
 {
+    if (gUnknown_203F3E0->unk10 == 0)
     {
-        .bg = 0,
-        .tilemapLeft = 1,
-        .tilemapTop = 1,
-        .width = 28,
-        .height = 3,
-        .paletteNum = 13,
-        .baseBlock = 0x13,
-    },
+        sub_8152110();
+        gUnknown_203F3E0->unk10++;
+    }
+    else
     {
-        .bg = 0,
-        .tilemapLeft = 1,
-        .tilemapTop = 6,
-        .width = 28,
-        .height = 13,
-        .paletteNum = 13,
-        .baseBlock = 0x67,
+        gUnknown_203F3E0->unk118 = 1;
+        sub_8152090(2);
     }
-};
+}
 
-/*static*/ const struct WindowTemplate sUnknown_8475684 =
+static void sub_8150CF4(void)
 {
-    .bg = 0,
-    .tilemapLeft = 1,
-    .tilemapTop = 6,
-    .width = 28,
-    .height = 7,
-    .paletteNum = 13,
-    .baseBlock = 0x67,
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        StartMinigameCountdown(7, 8, 120, 80, 0);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        LinkRfu_SetRfuFuncToSend6600();
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 2:
+        if (IsLinkTaskFinished())
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 3:
+        if (!IsMinigameCountdownRunning())
+        {
+            LinkRfu_SetRfuFuncToSend6600();
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 4:
+        if (IsLinkTaskFinished())
+        {
+            sub_8152090(3);
+        }
+        break;
+    }
+}
 
-/*static*/ const struct WindowTemplate sUnknown_847568C[] =
+static void sub_8150D7C(void)
 {
+    if (gUnknown_203F3E0->unk10 == 0)
     {
-        .bg = 0,
-        .tilemapLeft = 1,
-        .tilemapTop = 8,
-        .width = 19,
-        .height = 3,
-        .paletteNum = 13,
-        .baseBlock = 0x13,
-    },
+        if (gUnknown_203F3E0->unk11C != 0)
+        {
+            sub_8152090(4);
+        }
+    }
+}
+
+static void sub_8150DA4(void)
+{
+    if (gUnknown_203F3E0->unk10 == 0)
     {
-        .bg = 0,
-        .tilemapLeft = 22,
-        .tilemapTop = 7,
-        .width = 6,
-        .height = 4,
-        .paletteNum = 13,
-        .baseBlock = 0x4C,
+        if (gUnknown_203F3E0->unk40 < 10)
+        {
+            if (gUnknown_203F3E0->unkA8[0] == 0)
+            {
+                if (JOY_NEW(DPAD_UP))
+                {
+                    if (gUnknown_203F3E0->unk31A0[0].unk2C.unk0 == 0)
+                    {
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk4 = 0;
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk0 = sub_815327C(2);
+                    }
+                }
+                else if (JOY_NEW(DPAD_RIGHT))
+                {
+                    if (gUnknown_203F3E0->unk31A0[0].unk2C.unk0 == 0)
+                    {
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk4 = 0;
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk0 = sub_815327C(1);
+                    }
+                }
+                else if (JOY_NEW(DPAD_LEFT))
+                {
+                    if (gUnknown_203F3E0->unk31A0[0].unk2C.unk0 == 0)
+                    {
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk4 = 0;
+                        gUnknown_203F3E0->unk31A0[0].unk2C.unk0 = sub_815327C(3);
+                    }
+                }
+                else
+                {
+                    gUnknown_203F3E0->unk31A0[0].unk2C.unk0 = sub_815327C(0);
+                }
+            }
+        }
+        else
+        {
+            sub_8152090(11);
+        }
+        sub_815256C();
+        sub_8151D98();
     }
-};
+}
+static void sub_8150E68(void)
+{
+    if (gUnknown_203F3E0->unk40 < 10)
+    {
+        if (JOY_NEW(DPAD_UP))
+        {
+            if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 == 0)
+            {
+                gUnknown_203F3E0->unk32CC.unk2C.unk0 = 2;
+            }
+        }
+        else if (JOY_NEW(DPAD_RIGHT))
+        {
+            if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 == 0)
+            {
+                gUnknown_203F3E0->unk32CC.unk2C.unk0 = 1;
+            }
+        }
+        else if (JOY_NEW(DPAD_LEFT))
+        {
+            if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 == 0)
+            {
+                gUnknown_203F3E0->unk32CC.unk2C.unk0 = 3;
+            }
+        }
+        else
+        {
+            gUnknown_203F3E0->unk32CC.unk2C.unk0 = 0;
+        }
+    }
+    else
+    {
+        sub_8152090(11);
+    }
+    sub_8151E94();
+}
 
-/*static*/ const struct WindowTemplate sUnknown_847569C =
+static void sub_8150F40(void)
 {
-    .bg = 0,
-    .tilemapLeft = 4,
-    .tilemapTop = 6,
-    .width = 22,
-    .height = 5,
-    .paletteNum = 13,
-    .baseBlock = 0x13,
-};
+    u8 i;
 
-/*static*/ const struct WindowTemplate sUnknown_84756A4 =
+    sub_815256C();
+    sub_8151D98();
+    if (sub_8152A98() == 1)
+    {
+        sub_8153004();
+        sub_8152090(5);
+    }
+    else
+    {
+        gUnknown_203F3E0->unk12C = 1;
+        for (i = 1; i < gUnknown_203F3E0->unk24; i++)
+        {
+            if (gUnknown_203F3E0->unk130[i] != 1)
+            {
+                gUnknown_203F3E0->unk12C = 0;
+                break;
+            }
+        }
+    }
+}
+
+static void sub_8150FC4(void)
 {
-    .bg = 0,
-    .tilemapLeft = 5,
-    .tilemapTop = 8,
-    .width = 19,
-    .height = 3,
-    .paletteNum = 13,
-    .baseBlock = 0x13,
-};
+    sub_8151E94();
+    if (sub_8152AD8() == 1)
+        sub_8152090(5);
+}
 
-// This is an unused copy of the tables from the top of the file. Feel free to remove.
-/*static*/ const u8 sDuplicateArray[] =
-{
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 0, 0, 1, 2, 5, 6, 3, 4, 5, 8, 9, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 2, 9,
-    0, 0, 1, 4, 5, 6, 7, 2, 3, 4, 9, 0, 0, 1, 6, 7, 2, 3, 4, 5, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 0, 0, 3, 4, 5, 6, 7, 8, 1, 2, 3, 0, 0, 5, 6, 7, 8, 1, 2, 3, 4, 5, 0, 0, 7,
-    8, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0,
-    1, 2, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 6, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 5, 6, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 6, 7, 2, 2, 3, 4, 0, 0, 0, 0, 0, 0,
-    3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2, 3, 0, 0, 0, 4, 5, 6, 6, 7, 8, 8, 9, 0, 0, 1, 2, 2, 3, 4, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 0, 1, 2, 1, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 1,
-    2, 1, 2, 3, 2, 3, 0, 0, 0, 0, 4, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 0, 0, 0, 0, 9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9,
-    9, 9, 0, 0, 1, 1, 0, 9, 9, 9, 9, 9, 2, 2, 0, 0, 1, 1, 1, 9, 9, 9, 3, 3, 0, 0, 1, 1, 2, 2, 3, 9, 3, 3, 4, 4, 0, 0, 1, 1,
-    2, 2, 3, 5, 0, 0, 0, 0, 4, 6, 0, 0, 0, 3, 5, 7, 0, 0, 2, 4, 6, 8, 0, 1, 3, 5, 6, 9
-};
+static void sub_8150FDC(void)
+{
+    u8 blockReceivedStatus;
+    u8 i;
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        SendBlock(0, gUnknown_203F3E0->unk4A, sizeof(gUnknown_203F3E0->unk4A));
+        gUnknown_203F3E0->unk08 = 0;
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        blockReceivedStatus = GetBlockReceivedStatus();
+        for (i = 0; i < gUnknown_203F3E0->unk24; blockReceivedStatus >>= 1, i++)
+        {
+            if (blockReceivedStatus & 1)
+            {
+                ResetBlockReceivedFlag(i);
+                gUnknown_203F3E0->unk08++;
+            }
+        }
+        if (gUnknown_203F3E0->unk08 >= gUnknown_203F3E0->unk24)
+        {
+            gUnknown_203F3E0->unk14++;
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    default:
+        if (WaitFanfare(TRUE))
+        {
+            sub_8152090(6);
+            FadeOutAndPlayNewMapMusic(MUS_WIN_YASEI, 4);
+        }
+        break;
+    }
+}
 
-/*static*/ const u16 sDodrioBerryBgPal1[] = INCBIN_U16("graphics/link_games/dodrioberry_bg1.gbapal",
-                                            "graphics/link_games/dodrioberry_bg2.gbapal");
-/*static*/ const u16 sDodrioBerryPkmnPal[] = INCBIN_U16("graphics/link_games/dodrioberry_pkmn.gbapal");
-/*static*/ const u16 sDodrioBerryShinyPal[] = INCBIN_U16("graphics/link_games/dodrioberry_shiny.gbapal");
-/*static*/ const u16 sDodrioBerryStatusPal[] = INCBIN_U16("graphics/link_games/dodrioberry_status.gbapal");
-/*static*/ const u16 sDodrioBerrySpritesPal[] = INCBIN_U16("graphics/link_games/dodrioberry_berrysprites.gbapal");
-/*static*/ const u32 sDodrioBerrySpritesGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_berrysprites.4bpp.lz");
-/*static*/ const u16 sDodrioBerryPlatformPal[] = INCBIN_U16("graphics/link_games/dodrioberry_platform.gbapal");
-/*static*/ const u32 sDodrioBerryBgGfx1[] = INCBIN_U32("graphics/link_games/dodrioberry_bg1.4bpp.lz");
-/*static*/ const u32 sDodrioBerryBgGfx2[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2.4bpp.lz");
-/*static*/ const u32 sDodrioBerryStatusGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_status.4bpp.lz");
-/*static*/ const u32 sDodrioBerryPlatformGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_platform.4bpp.lz");
-/*static*/ const u32 sDodrioBerryPkmnGfx[] = INCBIN_U32("graphics/link_games/dodrioberry_pkmn.4bpp.lz");
-/*static*/ const u32 sDodrioBerryBgTilemap1[] = INCBIN_U32("graphics/link_games/dodrioberry_bg1.bin.lz");
-/*static*/ const u32 sDodrioBerryBgTilemap2Right[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2right.bin.lz");
-/*static*/ const u32 sDodrioBerryBgTilemap2Left[] = INCBIN_U32("graphics/link_games/dodrioberry_bg2left.bin.lz");
-
-/*static*/ const struct OamData sOamData_8478C98 =
-{
-    .y = 0,
-    .affineMode = ST_OAM_AFFINE_OFF,
-    .objMode = ST_OAM_OBJ_NORMAL,
-    .mosaic = FALSE,
-    .bpp = ST_OAM_4BPP,
-    .shape = SPRITE_SHAPE(64x64),
-    .x = 0,
-    .matrixNum = 0,
-    .size = SPRITE_SIZE(64x64),
-    .tileNum = 0,
-    .priority = 2,
-    .paletteNum = 0,
-    .affineParam = 0
-};
+static void sub_815109C(void)
+{
+    u8 i;
+    u8 blockReceivedStatus;
+
+    switch (gUnknown_203F3E0->unk10) {
+    case 0:
+        SendBlock(0, gUnknown_203F3E0->unk4A[gUnknown_203F3E0->unk14], sizeof(gUnknown_203F3E0->unk4A));
+        gUnknown_203F3E0->unk08 = 0;
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (IsLinkTaskFinished()) {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        blockReceivedStatus = GetBlockReceivedStatus();
+        for (i = 0; i < gUnknown_203F3E0->unk24; blockReceivedStatus >>= 1, i++)
+        {
+            if (blockReceivedStatus & 1)
+            {
+                memcpy(gUnknown_203F3E0->unk4A, gBlockRecvBuffer, sizeof(gUnknown_203F3E0->unk4A));
+                ResetBlockReceivedFlag(i);
+                gUnknown_203F3E0->unk08++;
+            }
+        }
+        if (gUnknown_203F3E0->unk08 >= gUnknown_203F3E0->unk24) {
+            gUnknown_203F3E0->unk14++;
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    default:
+        if (WaitFanfare(TRUE)) {
+            gUnknown_203F3E0->unk114 = gUnknown_203F3E0->unk4A[gUnknown_203F3E0->multiplayerId][5];
+            sub_8152090(6);
+            FadeOutAndPlayNewMapMusic(MUS_WIN_YASEI, 4);
+        }
+        break;
+    }
+}
 
-/*static*/ const struct OamData sOamData_8478CA0 =
-{
-    .y = 0,
-    .affineMode = ST_OAM_AFFINE_OFF,
-    .objMode = ST_OAM_OBJ_NORMAL,
-    .mosaic = FALSE,
-    .bpp = ST_OAM_4BPP,
-    .shape = SPRITE_SHAPE(16x16),
-    .x = 0,
-    .matrixNum = 0,
-    .size = SPRITE_SIZE(16x16),
-    .tileNum = 0,
-    .priority = 0,
-    .paletteNum = 0,
-    .affineParam = 0
-};
+static void sub_8151198(void)
+{
+    u8 sp00;
+    u8 i;
+    u8 blockReceivedStatus;
 
-/*static*/ const struct OamData sOamData_8478CA8 =
-{
-    .y = 0,
-    .affineMode = ST_OAM_AFFINE_OFF,
-    .objMode = ST_OAM_OBJ_NORMAL,
-    .mosaic = FALSE,
-    .bpp = ST_OAM_4BPP,
-    .shape = SPRITE_SHAPE(16x16),
-    .x = 0,
-    .matrixNum = 0,
-    .size = SPRITE_SIZE(16x16),
-    .tileNum = 0,
-    .priority = 2,
-    .paletteNum = 0,
-    .affineParam = 0
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        sub_81531FC();
+        sub_81540DC(TRUE);
+        sub_81544F0();
+        sub_81545BC(TRUE);
+        sub_81549D4(2);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (!sub_8155E68())
+        {
+            sp00 = 1;
+            sub_81549D4(5);
+            sp00 = sub_8155E8C();
+            SendBlock(0, &sp00, sizeof(sp00));
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        if (IsLinkTaskFinished())
+        {
+            gUnknown_203F3E0->unk10++;
+            gUnknown_203F3E0->unk08 = 0;
+        }
+        break;
+    case 3:
+        blockReceivedStatus = GetBlockReceivedStatus();
+        for (i = 0; i < gUnknown_203F3E0->unk24; blockReceivedStatus >>= 1, i++)
+        {
+            if (blockReceivedStatus & 1)
+            {
+                *(gUnknown_203F3E0->unk10C + i) = *(u8 *)gBlockRecvBuffer[i];
+                ResetBlockReceivedFlag(i);
+                gUnknown_203F3E0->unk08++;
+            }
+        }
+        if (gUnknown_203F3E0->unk08 >= gUnknown_203F3E0->unk24) {
+            if (++gUnknown_203F3E0->unk14 >= 120)
+            {
+                sub_81549D4(6);
+                gUnknown_203F3E0->unk10++;
+            }
+        }
+        break;
+    default:
+        if (!sub_8155E68())
+        {
+            sub_8152090(7);
+        }
+        break;
+    }
+}
 
-/*static*/ const struct OamData sOamData_8478CB0 =
-{
-    .y = 0,
-    .affineMode = ST_OAM_AFFINE_OFF,
-    .objMode = ST_OAM_OBJ_NORMAL,
-    .mosaic = FALSE,
-    .bpp = ST_OAM_4BPP,
-    .shape = SPRITE_SHAPE(64x32),
-    .x = 0,
-    .matrixNum = 0,
-    .size = SPRITE_SIZE(64x32),
-    .tileNum = 0,
-    .priority = 3,
-    .paletteNum = 0,
-    .affineParam = 0
-};
+static void sub_81512B4(void)
+{
+    u8 sp0;
+    u8 i;
+    u8 blockReceivedStatus;
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CB8[] =
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        if (sub_81534AC() >= 3000)
+        {
+            sub_81549D4(4);
+        }
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (!sub_8155E68())
+        {
+            sub_81549D4(3);
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        sub_81546C0();
+        sub_8153048();
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 3:
+        if ((sp0 = sub_8155E8C()) != 0)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 4:
+        if (!sub_8155E68())
+        {
+            sub_81549D4(5);
+            sp0 = sub_8155E8C();
+            SendBlock(0, &sp0, sizeof(sp0));
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 5:
+        if (IsLinkTaskFinished())
+        {
+            gUnknown_203F3E0->unk10++;
+            gUnknown_203F3E0->unk08 = 0;
+        }
+        break;
+    case 6:
+        blockReceivedStatus = GetBlockReceivedStatus();
+        for (i = 0; i < gUnknown_203F3E0->unk24; blockReceivedStatus >>= 1, i++)
+        {
+            if (blockReceivedStatus & 1)
+            {
+                *(gUnknown_203F3E0->unk10C + i) = *(u8 *)gBlockRecvBuffer[i];
+                ResetBlockReceivedFlag(i);
+                gUnknown_203F3E0->unk08++;
+            }
+        }
+        if (gUnknown_203F3E0->unk08 >= gUnknown_203F3E0->unk24) {
+            if (++gUnknown_203F3E0->unk14 >= 120)
+            {
+                sub_815336C();
+                sub_81549D4(6);
+                gUnknown_203F3E0->unk10++;
+            }
+        }
+        else
+        {
+            sub_81532B8();
+        }
+        break;
+    default:
+        if (!sub_8155E68())
+        {
+            for (i = 0; i < gUnknown_203F3E0->unk24; i++)
+            {
+                if (gUnknown_203F3E0->unk10C[i] == 2)
+                {
+                    sub_8152090(8);
+                    return;
+                }
+            }
+            sub_8152090(10);
+        }
+        break;
+    }
+}
+
+static void sub_8151488(void)
 {
-    ANIMCMD_FRAME(0, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        Link_TryStartSend5FFF();
+        sub_81549D4(7);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        if (!sub_8155E68())
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        if (sub_8155E8C() == 5)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    default:
+        if (!gReceivedRemoteLinkPlayers)
+        {
+            sub_8152090(9);
+        }
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CC0[] =
+static void sub_81514F0(void)
 {
-    ANIMCMD_FRAME(64, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        sub_8154274();
+        sub_8153ED8();
+        sub_8153D08(gUnknown_203F3E0->unk24);
+        sub_8154578();
+        gUnknown_3002044 = TRUE;
+        sub_81549D4(8);
+        gUnknown_203F3E0->unk10++;
+        break;
+    default:
+        if (!sub_8155E68())
+        {
+            SetMainCallback2(gUnknown_203F3E0->savedCallback);
+            DestroyTask(gUnknown_203F3E0->unk04);
+            Free(gUnknown_203F3E0);
+            FreeAllWindowBuffers();
+        }
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CC8[] =
+static void sub_815159C(void)
 {
-    ANIMCMD_FRAME(128, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        sub_81549D4(9);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 1:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 2:
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgX(2, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 3:
+        StopMapMusic();
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 4:
+        PlayNewMapMusic(MUS_KINOMIKUI);
+        sub_8154540();
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 5:
+        BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 6:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    default:
+        DestroyTask(gUnknown_203F3E0->unk04);
+        sub_815206C(sub_81516DC);
+        sub_8154730();
+        sub_81508EC(gUnknown_203F3E0);
+        if (!gReceivedRemoteLinkPlayers)
+        {
+            gUnknown_203F3E0->unk24 = 1;
+        }
+        sub_8153150();
+        sub_81545BC(FALSE);
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CD0[] =
+static void sub_81516DC(u8 taskId)
 {
-    ANIMCMD_FRAME(192, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk10)
+    {
+    case 0:
+        if (sub_81520B4() == 1)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    case 1:
+        sub_8153DD8();
+        gUnknown_203F3E0->unk10++;
+        break;
+    case 2:
+        if (sub_8153F1C() == TRUE)
+        {
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    default:
+        if (gUnknown_203F3E0->unk20 != 0)
+        {
+            sub_815206C(sub_8150C08);
+        }
+        else
+        {
+            sub_815206C(sub_8150C40);
+        }
+        DestroyTask(taskId);
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CD8[] =
+static void sub_8151750(u8 taskId)
 {
-    ANIMCMD_FRAME(256, 20),
-    ANIMCMD_JUMP(0)
-};
+    s16 * data = gTasks[taskId].data;
+    u8 i;
+    u8 blockReceivedStatus;
+
+    switch (data[0])
+    {
+    case 0:
+        SendBlock(0, &gUnknown_203F3E0->unk318C[gUnknown_203F3E0->multiplayerId].isShiny, sizeof(gUnknown_203F3E0->unk318C[gUnknown_203F3E0->multiplayerId].isShiny));
+        gUnknown_203F3E0->unk08 = 0;
+        data[0]++;
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+        {
+            data[0]++;
+        }
+        break;
+    case 2:
+        blockReceivedStatus = GetBlockReceivedStatus();
+        for (i = 0; i < gUnknown_203F3E0->unk24; blockReceivedStatus >>= 1, i++)
+        {
+            if (blockReceivedStatus & 1)
+            {
+                *(u8 *)&gUnknown_203F3E0->unk318C[i] = *(u8 *)gBlockRecvBuffer[i];
+                ResetBlockReceivedFlag(i);
+                gUnknown_203F3E0->unk08++;
+            }
+        }
+        if (gUnknown_203F3E0->unk08 >= gUnknown_203F3E0->unk24)
+        {
+            DestroyTask(taskId);
+            sub_81549D4(6);
+            gUnknown_203F3E0->unk10++;
+        }
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd *const sSpriteAnimTable_8478CE0[] =
+static void sub_815184C(void)
 {
-    sSpriteAnim_8478CB8,
-    sSpriteAnim_8478CC0,
-    sSpriteAnim_8478CC8,
-    sSpriteAnim_8478CD0,
-    sSpriteAnim_8478CD8
-};
+    u8 i;
+    u8 r7 = gUnknown_203F3E0->unk24;
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CF4[] =
+    gUnknown_203F3E0->unk31A0[0].unk10 = sub_815A950(0, &gUnknown_203F3E0->unk31A0[0], &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, &gUnknown_203F3E0->unk40, &gUnknown_203F3E0->unk120, &gUnknown_203F3E0->unk12C);
+    gUnknown_203F3E0->unk128 = 1;
+
+    for (i = 1; i < r7; i++)
+    {
+        if (   gUnknown_203F3E0->unkA8[i] == 0
+               && sub_815AB04(i, &gUnknown_203F3E0->unk31A0[i].unk2C.unk0) == 0)
+        {
+            gUnknown_203F3E0->unk31A0[i].unk2C.unk0 = 0;
+            gUnknown_203F3E0->unk128 = 0;
+        }
+    }
+    if (++gUnknown_203F3E0->unk124 >= 60)
+    {
+        if (gUnknown_203F3E0->unk128 != 0)
+        {
+            sub_80FBA44();
+            gUnknown_203F3E0->unk124 = 0;
+        }
+        else if (gUnknown_203F3E0->unk124 > 70)
+        {
+            sub_80FBA44();
+            gUnknown_203F3E0->unk124 = 0;
+        }
+    }
+
+    for (i = 0; i < r7; i++)
+    {
+        if (   gUnknown_203F3E0->unk31A0[i].unk2C.unk0 != 0
+               && gUnknown_203F3E0->unkA8[i] == 0)
+        {
+            gUnknown_203F3E0->unkA8[i] = 1;
+        }
+        switch (gUnknown_203F3E0->unkA8[i])
+        {
+        case 0:
+        default:
+            break;
+        case 1 ... 3:
+            if (++gUnknown_203F3E0->unkB0[i] >= 6)
+            {
+                gUnknown_203F3E0->unkB0[i] = 0;
+                gUnknown_203F3E0->unkA8[i] = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk0 = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk4 = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk8 = 0;
+            }
+            break;
+        case 4:
+            if (++gUnknown_203F3E0->unkB0[i] >= 40)
+            {
+                gUnknown_203F3E0->unkB0[i] = 0;
+                gUnknown_203F3E0->unkA8[i] = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk0 = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk4 = 0;
+                gUnknown_203F3E0->unk31A0[i].unk2C.unk8 = 0;
+            }
+            break;
+        }
+    }
+}
+
+static void sub_8151A5C(void)
 {
-    ANIMCMD_FRAME(0, 20),
-    ANIMCMD_JUMP(0)
-};
+    u8 i;
+    u8 r6 = gUnknown_203F3E0->unk24;
 
-/*static*/ const union AnimCmd sSpriteAnim_8478CFC[] =
+    gUnknown_203F3E0->unk31A0[0].unk10 = sub_815A950(0, &gUnknown_203F3E0->unk31A0[0], &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, &gUnknown_203F3E0->unk40, &gUnknown_203F3E0->unk120, &gUnknown_203F3E0->unk12C);
+    gUnknown_203F3E0->unk128 = 1;
+
+    for (i = 1; i < r6; i++)
+    {
+        if (sub_815AB60(i) != 0)
+        {
+            gUnknown_203F3E0->unk130[i] = 1;
+            gUnknown_203F3E0->unk128 = 0;
+        }
+    }
+    if (++gUnknown_203F3E0->unk124 >= 60)
+    {
+        if (gUnknown_203F3E0->unk128 != 0)
+        {
+            sub_80FBA44();
+            gUnknown_203F3E0->unk124 = 0;
+        }
+        else if (gUnknown_203F3E0->unk124 > 70)
+        {
+            sub_80FBA44();
+            gUnknown_203F3E0->unk124 = 0;
+        }
+    }
+}
+
+static void sub_8151B54(void)
 {
-    ANIMCMD_FRAME(4, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk18)
+    {
+    case 3:
+        if (sub_8152A00() == TRUE)
+        {
+            sub_8152A70();
+            gUnknown_203F3E0->unk11C = 1;
+        }
+        break;
+    case 4:
+        sub_815184C();
+        break;
+    case 11:
+        sub_8151A5C();
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D04[] =
+static void sub_8151BA0(void)
 {
-    ANIMCMD_FRAME(8, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk18)
+    {
+    case 4:
+        sub_815A61C(&gUnknown_203F3E0->unk32CC, &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, gUnknown_203F3E0->unk40, gUnknown_203F3E0->unk120, gUnknown_203F3E0->unk12C);
+        break;
+    case 11:
+        sub_815A61C(&gUnknown_203F3E0->unk32CC, &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, gUnknown_203F3E0->unk40, gUnknown_203F3E0->unk120, gUnknown_203F3E0->unk12C);
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd *const sSpriteAnimTable_8478D0C[] =
+static void sub_8151C5C(void)
 {
-    sSpriteAnim_8478CF4,
-    sSpriteAnim_8478CFC,
-    sSpriteAnim_8478D04
-};
+    switch (gUnknown_203F3E0->unk18)
+    {
+    case 4:
+        sub_815A950(gUnknown_203F3E0->multiplayerId, &gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId], &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, &gUnknown_203F3E0->unk40, &gUnknown_203F3E0->unk120, &gUnknown_203F3E0->unk12C);
+        break;
+    case 11:
+        sub_815A950(gUnknown_203F3E0->multiplayerId, &gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId], &gUnknown_203F3E0->unk31A0[0].unk2C, &gUnknown_203F3E0->unk31A0[1].unk2C, &gUnknown_203F3E0->unk31A0[2].unk2C, &gUnknown_203F3E0->unk31A0[3].unk2C, &gUnknown_203F3E0->unk31A0[4].unk2C, &gUnknown_203F3E0->unk40, &gUnknown_203F3E0->unk120, &gUnknown_203F3E0->unk12C);
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D18[] =
+static void sub_8151D28(void)
 {
-    ANIMCMD_FRAME(0, 20),
-    ANIMCMD_JUMP(0)
-};
+    switch (gUnknown_203F3E0->unk18)
+    {
+    case 3:
+        sub_815A5BC(1);
+        gUnknown_203F3E0->unk11C = 1;
+        break;
+    case 4:
+        if (gUnknown_203F3E0->unk32CC.unk2C.unk0 != 0)
+        {
+            sub_815AAD8(gUnknown_203F3E0->unk32CC.unk2C.unk0);
+        }
+        break;
+    case 11:
+        if (gUnknown_203F3E0->unk120 == 0 && gUnknown_203F3E0->unk12C == 0)
+        {
+            sub_815AB3C(1);
+        }
+        break;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D20[] =
+static void sub_8151D98(void)
 {
-    ANIMCMD_FRAME(4, 20),
-    ANIMCMD_JUMP(0)
-};
+    if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 == 0)
+    {
+        if (!IsSEPlaying())
+        {
+            gUnknown_203F3E0->unk144 = 0;
+        }
+    }
+    else if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk4 == 1)
+    {
+        if (gUnknown_203F3E0->unk144 == 0)
+        {
+            m4aSongNumStop(SE_SEIKAI);
+            PlaySE(SE_SEIKAI);
+            gUnknown_203F3E0->unk144 = 1;
+        }
+    }
+    else if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk8 == 1)
+    {
+        if (gUnknown_203F3E0->unk144 == 0 && !IsSEPlaying())
+        {
+            PlaySE(SE_BOO);
+            sub_8153BC0(1);
+            gUnknown_203F3E0->unk144 = 1;
+        }
+    }
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D28[] =
+    if (gUnknown_203F3E0->unk154 == 0 && gUnknown_203F3E0->unk40 >= 10)
+    {
+        StopMapMusic();
+        gUnknown_203F3E0->unk154 = 1;
+    }
+    else if (gUnknown_203F3E0->unk154 == 1)
+    {
+        PlayFanfareByFanfareNum(FANFARE_10); // MUS_ME_ZANNEN
+        gUnknown_203F3E0->unk154 = 2;
+    }
+}
+
+static void sub_8151E94(void)
 {
-    ANIMCMD_FRAME(8, 20),
-    ANIMCMD_JUMP(0)
-};
+    u8 r8 = gUnknown_203F3E0->unk44;
+    u8 r7 = gUnknown_203F3E0->unk48;
+    u8 r4;
+    if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 == 0)
+    {
+        if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk4 != 1 && gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk8 != 1)
+        {
+            gUnknown_203F3E0->unk144 = 0;
+        }
+    }
+    else if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk4 == 1)
+    {
+        if (gUnknown_203F3E0->unk144 == 0)
+        {
+            m4aSongNumStop(SE_SEIKAI);
+            PlaySE(SE_SEIKAI);
+            gUnknown_203F3E0->unk144 = 1;
+        }
+    }
+    else if (gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk8 == 1)
+    {
+        if (gUnknown_203F3E0->unk144 == 0 && !IsSEPlaying())
+        {
+            PlaySE(SE_BOO);
+            sub_8153BC0(1);
+            gUnknown_203F3E0->unk144 = 1;
+        }
+    }
+    for (r4 = r8; r4 < r7; r4++)
+    {
+        struct DodrioSubstruct_31A0_14 * ptr = &gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk14;
+        if (ptr->unkB[r4] >= 10)
+        {
+            if (gUnknown_203F3E0->unk148[r4] == 0)
+            {
+                PlaySE(SE_FUUSEN1 + ptr->unk0[r4]);
+                gUnknown_203F3E0->unk148[r4] = 1;
+            }
+        }
+        else
+        {
+            gUnknown_203F3E0->unk148[r4] = 0;
+        }
+    }
+    if (gUnknown_203F3E0->unk154 == 0 && gUnknown_203F3E0->unk40 >= 10)
+    {
+        StopMapMusic();
+        gUnknown_203F3E0->unk154 = 1;
+    }
+    else if (gUnknown_203F3E0->unk154 == 1)
+    {
+        PlayFanfareByFanfareNum(FANFARE_10); // MUS_ME_ZANNEN
+        gUnknown_203F3E0->unk154 = 2;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D30[] =
+static void sub_815201C(void)
 {
-    ANIMCMD_FRAME(12, 20),
-    ANIMCMD_JUMP(0)
-};
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D38[] =
+static void sub_8152034(void)
 {
-    ANIMCMD_FRAME(16, 20),
-    ANIMCMD_JUMP(0)
-};
+    TransferPlttBuffer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D40[] =
+static void sub_8152048(struct DodrioSubstruct_318C * a0, struct Pokemon * a1)
 {
-    ANIMCMD_FRAME(20, 20),
-    ANIMCMD_JUMP(0)
-};
+    a0->isShiny = IsMonShiny(a1);
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D48[] =
+static void sub_815205C(TaskFunc func, u8 priority)
 {
-    ANIMCMD_FRAME(24, 20),
-    ANIMCMD_JUMP(0)
-};
+    CreateTask(func, priority);
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D50[] =
+static void sub_815206C(TaskFunc func)
 {
-    ANIMCMD_FRAME(28, 20),
-    ANIMCMD_JUMP(0)
-};
+    gUnknown_203F3E0->unk04 = CreateTask(func, 1);
+    gUnknown_203F3E0->unk10 = 0;
+    gUnknown_203F3E0->unk0C = 0;
+    gUnknown_203F3E0->unk14 = 0;
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D58[] =
+static void sub_8152090(u8 a0)
 {
-    ANIMCMD_FRAME(32, 20),
-    ANIMCMD_JUMP(0)
-};
+    gUnknown_203F3E0->unk1C = gUnknown_203F3E0->unk18;
+    gUnknown_203F3E0->unk18 = a0;
+    gUnknown_203F3E0->unk10 = 0;
+    gUnknown_203F3E0->unk14 = 0;
+}
 
-/*static*/ const union AnimCmd *const sSpriteAnimTable_8478D60[] =
-{
-    sSpriteAnim_8478D18,
-    sSpriteAnim_8478D20,
-    sSpriteAnim_8478D28,
-    sSpriteAnim_8478D30,
-    sSpriteAnim_8478D38,
-    sSpriteAnim_8478D40,
-    sSpriteAnim_8478D48,
-    sSpriteAnim_8478D50,
-    sSpriteAnim_8478D58
-};
+static bool32 sub_81520B4(void)
+{
+    u8 r2 = gUnknown_203F3E0->unk14 / 4;
+    gUnknown_203F3E0->unk14++;
+    if (r2 != 0 && gUnknown_203F3E0->unk14 % 4 == 0)
+    {
+        if (r2 < sUnknown_8475548[gUnknown_203F3E0->unk24 - 1])
+        {
+            SetGpuReg(REG_OFFSET_BG1HOFS,  (r2 * 8));
+            SetGpuReg(REG_OFFSET_BG2HOFS, -(r2 * 8));
+            return FALSE;
+        }
+        else
+        {
+            return TRUE;
+        }
+    }
+    else
+    {
+        return FALSE;
+    }
+}
 
-/*static*/ const union AnimCmd sSpriteAnim_8478D84[] =
+static void sub_8152110(void)
 {
-    ANIMCMD_FRAME(0, 20),
-    ANIMCMD_JUMP(0)
-};
+    u8 i;
+    u8 start = gUnknown_203F3E0->unk44;
+    u8 finish = gUnknown_203F3E0->unk48;
+
+    for (i = start; i < finish; i++)
+    {
+        struct DodrioSubstruct_31A0_14 * ptr = &gUnknown_203F3E0->unk32CC.unk14;
+        ptr->unkB[i] = (i % 2 == 0) ? 1 : 0;
+        ptr->unk0[i] = 0;
+    }
+}
 
-/*static*/ const union AnimCmd *const sSpriteAnimTable_8478D8C[] =
+static void sub_8152174(void)
 {
-    sSpriteAnim_8478D84
-};
+    u8 sp0 = gUnknown_203F3E0->unk44;
+    u8 sp4 = gUnknown_203F3E0->unk48;
+    u8 sp8 = gUnknown_203F3E0->unk24;
+    u8 i, j, k, r5;
 
-// These are declared inside pokeemerald's sub_80283A8
-const struct SpritePalette gUnknown_8478D90 = {sDodrioBerryPkmnPal, 0};
-const struct SpritePalette gUnknown_8478D98 = {sDodrioBerryShinyPal, 1};
-
-// These are declared inside pokeemerald's sub_8028734
-const struct SpritePalette gUnknown_8478DA0 = {sDodrioBerryStatusPal, 2};
-const struct SpriteTemplate gUnknown_8478DA8 =
-        {
-            .tileTag = 1,
-            .paletteTag = 2,
-            .oam = &sOamData_8478CA0,
-            .anims = sSpriteAnimTable_8478D0C,
-            .images = NULL,
-            .affineAnims = gDummySpriteAffineAnimTable,
-            .callback = nullsub_97,
-        };
-
-// Unknown unused data, feel free to remove.
-/*static*/ const u8 sUnused2[] = {0xCD, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0xF4, 0x0, 0x0};
-
-// This is declared inside pokeemerald's sub_8028A34
-const struct SpritePalette gUnknown_8478DCC = {sDodrioBerrySpritesPal, 3};
-
-/*static*/ const s16 sUnknown_8478DD4[] = {88, 128, 168, 208};
-
-// These are declared inside pokeemerald's sub_8028A88
-const struct SpriteTemplate gUnknown_8478DDC =
-    {
-        .tileTag = 2,
-        .paletteTag = 3,
-        .oam = &sOamData_8478CA8,
-        .anims = sSpriteAnimTable_8478D60,
-        .images = NULL,
-        .affineAnims = gDummySpriteAffineAnimTable,
-        .callback = SpriteCallbackDummy,
-    };
-const struct SpriteTemplate gUnknown_8478DF4 =
-    {
-        .tileTag = 2,
-        .paletteTag = 3,
-        .oam = &sOamData_8478CA0,
-        .anims = sSpriteAnimTable_8478D60,
-        .images = NULL,
-        .affineAnims = gDummySpriteAffineAnimTable,
-        .callback = SpriteCallbackDummy,
-    };
-
-// This is declared inside pokeemerald's sub_8028CF4
-/*static*/ const u8 gUnknown_8478E0C[] = {30, 20};
-
-/*static*/ const s16 gUnknown_8478E0E[][2] = {{230, 55}, {30, 74}};
-
-// These are declared inside pokeemerald's sub_8028D44
-const struct SpritePalette gUnknown_8478E18 = {sDodrioBerryPlatformPal, 6};
-const struct SpriteTemplate gUnknown_8478E20 =
-    {
-        .tileTag = 5,
-        .paletteTag = 6,
-        .oam = &sOamData_8478CB0,
-        .anims = sSpriteAnimTable_8478D8C,
-        .images = NULL,
-        .affineAnims = gDummySpriteAffineAnimTable,
-        .callback = sub_81543E8,
-    };
-
-struct WinCoords
-{
-    u8 left;
-    u8 top;
-};
+    if (gUnknown_203F3E0->unk40 >= 10)
+        return;
+
+    for (i = 0; i < sp8; i++)
+    {
+        u8 *ptr = &gUnknown_203F3E0->unk31A0[i].unk2C.unk0;
+        if (*ptr != 0 && gUnknown_203F3E0->unkA8[i] == 1)
+        {
+            for (j = sp0; j < sp4; j++)
+            {
+                r5 = sUnknown_8471F50[0][0][j];
+                if (gUnknown_203F3E0->unkF4[r5][0] == i || gUnknown_203F3E0->unkF4[r5][1] == i)
+                    break;
+                if (sub_8152484(i, *ptr, r5) == TRUE)
+                {
+                    for (k = 0; k < 2; k++)
+                    {
+                        if (gUnknown_203F3E0->unkF4[r5][k] == 0xFF)
+                        {
+                            gUnknown_203F3E0->unkF4[r5][k] = i;
+                            gUnknown_203F3E0->unkA8[i] = 2;
+                            gUnknown_203F3E0->unkC4[r5] = 1;
+                            break;
+                        }
+                    }
+                    break;
+                }
+                if (gUnknown_203F3E0->unk31A0[i].unk2C.unk8 == 1)
+                    break;
+            }
+        }
+    }
+
+    for (j = sp0; j < sp4; j++)
+    {
+        u8 id = 0xFF;
+        r5 = sUnknown_8471F50[0][0][j];
+        if (gUnknown_203F3E0->unkC4[r5] == 1)
+        {
+            s32 r2;
+            u8 r4, r3 = gUnknown_203F3E0->unk90[sub_8152BD4(r5)] / 7;
+            if (r3 >= NELEMS(sUnknown_847553C) - 1)
+                r3 = NELEMS(sUnknown_847553C) - 1;
+
+            r2 = sUnknown_847553C[r3][gUnknown_203F3E0->unk31A0[0].unk14.unk0[r5]] - gUnknown_203F3E0->unkD0[r5];
+            if (r2 < 6)
+                gUnknown_203F3E0->unk9C[r5] += r2;
+
+            if (++gUnknown_203F3E0->unk9C[r5] >= 6)
+            {
+                gUnknown_203F3E0->unk9C[r5] = 0;
+                if (gUnknown_203F3E0->unkF4[r5][0] == 0xFF && gUnknown_203F3E0->unkF4[r5][1] == 0xFF)
+                {
+                    continue;
+                }
+                else if (gUnknown_203F3E0->unkF4[r5][0] != 0xFF && gUnknown_203F3E0->unkF4[r5][1] == 0xFF)
+                {
+                    r4 = gUnknown_203F3E0->unkF4[r5][0];
+                }
+                else
+                {
+                    u8 unk0 = gUnknown_203F3E0->unkF4[r5][0];
+                    i = gUnknown_203F3E0->unkF4[r5][1]; // Have to re-use the variable to match.
+                    if (!(Random() & 1))
+                    {
+                        r4 = unk0;
+                        id = i;
+                    }
+                    else
+                    {
+                        r4 = i;
+                        id = unk0;
+                    }
+                }
+                gUnknown_203F3E0->unk32CC.unk14.unkB[r5] = 7;
+                gUnknown_203F3E0->unkC4[r5] = 2;
+                gUnknown_203F3E0->unkA8[r4] = 3;
+                gUnknown_203F3E0->unkB8[r5] = r4;
+                gUnknown_203F3E0->unk31A0[r4].unk2C.unk4 = 1;
+                gUnknown_203F3E0->unk31A0[id].unk2C.unk8 = 1;
+                gUnknown_203F3E0->unk86[r4]++;
+                sub_8152D34(0, r5, r4);
+                sub_8152F94(TRUE);
+                sub_8152B64(r4);
+                gUnknown_203F3E0->unkE8[r5] = gUnknown_203F3E0->unk32CC.unk14.unk0[r5];
+                gUnknown_203F3E0->unk32CC.unk14.unk0[r5] = 3;
+                gUnknown_203F3E0->unkF4[r5][0] = 0xFF;
+                gUnknown_203F3E0->unkF4[r5][1] = 0xFF;
+            }
+        }
+    }
+}
 
-/*static*/ const u8 sUnknown_8478E38[][3] =
+static bool32 sub_8152484(u8 a0, u8 a1, u8 a2)
 {
-    {1, 2, 3},
-    {1, 4, 5},
-    {1, 8, 9},
-    {1, 6, 7},
-};
+    s32 r7 = 0;
+    u8 r5 = gUnknown_203F3E0->unk24 - 1;
+    struct DodrioSubstruct_31A0_14 * ptr = &gUnknown_203F3E0->unk32CC.unk14;
+
+    switch (a1)
+    {
+    case 3:
+    default:
+        r7 = 0;
+        break;
+    case 2:
+        r7 = 1;
+        break;
+    case 1:
+        r7 = 2;
+        break;
+    }
+    if (ptr->unkB[a2] == 6 || ptr->unkB[a2] == 7)
+    {
+        if (a2 == sUnknown_8472063[r5][a0][r7])
+        {
+            if (gUnknown_203F3E0->unkC4[a2] == 1 || gUnknown_203F3E0->unkC4[a2] == 2)
+            {
+                gUnknown_203F3E0->unk31A0[a0].unk2C.unk8 = 1;
+                return FALSE;
+            }
+            else
+            {
+                return TRUE;
+            }
+        }
+    }
+    else
+    {
+        if (a2 == sUnknown_8472063[r5][a0][r7])
+        {
+            gUnknown_203F3E0->unkA8[a0] = 4;
+            gUnknown_203F3E0->unk31A0[a0].unk2C.unk8 = 1;
+        }
+    }
+    return FALSE;
+}
+
+static void sub_815256C(void)
+{
+    u8 r1 = gUnknown_203F3E0->unk44;
+    u8 r9 = gUnknown_203F3E0->unk48;
+    u8 r3 = 0;
+    u8 r10 = 0;
+    u8 i;
+    u8 r2;
+    struct DodrioStruct * ptr;
+
+    gUnknown_203F3E0->unk120 = 0;
+
+    for (i = r1; i < r9 - 1; i++)
+    {
+        ptr = gUnknown_203F3E0;
+
+        if (gUnknown_203F3E0->unkC4[i] == 0 || gUnknown_203F3E0->unkC4[i] == 1)
+        {
+            gUnknown_203F3E0->unk120 = 1;
+            if (ptr->unk32CC.unk14.unkB[i] >= 10)
+            {
+                ptr->unk32CC.unk14.unkB[i] = 10;
+                gUnknown_203F3E0->unkC4[i] = 3;
+                if (gUnknown_203F3E0->unk148[i] == 0)
+                {
+                    gUnknown_203F3E0->unk148[i] = 1;
+                    PlaySE(SE_FUUSEN1 + ptr->unk32CC.unk14.unk0[i]);
+                }
+                if (gUnknown_203F3E0->unk40 < 10 || r10 == 1)
+                {
+                    r10 = 1;
+                    gUnknown_203F3E0->unk148[i] = 0;
+                    if (gUnknown_203F3E0->unk40 < 10)
+                    {
+                        gUnknown_203F3E0->unk40++;
+                    }
+                    sub_8152D34(3, i, 0);
+                    sub_8152F94(FALSE);
+                }
+            }
+            else
+            {
+                r3 = gUnknown_203F3E0->unk90[sub_8152BD4(i)] / 7;
+                if (r3 >= NELEMS(sUnknown_847553C) - 1)
+                {
+                    r3 = NELEMS(sUnknown_847553C) - 1;
+                }
+                r2 = sUnknown_847553C[r3][ptr->unk32CC.unk14.unk0[i]];
+                if (++gUnknown_203F3E0->unkD0[i] >= r2)
+                {
+                    ptr->unk32CC.unk14.unkB[i]++;
+                    gUnknown_203F3E0->unkD0[i] = 0;
+                }
+                sub_8152174();
+            }
+        }
+        else if (gUnknown_203F3E0->unkC4[i] == 2)
+        {
+            // gUnknown_203F3E0->unk120 = 1;
+            if (++gUnknown_203F3E0->unkDC[i] >= 20)
+            {
+                gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->unkB8[i]].unk2C.unk4 = 0;
+                gUnknown_203F3E0->unkDC[i] = 0;
+                gUnknown_203F3E0->unkD0[i] = 0;
+                gUnknown_203F3E0->unkC4[i] = 0;
+                ptr->unk32CC.unk14.unkB[i] = 1;
+                ptr->unk32CC.unk14.unk0[i] = sub_8152BF8(sub_8152BD4(i), i);
+            }
+        }
+        else if (gUnknown_203F3E0->unkC4[i] == 3)
+        {
+            if (++gUnknown_203F3E0->unkDC[i] >= 20)
+            {
+                if (gUnknown_203F3E0->unk40 < 10)
+                {
+                    gUnknown_203F3E0->unkDC[i] = 0;
+                    gUnknown_203F3E0->unkD0[i] = 0;
+                    gUnknown_203F3E0->unkC4[i] = 0;
+                    ptr->unk32CC.unk14.unkB[i] = 1;
+                    gUnknown_203F3E0->unkE8[i] = ptr->unk32CC.unk14.unk0[i];
+                    ptr->unk32CC.unk14.unk0[i] = sub_8152BF8(sub_8152BD4(i), i);
+                }
+            }
+        }
+    }
+}
+
+static void sub_81527D0(void)
+{
+    u8 i, first, count;
+
+    first = gUnknown_203F3E0->unk44;
+    count = gUnknown_203F3E0->unk48;
+    for (i = first; i < count; i++)
+    {
+        struct DodrioSubstruct_31A0 * ptr = &gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId];
+        u8 var = sUnknown_8471F50[gUnknown_203F3E0->unk24 - 1][gUnknown_203F3E0->multiplayerId][i];
+
+        if (ptr->unk14.unkB[var] != 0)
+            sub_81542EC(i, FALSE);
+        else
+            sub_81542EC(i, TRUE);
+
+        if (ptr->unk14.unkB[var] > 9)
+        {
+            sub_8154398(i, ptr->unk14.unk0[var] + 3);
+            sub_8154370(i, ptr->unk14.unkB[var] * 2 - 1);
+        }
+        else if (ptr->unk14.unk0[var] == 3)
+        {
+            ptr->unk14.unkB[var] = 7;
+            sub_8154398(i, 6);
+            sub_8154370(i, ptr->unk14.unkB[var] * 2 - 1);
+        }
+        else
+        {
+            sub_8154398(i, ptr->unk14.unk0[var]);
+            sub_8154370(i, ptr->unk14.unkB[var] * 2);
+        }
+    }
+}
+
+static void sub_81528D0(void)
+{
+    u8 i, count;
+
+    count = gUnknown_203F3E0->unk24;
+    for (i = 0; i < count; i++)
+    {
+        struct DodrioSubstruct_31A0 * ptr = &gUnknown_203F3E0->unk31A0[i];
+        sub_8153DA8(i, ptr->unk2C.unk0);
+    }
+}
+
+static void sub_8152910(void)
+{
+    u8 i, count;
+
+    count = gUnknown_203F3E0->unk24;
+    for (i = 0; i < count; i++)
+        sub_8153DA8(i, 4);
+}
+
+static void sub_815293C(void)
+{
+    sub_81527D0();
+    if (gUnknown_203F3E0->unk40 > 9)
+        sub_8152910();
+    else
+        sub_81528D0();
+
+    sub_8153FC8(gUnknown_203F3E0->unk40);
+}
+
+// This function is literally the same as the one above...Why?
+static void sub_8152970(void)
+{
+    sub_81527D0();
+    if (gUnknown_203F3E0->unk40 > 9)
+        sub_8152910();
+    else
+        sub_81528D0();
+
+    sub_8153FC8(gUnknown_203F3E0->unk40);
+}
+
+static void sub_81529A4(u8 arg0, u8 *arg1, u8 *arg2)
+{
+    switch (arg0)
+    {
+    case 1:
+        *arg1 = 4, *arg2 = 7;
+        break;
+    case 2:
+        *arg1 = 3, *arg2 = 8;
+        break;
+    case 3:
+        *arg1 = 2, *arg2 = 9;
+        break;
+    case 4:
+        *arg1 = 1, *arg2 = 10;
+        break;
+    case 5:
+        *arg1 = 0, *arg2 = 11;
+        break;
+    }
+}
+
+static bool32 sub_8152A00(void)
+{
+    u8 i, count;
+
+    count = gUnknown_203F3E0->unk24;
+    for (i = 1; i < count; i++)
+    {
+        if (gUnknown_203F3E0->unk158[i] == 0)
+            gUnknown_203F3E0->unk158[i] = sub_815A5E8(i);
+    }
+
+    // This loop won't ever run, the seemingly pointless assingment below is to make the compiler
+    // generate code for it.
+    count = count;
+    for (; i < count; i++)
+    {
+        if (gUnknown_203F3E0->unk158[i] == 0)
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void sub_8152A70(void)
+{
+    u8 i;
+
+    for (i = 0; i < 5; i++)
+        gUnknown_203F3E0->unk158[i] = 0;
+}
+
+static bool32 sub_8152A98(void)
+{
+    if (gUnknown_203F3E0->unk40 > 9 && gUnknown_203F3E0->unk120 == 0)
+    {
+        gUnknown_203F3E0->unk40 = 10;
+        if (gUnknown_203F3E0->unk12C != 0)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static bool32 sub_8152AD8(void)
+{
+    u8 i, first, count;
+
+    if (gUnknown_203F3E0->unk40 > 9)
+    {
+        first = gUnknown_203F3E0->unk44;
+        count = gUnknown_203F3E0->unk48;
+        gUnknown_203F3E0->unk40 = 10;
+        if (gUnknown_203F3E0->unk12C != 0)
+        {
+            for (i = first; i < count; i++)
+            {
+                struct DodrioSubstruct_31A0 * ptr = &gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId];
+                u8 var = sUnknown_8471F50[gUnknown_203F3E0->unk24 - 1][gUnknown_203F3E0->multiplayerId][i];
+
+                if (ptr->unk14.unkB[var] != 10)
+                    return FALSE;
+            }
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static void sub_8152B64(u8 arg0)
+{
+    u8 var = sUnknown_8475550[gUnknown_203F3E0->unk90[arg0] % 7] + (gUnknown_203F3E0->unk90[arg0] / 7) * 100;
+    if (gUnknown_203F3E0->unk86[arg0] >= var)
+        gUnknown_203F3E0->unk90[arg0]++;
+}
+
+static u8 sub_8152BD4(u8 arg0)
+{
+    return sUnknown_84720FC[gUnknown_203F3E0->unk24 - 1][arg0];
+}
+
+static u8 sub_8152BF8(u8 arg0, u8 arg1)
+{
+    u8 i, var3;
+    u8 count = gUnknown_203F3E0->unk24 - 1;
+    u8 var0 = sUnknown_84720AE[count][arg0][0];
+    u8 var1 = sUnknown_84720AE[count][arg0][1];
+    u8 var2 = sUnknown_84720AE[count][arg0][2];
+
+    for (i = 0; sUnknown_8472133[count][i] != 0; i++)
+    {
+        if (arg1 == sUnknown_8472133[count][i])
+            return sub_8152CB8(gUnknown_203F3E0->unk90[var1], arg1);
+    }
+
+    // Gets the highest of the three.
+    if (gUnknown_203F3E0->unk90[var0] > gUnknown_203F3E0->unk90[var1])
+        var3 = gUnknown_203F3E0->unk90[var0];
+    else
+        var3 = gUnknown_203F3E0->unk90[var1];
+
+    if (gUnknown_203F3E0->unk90[var2] > var3)
+        var3 = gUnknown_203F3E0->unk90[var2];
+
+    return sub_8152CB8(var3, arg1);
+}
+
+static u8 sub_8152CB8(u8 arg0, u8 arg1)
+{
+    u8 var = gUnknown_203F3E0->unkE8[arg1];
+    switch (arg0 % 7)
+    {
+    default: return 0;
+    case 0:  return 0;
+    case 1:  return 1;
+    case 2:  return 2;
+    case 3:
+        if (var == 0)
+            return 1;
+        else
+            return 0;
+    case 4:
+        if (var == 0)
+            return 2;
+        else
+            return 0;
+    case 5:
+        if (var == 2)
+            return 1;
+        else
+            return 2;
+    case 6:
+        if (var == 0)
+            return 1;
+        else if (var == 1)
+            return 2;
+        else
+            return 0;
+    }
+}
+
+static void sub_8152D34(u8 arg0, u8 arg1, u8 arg2)
+{
+    u8 var;
+    u8 count = gUnknown_203F3E0->unk24;
+    switch (arg0)
+    {
+    case 0:
+    case 1:
+    case 2:
+        var = gUnknown_203F3E0->unk31A0[0].unk14.unk0[arg1];
+        gUnknown_203F3E0->unk4A[arg2][var] = IncrementWithLimit(gUnknown_203F3E0->unk4A[arg2][var], 20000);
+        break;
+    case 3:
+        switch (count)
+        {
+        case 5:
+            switch (arg1)
+            {
+            case 0:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                gUnknown_203F3E0->unk4A[3][3]++;
+                break;
+            case 1:
+                gUnknown_203F3E0->unk4A[3][3]++;
+                break;
+            case 2:
+                gUnknown_203F3E0->unk4A[3][3]++;
+                gUnknown_203F3E0->unk4A[4][3]++;
+                break;
+            case 3:
+                gUnknown_203F3E0->unk4A[4][3]++;
+                break;
+            case 4:
+                gUnknown_203F3E0->unk4A[4][3]++;
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 5:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 6:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 7:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 8:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            case 9:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            }
+            break;
+        case 4:
+            switch (arg1)
+            {
+            case 1:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                gUnknown_203F3E0->unk4A[3][3]++;
+                break;
+            case 2:
+                gUnknown_203F3E0->unk4A[3][3]++;
+                break;
+            case 3:
+                gUnknown_203F3E0->unk4A[3][3]++;
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 4:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 5:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 6:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 7:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            case 8:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            }
+            break;
+        case 3:
+            switch (arg1)
+            {
+            case 2:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            case 3:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                break;
+            case 4:
+                gUnknown_203F3E0->unk4A[2][3]++;
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 5:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 6:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 7:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            }
+            break;
+        case 2:
+            switch (arg1)
+            {
+            case 3:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 4:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                break;
+            case 5:
+                gUnknown_203F3E0->unk4A[0][3]++;
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            case 6:
+                gUnknown_203F3E0->unk4A[1][3]++;
+                break;
+            }
+            break;
+        }
+        break;
+    }
+}
+
+static void sub_8152F94(bool32 arg0)
+{
+    if (gUnknown_203F3E0->unk24 != 5)
+        return;
+
+    if (arg0 == TRUE)
+    {
+        if (++gUnknown_203F3E0->unk112 > gUnknown_203F3E0->unk114)
+            gUnknown_203F3E0->unk114 = gUnknown_203F3E0->unk112;
+        if (gUnknown_203F3E0->unk112 > 9999)
+            gUnknown_203F3E0->unk112 = 9999;
+    }
+    else
+    {
+        if (gUnknown_203F3E0->unk112 > gUnknown_203F3E0->unk114)
+            gUnknown_203F3E0->unk114 = gUnknown_203F3E0->unk112;
+        gUnknown_203F3E0->unk112 = 0;
+    }
+}
+
+static void sub_8153004(void)
+{
+    u8 i;
+    for (i = 0; i < gUnknown_203F3E0->unk24; i++)
+        gUnknown_203F3E0->unk4A[i][5] = gUnknown_203F3E0->unk114;
+}
+
+static void sub_8153048(void)
+{
+    u8 i, j;
 
-/*static*/ const struct WinCoords sUnknown_8478E44[] = {{12, 6}};
-/*static*/ const struct WinCoords sUnknown_8478E48[] = {{9, 10}, {15, 6}};
-/*static*/ const struct WinCoords sUnknown_8478E50[] = {{12, 6}, {18, 10}, {6, 10}};
-/*static*/ const struct WinCoords sUnknown_8478E5C[] = {{9, 10}, {15, 6}, {21, 10}, {3, 6}};
-/*static*/ const struct WinCoords sUnknown_8478E6C[] = {{12, 6}, {18, 10}, {23, 6}, {1, 6}, {6, 10}};
+    for (i = 0; i < 5; i++)
+    {
+        for (j = 0; j < 11; j++)
+            gUnknown_203F3E0->unk31A0[i].unk14.unkB[j] = 0;
+        gUnknown_203F3E0->unk31A0[i].unk2C.unk0 = 0;
+        gUnknown_203F3E0->unk31A0[i].unk2C.unk4 = 0;
+        gUnknown_203F3E0->unk90[i] = 0;
+        gUnknown_203F3E0->unk86[i] = 0;
+        gUnknown_203F3E0->unk3308[i].unk0 = 0;
+        gUnknown_203F3E0->unk3308[i].unk4 = 0;
+        gUnknown_203F3E0->unk4A[i][0] = 0;
+        gUnknown_203F3E0->unk4A[i][1] = 0;
+        gUnknown_203F3E0->unk4A[i][2] = 0;
+        gUnknown_203F3E0->unk4A[i][3] = 0;
+        gUnknown_203F3E0->unk4A[i][4] = 0;
+        gUnknown_203F3E0->unk4A[i][5] = 0;
+    }
+    gUnknown_203F3E0->unk154 = 0;
+    gUnknown_203F3E0->unk112 = 0;
+    gUnknown_203F3E0->unk40 = 0;
+    sub_81528D0();
+    sub_81527D0();
+}
+
+static const s16 sUnknown_84755D8[] = {10, 30, 50, 50};
+
+static void sub_8153150(void)
+{
+    u8 i, var = 0, var2 = 0;
+
+    switch (gUnknown_203F3E0->unk24)
+    {
+    case 4:  var = 1; break;
+    case 5:  var = 2; break;
+    }
+
+    var2 = Random() % 10;
+    for (i = 0; i < 5; i++)
+        gUnknown_203F3E0->unk4A[i][4] = sUnknown_8475558[var][var2];
+}
+
+static u32 sub_81531BC(u8 arg0)
+{
+    u32 sum = gUnknown_203F3E0->unk4A[arg0][0]
+              + gUnknown_203F3E0->unk4A[arg0][1]
+              + gUnknown_203F3E0->unk4A[arg0][2];
+    return min(sum, 9999);
+}
+
+static void sub_81531FC(void)
+{
+    u32 berriesPicked = Min(sub_81531BC(gUnknown_203F3E0->multiplayerId), 9999);
+    u32 score = Min(sub_8153424(gUnknown_203F3E0->multiplayerId), 999990);
+
+    if (gSaveBlock2Ptr->berryPick.bestScore < score)
+        gSaveBlock2Ptr->berryPick.bestScore = score;
+    if (gSaveBlock2Ptr->berryPick.berriesPicked < berriesPicked)
+        gSaveBlock2Ptr->berryPick.berriesPicked = berriesPicked;
+    if (gSaveBlock2Ptr->berryPick.berriesPickedInRow < gUnknown_203F3E0->unk114)
+        gSaveBlock2Ptr->berryPick.berriesPickedInRow = gUnknown_203F3E0->unk114;
+}
+
+static u8 sub_815327C(u8 arg0)
+{
+    u8 i, saved;
+
+    saved = gUnknown_203F3E0->unk98[3];
+    for (i = 3; i != 0; i--)
+        gUnknown_203F3E0->unk98[i] = gUnknown_203F3E0->unk98[i - 1];
+    gUnknown_203F3E0->unk98[0] = arg0;
+    return saved;
+}
+
+static void sub_81532B8(void)
+{
+    if (gUnknown_203F3E0->unkB0[gUnknown_203F3E0->multiplayerId] == 0)
+    {
+        if (JOY_NEW(DPAD_UP))
+        {
+            gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 = 2;
+            gUnknown_203F3E0->unkB0[gUnknown_203F3E0->multiplayerId] = 6;
+            PlaySE(SE_W204);
+        }
+        else if (JOY_NEW(DPAD_LEFT))
+        {
+            gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 = 3;
+            gUnknown_203F3E0->unkB0[gUnknown_203F3E0->multiplayerId] = 6;
+            PlaySE(SE_W204);
+        }
+        else if (JOY_NEW(DPAD_RIGHT))
+        {
+            gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 = 1;
+            gUnknown_203F3E0->unkB0[gUnknown_203F3E0->multiplayerId] = 6;
+            PlaySE(SE_W204);
+        }
+        else
+        {
+            gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 = 0;
+        }
+    }
+    else
+    {
+        gUnknown_203F3E0->unkB0[gUnknown_203F3E0->multiplayerId]--;
+    }
+}
+
+static void sub_815336C(void)
+{
+    gUnknown_203F3E0->unk31A0[gUnknown_203F3E0->multiplayerId].unk2C.unk0 = 0;
+}
+
+u16 sub_8153390(void)
+{
+    return gUnknown_203F3E0->unk4A[gUnknown_203F3E0->multiplayerId][4] + FIRST_BERRY_INDEX;
+}
+
+u8 sub_81533B4(void)
+{
+    return gUnknown_203F3E0->unk24;
+}
+
+u8 *sub_81533C4(u8 id)
+{
+    if (gReceivedRemoteLinkPlayers)
+        return gLinkPlayers[id].name;
+    else
+        return gUnknown_203F3E0->unk31A0[id].name;
+}
 
-/*static*/ const struct WinCoords *const sUnknown_8478E80[] =
+u16 sub_8153404(u8 arg0, u8 arg1)
+{
+    return gUnknown_203F3E0->unk4A[arg0][arg1];
+}
+
+static u32 sub_8153424(u8 arg0)
+{
+    u8 i;
+    u32 var, sum = 0;
+
+    for (i = 0; i < 3; i++)
+        sum += gUnknown_203F3E0->unk4A[arg0][i] * sUnknown_84755D8[i];
+
+    var = gUnknown_203F3E0->unk4A[arg0][3] * sUnknown_84755D8[3];
+    if (sum <= var)
+        return 0;
+    else
+        return sum - var;
+}
+
+u32 sub_81534AC(void)
+{
+    u8 i, count = gUnknown_203F3E0->unk24;
+    u32 maxVar = sub_8153424(0);
+
+    for (i = 1; i < count; i++)
+    {
+        u32 var = sub_8153424(i);
+        if (var > maxVar)
+            maxVar = var;
+    }
+    return Min(maxVar, 999990);
+}
+
+u32 sub_81534F0(u8 arg0)
+{
+    u8 i, count = gUnknown_203F3E0->unk24;
+    u16 maxVar = gUnknown_203F3E0->unk4A[0][arg0];
+
+    for (i = 0; i < count; i++)
+    {
+        u16 var = gUnknown_203F3E0->unk4A[i][arg0];
+        if (var > maxVar)
+            maxVar = var;
+    }
+    return maxVar;
+}
+
+static u32 sub_8153534(u8 arg0)
+{
+    u32 vals[5], temp;
+    s16 r6 = TRUE;
+    u8 i, count = gUnknown_203F3E0->unk24;
+
+    for (i = 0; i < count; i++)
+        vals[i] = temp = sub_8153424(i);
+
+    while (r6)
+    {
+        r6 = FALSE;
+        for (i = 0; i < count - 1; i++)
+        {
+            if (vals[i] < vals[i + 1])
+            {
+                SWAP(vals[i], vals[i + 1], temp);
+                r6 = TRUE;
+            }
+        }
+    }
+
+    return vals[arg0];
+}
+
+u32 sub_81535B0(void)
+{
+    u8 i, r10 = 0, r8 = 0, r9 = 0, count = gUnknown_203F3E0->unk24;
+
+    // Function called two times for some reason.
+    sub_81534AC();
+    if (sub_81534AC() == 0)
+    {
+        for (i = 0; i < count; i++)
+        {
+            gUnknown_203F3E0->unk3308[i].unk0 = 4;
+            gUnknown_203F3E0->unk3308[i].unk4 = 0;
+        }
+    }
+
+    for (i = 0; i < count; i++)
+        gUnknown_203F3E0->unk3308[i].unk4 = Min(sub_8153424(i), 999990);
+
+    do
+    {
+        u32 r6 = sub_8153534(r10);
+        u8 r3 = r8;
+        for (i = 0; i < count; i++)
+        {
+            if (r6 == gUnknown_203F3E0->unk3308[i].unk4)
+            {
+                gUnknown_203F3E0->unk3308[i].unk0 = r3;
+                r8++;
+                r9++;
+            }
+        }
+        r10 = r8;
+    } while (r9 < count);
+
+    return 0;
+}
+
+void sub_81536A0(struct DodrioSubstruct_3308 * dst, u8 id)
 {
-    sUnknown_8478E44,
-    sUnknown_8478E48,
-    sUnknown_8478E50,
-    sUnknown_8478E5C,
-    sUnknown_8478E6C,
+    *dst = gUnknown_203F3E0->unk3308[id];
+}
+
+static u8 sub_81536C0(u8 arg0)
+{
+    u8 i, ret = 0, count = gUnknown_203F3E0->unk24;
+    u32 var, vars[5] = {0};
+
+    for (i = 0; i < count; i++)
+        vars[i] = sub_8153424(i);
+
+    var = vars[arg0];
+    for (i = 0; i < 5; i++)
+    {
+        if (i != arg0 && var < vars[i])
+            ret++;
+    }
+
+    return ret;
+}
+
+u8 sub_815372C(void)
+{
+    u8 multiplayerId = gUnknown_203F3E0->multiplayerId;
+    u16 itemId = sub_8153390();
+
+    if (sub_8153424(multiplayerId) != sub_81534AC())
+        return 3;
+    if (!CheckBagHasSpace(itemId, 1))
+        return 2;
+
+    AddBagItem(itemId, 1);
+    if (!CheckBagHasSpace(itemId, 1))
+        return 1;
+    return 0;
+}
+
+// Really? What next, u32 Add(u32 a)return a+1;?
+u32 IncrementWithLimit(u32 a, u32 max)
+{
+    if (a < max)
+        return a + 1;
+    else
+        return max;
+}
+
+// Gamefreak pls, min(a, b) ((a) < (b) ? (a) : (b)) is a well-known macro
+u32 Min(u32 a, u32 b)
+{
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+u8 sub_81537AC(u8 id)
+{
+    return gUnknown_203F3E0->unk34[id];
+}
+
+void IsDodrioInParty(void)
+{
+    int i;
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_HAS_SPECIES)
+            && GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2) == SPECIES_DODRIO)
+        {
+            gSpecialVar_Result = TRUE;
+            return;
+        }
+    }
+
+    gSpecialVar_Result = FALSE;
+}
+
+void ShowDodrioBerryPickingRecords(void)
+{
+    u8 taskId = CreateTask(Task_ShowDodrioBerryPickingRecords, 0);
+    Task_ShowDodrioBerryPickingRecords(taskId);
+}
+
+// Data related to printing saved results.
+static const struct WindowTemplate sUnknown_84755E0 =
+{
+    .bg = 0,
+    .tilemapLeft = 1,
+    .tilemapTop = 1,
+    .width = 28,
+    .height = 11,
+    .paletteNum = 15,
+    .baseBlock = 1,
 };
 
-/*static*/ const u8 *const sUnknown_8478E94[] =
+static const u8 *const sUnknown_84755E8[] = {gText_BerryPickingRecords, gText_BerriesPicked, gText_BestScore, gText_BerriesInRowFivePlayers};
+static const u8 sUnknown_84755F8[] = {4, 7, 4};
+
+ALIGNED(4)
+static const u8 sUnknown_84755FC[][2] = {{24}, {40}, {56}};
+static const u8 sUnknown_8475602[][2] = {{24}, {40}, {70}};
+
+static void Task_ShowDodrioBerryPickingRecords(u8 taskId)
+{
+    struct WindowTemplate window;
+    s32 i, width, widthCurr;
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        data[1] = AddWindow(&sUnknown_84755E0);
+        sub_81538D0(data[1]);
+        CopyWindowToVram(data[1], 3);
+        data[0]++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            data[0]++;
+        break;
+    case 2:
+        if (JOY_NEW(A_BUTTON | B_BUTTON))
+        {
+            rbox_fill_rectangle(data[1]);
+            CopyWindowToVram(data[1], 1);
+            data[0]++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            RemoveWindow(data[1]);
+            DestroyTask(taskId);
+            EnableBothScriptContexts();
+        }
+        break;
+    }
+}
+
+static void sub_81538D0(u8 windowId)
 {
-    gText_1Colon,
-    gText_2Colon,
-    gText_3Colon,
-    gText_4Colon,
-    gText_5Colon,
+    s32 i, x, numWidth;
+    s32 results[3];
+    u8 strbuf[20];
+    results[0] = gSaveBlock2Ptr->berryPick.berriesPicked;
+    results[1] = gSaveBlock2Ptr->berryPick.bestScore;
+    results[2] = gSaveBlock2Ptr->berryPick.berriesPickedInRow;
+
+    TextWindow_SetStdFrame0_WithPal(windowId, 0x21D, 0xD0);
+    DrawTextBorderOuter(windowId, 0x21D, 0xD);
+    FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
+    AddTextPrinterParameterized(windowId, 2, sUnknown_84755E8[0], 1, 1, TEXT_SPEED_FF, NULL);
+    for (i = 0; i < 3; i++)
+    {
+        ConvertIntToDecimalStringN(strbuf, results[i], STR_CONV_MODE_LEFT_ALIGN, sUnknown_84755F8[i]);
+        numWidth = GetStringWidth(2, strbuf, -1);
+        AddTextPrinterParameterized(windowId, 2, sUnknown_84755E8[i + 1], 1, sUnknown_84755FC[i][0], TEXT_SPEED_FF, NULL);
+        x = 224 - numWidth;
+        AddTextPrinterParameterized(windowId, 2, strbuf, x, sUnknown_8475602[i][0], TEXT_SPEED_FF, NULL);
+    }
+    PutWindowTilemap(windowId);
+}
+
+// Debug functions?
+static const u16 sUnknown_8475608[][4] =
+{
+    {9999, 0, 90, 9999},
+    {9999, 9999, 70, 9999},
+    {9999, 0, 9999, 0},
+    {9999, 9999, 60, 0},
+    {9999, 9999, 9999, 0},
 };
 
-/*static*/ const u16 sUnknown_8478EA8[] = {92, 132, 172, 212};
-/*static*/ const u16 sUnknown_8478EB0[] = {30, 45, 60, 75, 90};
-/*static*/ const u16 sUnknown_8478EBA[] = {12, 28, 44, 60, 76};
-
-struct
-{
-    u8 id;
-    void (*func)(void);
-} const gUnknown_8478EC4[] =
-{
-    {0, sub_8154A2C},
-    {1, sub_8154B34},
-    {2, sub_8154F80},
-    {3, sub_81556E0},
-    {4, sub_8155A78},
-    {5, sub_8155B4C},
-    {6, sub_8155C2C},
-    {7, sub_8155C80},
-    {8, unused_0},
-    {9, nullsub_98},
+static const u8 sUnknown_8475630[] = _("あいうえおかき");
+static const u8 sUnknown_8475638[] = _("ABCDEFG");
+static const u8 sUnknown_8475640[] = _("0123456");
+
+static const u8 *const sPlaceholderPlayerNames[] =
+{
+    sUnknown_8475630,
+    sUnknown_8475630,
+    sUnknown_8475630,
+    sUnknown_8475638,
+    sUnknown_8475640
 };
 
-// This is declared inside pokeemerald's sub_80296A8
-const u8 gUnknown_8478F14[5] = {0, 1, 2, 3, 4};
+static void sub_81539EC(void)
+{
+    gUnknown_203F3E0->unk24 = GetLinkPlayerCount();
+}
+
+static void sub_8153A04(void)
+{
+    u8 i, playerId;
+
+    for (playerId = gUnknown_203F3E0->unk24; playerId < NELEMS(sPlaceholderPlayerNames); playerId++)
+        StringCopy(gLinkPlayers[playerId].name, sPlaceholderPlayerNames[playerId]);
+
+    gUnknown_203F3E0->unk24 = 5;
+    for (i = 0; i < 4; i++)
+    {
+        for (playerId = 0; playerId < gUnknown_203F3E0->unk24; playerId++)
+            gUnknown_203F3E0->unk4A[playerId][i] = sUnknown_8475608[playerId][i];
+    }
+}
diff --git a/src/dodrio_berry_picking_2.c b/src/dodrio_berry_picking_2.c
index fc6aa14c6..e170ac903 100644
--- a/src/dodrio_berry_picking_2.c
+++ b/src/dodrio_berry_picking_2.c
@@ -1,23 +1,1617 @@
 #include "global.h"
+#include "gflib.h"
+#include "dodrio_berry_picking.h"
+#include "dynamic_placeholder_text_util.h"
+#include "item.h"
 #include "link.h"
-#include "link_rfu.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "save.h"
+#include "strings.h"
+#include "task.h"
+#include "text_window.h"
+#include "text_window_graphics.h"
+#include "constants/songs.h"
 
-void sub_815A5BC(s32 a0)
+struct DodrioStruct_2022CF4
 {
-    struct Padded_U8 data[2];
-    data[0].value = 1;
-    data[1].value = a0;
-    sub_80F9E2C(data);
+    u8 filler_00[0xc];
+    u8 unkC[10];
+    s16 unk16[10];
+    u16 unk2A[10];
+    u16 unk3E;
+}; // size = 0x40
+
+static EWRAM_DATA u16 *gUnknown_203F3E4[5] = {NULL};
+static EWRAM_DATA u16 *gUnknown_203F3F8[2] = {NULL};
+static EWRAM_DATA u16 *gUnknown_203F400[11] = {NULL};
+static EWRAM_DATA u16 *gUnknown_203F42C[4] = {NULL};
+static EWRAM_DATA struct DodrioStruct_2022CF4 * gUnknown_203F43C = NULL;
+static EWRAM_DATA struct DodrioSubstruct_0160 * gUnknown_203F440 = NULL;
+
+static void sub_8153B9C(struct Sprite * sprite);
+static u32 sub_8153C30(struct Sprite * sprite);
+static u32 sub_8153CA0(struct Sprite * sprite);
+static void sub_8153D48(bool8 a0, u8 a1);
+static void nullsub_97(struct Sprite * sprite);
+static void sub_8154324(bool8 a0);
+static void sub_81543E8(struct Sprite * sprite);
+static s16 sub_8154608(u8 a0, u8 a1);
+static void sub_8154A08(u8 taskId);
+static void sub_8154A2C(void);
+static void sub_8154B34(void);
+static void sub_8154F80(void);
+static void sub_81556E0(void);
+static void sub_8155A78(void);
+static void sub_8155B4C(void);
+static void sub_8155C2C(void);
+static void sub_8155C80(void);
+static void unused_0(void);
+static void nullsub_98(void);
+static void sub_8155E24(MainCallback cb);
+MainCallback sub_8155E54(void);
+static void sub_8155EA0(void);
+static bool32 sub_8155FE0(void);
+
+// Assets in this header are duplicated
+#include "data/dodrio_berry_picking.h"
+
+static const struct OamData sOamData_8478C98 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_8478CA0 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_8478CA8 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_8478CB0 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x32),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x32),
+    .tileNum = 0,
+    .priority = 3,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const union AnimCmd sSpriteAnim_8478CB8[] =
+{
+    ANIMCMD_FRAME(0, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478CC0[] =
+{
+    ANIMCMD_FRAME(64, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478CC8[] =
+{
+    ANIMCMD_FRAME(128, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478CD0[] =
+{
+    ANIMCMD_FRAME(192, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478CD8[] =
+{
+    ANIMCMD_FRAME(256, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sSpriteAnimTable_8478CE0[] =
+{
+    sSpriteAnim_8478CB8,
+    sSpriteAnim_8478CC0,
+    sSpriteAnim_8478CC8,
+    sSpriteAnim_8478CD0,
+    sSpriteAnim_8478CD8
+};
+
+static const union AnimCmd sSpriteAnim_8478CF4[] =
+{
+    ANIMCMD_FRAME(0, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478CFC[] =
+{
+    ANIMCMD_FRAME(4, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D04[] =
+{
+    ANIMCMD_FRAME(8, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sSpriteAnimTable_8478D0C[] =
+{
+    sSpriteAnim_8478CF4,
+    sSpriteAnim_8478CFC,
+    sSpriteAnim_8478D04
+};
+
+static const union AnimCmd sSpriteAnim_8478D18[] =
+{
+    ANIMCMD_FRAME(0, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D20[] =
+{
+    ANIMCMD_FRAME(4, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D28[] =
+{
+    ANIMCMD_FRAME(8, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D30[] =
+{
+    ANIMCMD_FRAME(12, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D38[] =
+{
+    ANIMCMD_FRAME(16, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D40[] =
+{
+    ANIMCMD_FRAME(20, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D48[] =
+{
+    ANIMCMD_FRAME(24, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D50[] =
+{
+    ANIMCMD_FRAME(28, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sSpriteAnim_8478D58[] =
+{
+    ANIMCMD_FRAME(32, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sSpriteAnimTable_8478D60[] =
+{
+    sSpriteAnim_8478D18,
+    sSpriteAnim_8478D20,
+    sSpriteAnim_8478D28,
+    sSpriteAnim_8478D30,
+    sSpriteAnim_8478D38,
+    sSpriteAnim_8478D40,
+    sSpriteAnim_8478D48,
+    sSpriteAnim_8478D50,
+    sSpriteAnim_8478D58
+};
+
+static const union AnimCmd sSpriteAnim_8478D84[] =
+{
+    ANIMCMD_FRAME(0, 20),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sSpriteAnimTable_8478D8C[] =
+{
+    sSpriteAnim_8478D84
+};
+
+// Code
+
+void sub_8153A9C(void)
+{
+    void *ptr = AllocZeroed(0x3000);
+    struct SpritePalette pal1 = {sDodrioBerryPkmnPal, 0};
+    struct SpritePalette pal2 = {sDodrioBerryShinyPal, 1};
+
+    LZ77UnCompWram(sDodrioBerryPkmnGfx, ptr);
+    // This check should be one line up.
+    if (ptr != NULL)
+    {
+        struct SpriteSheet sheet = {ptr, 0x3000, 0};
+        LoadSpriteSheet(&sheet);
+        Free(ptr);
+    }
+    LoadSpritePalette(&pal1);
+    LoadSpritePalette(&pal2);
+}
+
+void sub_8153AFC(struct DodrioSubstruct_318C * arg0, u8 arg1, u8 id, u8 arg3)
+{
+    struct SpriteTemplate sprTemplate =
+    {
+        .tileTag = 0,
+        .paletteTag = arg0->isShiny,
+        .oam = &sOamData_8478C98,
+        .anims = sSpriteAnimTable_8478CE0,
+        .images = NULL,
+        .affineAnims = gDummySpriteAffineAnimTable,
+        .callback = sub_8153B9C,
+    };
+
+    gUnknown_203F3E4[id] = AllocZeroed(4);
+    *gUnknown_203F3E4[id] = CreateSprite(&sprTemplate, sub_8154608(arg1, arg3), 136, 3);
+    sub_8153D48(TRUE, id);
+}
+
+static void sub_8153B9C(struct Sprite * sprite)
+{
+    switch (sprite->data[0])
+    {
+    case 0:
+        break;
+    case 1:
+        sub_8153C30(sprite);
+        break;
+    case 2:
+        sub_8153CA0(sprite);
+        break;
+    }
+}
+
+void sub_8153BC0(u8 unused)
+{
+    struct Sprite * sprite = &gSprites[*gUnknown_203F3E4[GetMultiplayerId()]];
+    sprite->data[0] = 1;
+    sprite->data[1] = 0;
+    sprite->data[2] = 0;
+    sprite->data[3] = 0;
+    sprite->data[4] = 0;
+}
+
+void sub_8153BF8(u8 unused)
+{
+    struct Sprite * sprite = &gSprites[*gUnknown_203F3E4[GetMultiplayerId()]];
+    sprite->data[0] = 2;
+    sprite->data[1] = 0;
+    sprite->data[2] = 0;
+    sprite->data[3] = 0;
+    sprite->data[4] = 0;
 }
 
-u8 sub_815A5E8(s32 a0)
+static u32 sub_8153C30(struct Sprite * sprite)
 {
-    u8 * r1;
-    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
-        return 0;
-    r1 = (u8 *)&gRecvCmds[a0][1];
-    if (r1[0] == 1)
-        return r1[4];
+    s8 var;
+    u8 mod = (++sprite->data[1] / 2) % 4;
+
+    if (sprite->data[1] >= 3)
+    {
+        switch (mod)
+        {
+        default:
+            var = 1;
+            break;
+        case 1:
+        case 2:
+            var = -1;
+            break;
+        }
+
+        sprite->pos1.x += var;
+        if (++sprite->data[1] >= 40)
+        {
+            sprite->data[0] = 0;
+            sprite->pos1.x = sub_8154608(0, sub_81533B4());
+        }
+    }
+
     return 0;
 }
 
+static u32 sub_8153CA0(struct Sprite * sprite)
+{
+    u8 mod = (++sprite->data[1] / 13) % 4;
+
+    if (sprite->data[1] % 13 == 0 && mod != 0)
+        PlaySE(SE_W204);
+    if (sprite->data[1] >= 104)
+    {
+        sprite->data[0] = 0;
+        mod = 0;
+    }
+    sub_8153DA8(GetMultiplayerId(), mod);
+    return 0;
+}
+
+void sub_8153D08(u8 count)
+{
+    u8 i;
+    for (i = 0; i < count; i++)
+    {
+        struct Sprite * sprite = &gSprites[*gUnknown_203F3E4[i]];
+        if (sprite != NULL)
+            DestroySpriteAndFreeResources(sprite);
+        // Memory should be freed here but is not.
+    }
+}
+
+static void sub_8153D48(bool8 invisible, u8 id)
+{
+    gSprites[*gUnknown_203F3E4[id]].invisible = invisible;
+}
+
+void sub_8153D80(bool8 invisible, u8 count)
+{
+    u8 i;
+    for (i = 0; i < count; i++)
+        sub_8153D48(invisible, i);
+}
+
+void sub_8153DA8(u8 id, u8 frameNum)
+{
+    StartSpriteAnim(&gSprites[*gUnknown_203F3E4[id]], frameNum);
+}
+
+static void nullsub_97(struct Sprite * sprite)
+{
+
+}
+
+void sub_8153DD8(void)
+{
+    u8 i;
+    for (i = 0; i < 10; i++)
+    {
+        struct Sprite * sprite = &gSprites[gUnknown_203F43C->unk2A[i]];
+        sprite->pos1.x = (i * 16) + 48;
+        sprite->pos1.y = -8 - (i * 8);
+        gUnknown_203F43C->unkC[i] = 0;
+    }
+}
+
+void sub_8153E28(void)
+{
+    u8 i;
+    void *ptr = AllocZeroed(0x180);
+    struct SpritePalette spPal = {sDodrioBerryStatusPal, 2};
+
+    LZ77UnCompWram(sDodrioBerryStatusGfx, ptr);
+    // This check should be one line up.
+    if (ptr != NULL)
+    {
+        struct SpriteSheet spSheet = {ptr, 0x180, 1};
+        struct SpriteTemplate spTemplate =
+        {
+            .tileTag = 1,
+            .paletteTag = 2,
+            .oam = &sOamData_8478CA0,
+            .anims = sSpriteAnimTable_8478D0C,
+            .images = NULL,
+            .affineAnims = gDummySpriteAffineAnimTable,
+            .callback = nullsub_97,
+        };
+
+        gUnknown_203F43C = AllocZeroed(sizeof(*gUnknown_203F43C));
+        LoadSpriteSheet(&spSheet);
+        LoadSpritePalette(&spPal);
+        for (i = 0; i < 10; i++)
+            gUnknown_203F43C->unk2A[i] = CreateSprite(&spTemplate, (i * 16) + 48, -8 - (i * 8), 0);
+    }
+
+    Free(ptr);
+}
+
+void sub_8153ED8(void)
+{
+    u8 i;
+    for (i = 0; i < 10; i++)
+    {
+        struct Sprite * sprite = &gSprites[gUnknown_203F43C->unk2A[i]];
+        if (sprite != NULL)
+            DestroySpriteAndFreeResources(sprite);
+    }
+    FREE_AND_SET_NULL(gUnknown_203F43C);
+}
+
+bool32 sub_8153F1C(void)
+{
+    u8 i;
+    bool32 r3 = FALSE;
+    for (i = 0; i < 10; i++)
+    {
+        struct Sprite * sprite = &gSprites[gUnknown_203F43C->unk2A[i]];
+        gUnknown_203F43C->unk16[i] = 2;
+        if (gUnknown_203F43C->unkC[i] != 0 && sprite->pos1.y == 8)
+            continue;
+        r3 = TRUE;
+        if (sprite->pos1.y == 8)
+        {
+            if (gUnknown_203F43C->unkC[i] != 0)
+                continue;
+            gUnknown_203F43C->unkC[i] = 1;
+            gUnknown_203F43C->unk16[i] = -16;
+            PlaySE(SE_TK_KASYA);
+        }
+        sprite->pos1.y += gUnknown_203F43C->unk16[i];
+    }
+
+    if (r3)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+void sub_8153FC8(u8 arg0)
+{
+    u8 i;
+
+    if (arg0 > 10)
+    {
+        for (i = 0; i < 10; i++)
+            StartSpriteAnim(&gSprites[gUnknown_203F43C->unk2A[i]], 1);
+    }
+    else
+    {
+        for (i = 0; i < 10 - arg0; i++)
+        {
+            if (arg0 > 6)
+            {
+                gUnknown_203F43C->unk3E += arg0 - 6;
+                if (gUnknown_203F43C->unk3E > 30)
+                    gUnknown_203F43C->unk3E = 0;
+                else if (gUnknown_203F43C->unk3E > 10)
+                    StartSpriteAnim(&gSprites[gUnknown_203F43C->unk2A[i]], 2);
+                else
+                    StartSpriteAnim(&gSprites[gUnknown_203F43C->unk2A[i]], 0);
+            }
+            else
+            {
+                StartSpriteAnim(&gSprites[gUnknown_203F43C->unk2A[i]], 0);
+            }
+        }
+        for (; i < 10; i++)
+            StartSpriteAnim(&gSprites[gUnknown_203F43C->unk2A[i]], 1);
+    }
+}
+
+void sub_81540DC(bool8 invisible)
+{
+    u8 i;
+    for (i = 0; i < 10; i++)
+        gSprites[gUnknown_203F43C->unk2A[i]].invisible = invisible;
+}
+
+// Unknown unused data, feel free to remove.
+static const u8 sUnused2[] = {
+    SE_W204,
+    SE_TOY_C,
+    SE_TOY_D,
+    SE_TOY_E,
+    SE_TOY_F,
+    SE_TOY_G,
+    SE_TOY_A,
+    SE_TOY_B,
+    SE_TOY_C1,
+    SE_CARD3
+};
+
+void sub_8154128(void)
+{
+    void *ptr = AllocZeroed(0x480);
+    struct SpritePalette sprPal = {sDodrioBerrySpritesPal, 3};
+
+    LZ77UnCompWram(sDodrioBerrySpritesGfx, ptr);
+    if (ptr != NULL) // This should be one line up
+    {
+        struct SpriteSheet sprSheet = {ptr, 0x480, 2};
+        LoadSpriteSheet(&sprSheet);
+    }
+
+    LoadSpritePalette(&sprPal);
+    Free(ptr);
+}
+
+static const s16 sUnknown_8478DD4[] = {88, 128, 168, 208};
+
+void sub_815417C(void)
+{
+    u8 i;
+    s16 x;
+
+    struct SpriteTemplate sprTemplate1 =
+    {
+        .tileTag = 2,
+        .paletteTag = 3,
+        .oam = &sOamData_8478CA8,
+        .anims = sSpriteAnimTable_8478D60,
+        .images = NULL,
+        .affineAnims = gDummySpriteAffineAnimTable,
+        .callback = SpriteCallbackDummy,
+    };
+    struct SpriteTemplate sprTemplate2 =
+    {
+        .tileTag = 2,
+        .paletteTag = 3,
+        .oam = &sOamData_8478CA0,
+        .anims = sSpriteAnimTable_8478D60,
+        .images = NULL,
+        .affineAnims = gDummySpriteAffineAnimTable,
+        .callback = SpriteCallbackDummy,
+    };
+
+    for (i = 0; i < 11; i++)
+    {
+        gUnknown_203F400[i] = AllocZeroed(4);
+        x = i * 16;
+        *gUnknown_203F400[i] = CreateSprite(&sprTemplate1, x + (i * 8), 8, 1);
+        sub_81542EC(i, TRUE);
+    }
+    for (i = 0; i < 4; i++)
+    {
+        gUnknown_203F42C[i] = AllocZeroed(4);
+        if (i == 3)
+            *gUnknown_203F42C[i] = CreateSprite(&sprTemplate2, sUnknown_8478DD4[i], 57, 0);
+        else
+            *gUnknown_203F42C[i] = CreateSprite(&sprTemplate2, sUnknown_8478DD4[i], 60, 0);
+        StartSpriteAnim(&gSprites[*gUnknown_203F42C[i]], i);
+    }
+
+    sub_8154324(TRUE);
+}
+
+void sub_8154274(void)
+{
+    struct Sprite * sprite;
+    u8 i;
+
+    for (i = 0; i < 11; i++)
+    {
+        sprite = &gSprites[*gUnknown_203F400[i]];
+        if (sprite != NULL)
+            DestroySprite(sprite);
+        FREE_AND_SET_NULL(gUnknown_203F400[i]);
+    }
+    for (i = 0; i < 4; i++)
+    {
+        sprite = &gSprites[*gUnknown_203F42C[i]];
+        if (sprite != NULL)
+            DestroySprite(sprite);
+        FREE_AND_SET_NULL(gUnknown_203F42C[i]);
+    }
+}
+
+void sub_81542EC(u8 id, bool8 invisible)
+{
+    gSprites[*gUnknown_203F400[id]].invisible = invisible;
+}
+
+static void sub_8154324(bool8 invisible)
+{
+    u8 i;
+    for (i = 0; i < 4; i++)
+        gSprites[*gUnknown_203F42C[i]].invisible = invisible;
+}
+
+void sub_8154370(u8 id, u8 y)
+{
+    gSprites[*gUnknown_203F400[id]].pos1.y = y * 8;
+}
+
+void sub_8154398(u16 id, u8 frameNum)
+{
+    StartSpriteAnim(&gSprites[*gUnknown_203F400[id]], frameNum);
+}
+
+// Unused
+static void sub_81543C4(u8 spriteId)
+{
+    gSprites[spriteId].pos1.x = 20 * spriteId + 50;
+    gSprites[spriteId].pos1.y = 50;
+}
+
+// Gamefreak made a mistake there and goes out of bounds for the data array as it holds 8 elements
+// in turn overwriting sprite's subpriority and subsprites fields.
+#if defined(BUGFIX)
+#define sKeepPosX data[1]
+#else
+#define sKeepPosX data[10]
+#endif // NONMATCHING
+
+static void sub_81543E8(struct Sprite * sprite)
+{
+    u8 i;
+    static const u8 array[] = {30, 20};
+
+    if (sprite->sKeepPosX != TRUE)
+    {
+        for (i = 0; i < 2; i++)
+        {
+            if (++gUnknown_203F3F8[i][1] > array[i])
+            {
+                sprite->pos1.x--;
+                gUnknown_203F3F8[i][1] = 0;
+            }
+        }
+    }
+}
+
+static const s16 gUnknown_8478E0E[][2] = {{230, 55}, {30, 74}};
+
+void sub_8154438(void)
+{
+    u8 i;
+    void *ptr = AllocZeroed(0x400);
+    struct SpritePalette sprPal = {sDodrioBerryPlatformPal, 6};
+
+    LZ77UnCompWram(sDodrioBerryPlatformGfx, ptr);
+    if (ptr != NULL) // This should be one line up
+    {
+        struct SpriteSheet sprSheet = {ptr, 0x400, 5};
+        struct SpriteTemplate sprTemplate =
+        {
+            .tileTag = 5,
+            .paletteTag = 6,
+            .oam = &sOamData_8478CB0,
+            .anims = sSpriteAnimTable_8478D8C,
+            .images = NULL,
+            .affineAnims = gDummySpriteAffineAnimTable,
+            .callback = sub_81543E8,
+        };
+
+        LoadSpriteSheet(&sprSheet);
+        LoadSpritePalette(&sprPal);
+        for (i = 0; i < 2; i++)
+        {
+            gUnknown_203F3F8[i] = AllocZeroed(4);
+            *gUnknown_203F3F8[i] = CreateSprite(&sprTemplate, gUnknown_8478E0E[i][0], gUnknown_8478E0E[i][1], 4);
+        }
+    }
+
+    Free(ptr);
+}
+
+void sub_81544F0(void)
+{
+    u8 i;
+    for (i = 0; i < 2; i++)
+    {
+        struct Sprite * sprite = &gSprites[*gUnknown_203F3F8[i]];
+        sprite->sKeepPosX = TRUE;
+        sprite->pos1.x = gUnknown_8478E0E[i][0];
+        sprite->pos1.y = gUnknown_8478E0E[i][1];
+    }
+}
+
+void sub_8154540(void)
+{
+    u8 i;
+    for (i = 0; i < 2; i++)
+    {
+        struct Sprite * sprite = &gSprites[*gUnknown_203F3F8[i]];
+        sprite->sKeepPosX = FALSE;
+    }
+}
+
+void sub_8154578(void)
+{
+    u8 i;
+    for (i = 0; i < 2; i++)
+    {
+        struct Sprite * sprite = &gSprites[*gUnknown_203F3F8[i]];
+        if (sprite)
+            DestroySprite(sprite);
+        FREE_AND_SET_NULL(gUnknown_203F3F8[i]);
+    }
+}
+
+void sub_81545BC(bool8 invisible)
+{
+    u8 i;
+    for (i = 0; i < 2; i++)
+        gSprites[*gUnknown_203F3F8[i]].invisible = invisible;
+}
+
+#undef sKeepPosX
+
+static s16 sub_8154608(u8 arg0, u8 arg1)
+{
+    s16 x = 0;
+    switch (arg1)
+    {
+    case 1:
+        x = 15;
+        break;
+    case 2:
+        switch (arg0)
+        {
+        case 0: x = 12; break;
+        case 1: x = 18; break;
+        }
+        break;
+    case 3:
+        switch (arg0)
+        {
+        case 0: x = 15; break;
+        case 1: x = 21; break;
+        case 2: x =  9; break;
+        }
+        break;
+    case 4:
+        switch (arg0)
+        {
+        case 0: x = 12; break;
+        case 1: x = 18; break;
+        case 2: x = 24; break;
+        case 3: x =  6; break;
+        }
+        break;
+    case 5:
+        switch (arg0)
+        {
+        case 0: x = 15; break;
+        case 1: x = 21; break;
+        case 2: x = 27; break;
+        case 3: x =  3; break;
+        case 4: x =  9; break;
+        }
+        break;
+    }
+
+    return x * 8;
+}
+
+void sub_81546C0(void)
+{
+    u8 i;
+    for (i = 0; i < 11; i++)
+    {
+        sub_81542EC(i, TRUE);
+        sub_8154370(i, 1);
+    }
+    sub_81540DC(FALSE);
+}
+
+static void sub_81546EC(u8 frameId)
+{
+    LoadBgTiles(0, GetUserFrameGraphicsInfo(frameId)->tiles, 0x120, 1);
+    LoadPalette(GetUserFrameGraphicsInfo(frameId)->palette, 0xA0, 0x20);
+}
+
+static void sub_8154720(void)
+{
+    TextWindow_SetStdFrame0_WithPal(0, 0xA, 0xB0);
+}
+
+void sub_8154730(void)
+{
+    gUnknown_203F440->finished = FALSE;
+    gUnknown_203F440->state = 0;
+    gUnknown_203F440->unk3018 = 0;
+    gUnknown_203F440->unk3020 = 0;
+    gUnknown_203F440->unk3024 = 0;
+}
+
+static void sub_8154768(const struct WindowTemplate * winTempl)
+{
+    u8 pal = 0xA;
+
+    FillBgTilemapBufferRect(0, 1, winTempl->tilemapLeft - 1,                winTempl->tilemapTop - 1,                   1, 1, pal);
+    FillBgTilemapBufferRect(0, 2, winTempl->tilemapLeft,                    winTempl->tilemapTop - 1,                   winTempl->width, 1, pal);
+    FillBgTilemapBufferRect(0, 3, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop - 1,                   1, 1, pal);
+    FillBgTilemapBufferRect(0, 4, winTempl->tilemapLeft - 1,                winTempl->tilemapTop, 1,                    winTempl->height, pal);
+    FillBgTilemapBufferRect(0, 6, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop, 1,                    winTempl->height, pal);
+    FillBgTilemapBufferRect(0, 7, winTempl->tilemapLeft - 1,                winTempl->tilemapTop + winTempl->height,    1, 1, pal);
+    FillBgTilemapBufferRect(0, 8, winTempl->tilemapLeft,                    winTempl->tilemapTop + winTempl->height,    winTempl->width, 1, pal);
+    FillBgTilemapBufferRect(0, 9, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop + winTempl->height,    1, 1, pal);
+}
+
+static void sub_8154868(const struct WindowTemplate * winTempl)
+{
+    u8 pal = 0xB;
+
+    FillBgTilemapBufferRect(0, 10, winTempl->tilemapLeft - 1,                winTempl->tilemapTop - 1,                   1, 1, pal);
+    FillBgTilemapBufferRect(0, 11, winTempl->tilemapLeft,                    winTempl->tilemapTop - 1,                   winTempl->width, 1, pal);
+    FillBgTilemapBufferRect(0, 12, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop - 1,                   1, 1, pal);
+    FillBgTilemapBufferRect(0, 13, winTempl->tilemapLeft - 1,                winTempl->tilemapTop, 1,                    winTempl->height, pal);
+    FillBgTilemapBufferRect(0, 15, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop, 1,                    winTempl->height, pal);
+    FillBgTilemapBufferRect(0, 16, winTempl->tilemapLeft - 1,                winTempl->tilemapTop + winTempl->height,    1, 1, pal);
+    FillBgTilemapBufferRect(0, 17, winTempl->tilemapLeft,                    winTempl->tilemapTop + winTempl->height,    winTempl->width, 1, pal);
+    FillBgTilemapBufferRect(0, 18, winTempl->tilemapLeft + winTempl->width,  winTempl->tilemapTop + winTempl->height,    1, 1, pal);
+}
+
+void sub_8154968(struct DodrioSubstruct_0160 * ptr)
+{
+    gUnknown_203F440 = ptr;
+    gUnknown_203F440->finished = FALSE;
+    gUnknown_203F440->state = 0;
+    gUnknown_203F440->unk3018 = 0;
+    gUnknown_203F440->unk3020 = 0;
+    gUnknown_203F440->unk3024 = 0;
+    gUnknown_203F440->unk3004 = CreateTask(sub_8154A08, 3);
+    sub_8155E24(sub_8154A2C);
+}
+
+static void sub_81549C8(void)
+{
+    FreeAllWindowBuffers();
+}
+
+struct WinCoords
+{
+    u8 left;
+    u8 top;
+};
+
+static const u8 sTextColorTable[][3] =
+{
+    {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_DARK_GREY,
+        TEXT_COLOR_LIGHT_GREY
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_RED,
+        TEXT_COLOR_LIGHT_RED
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_BLUE,
+        TEXT_COLOR_LIGHT_BLUE
+    }, {
+        TEXT_COLOR_WHITE,
+        TEXT_COLOR_GREEN,
+        TEXT_COLOR_LIGHT_GREEN
+    }
+};
+
+static const struct WinCoords sUnknown_8478E44[] = {{12, 6}};
+static const struct WinCoords sUnknown_8478E48[] = {{9, 10}, {15, 6}};
+static const struct WinCoords sUnknown_8478E50[] = {{12, 6}, {18, 10}, {6, 10}};
+static const struct WinCoords sUnknown_8478E5C[] = {{9, 10}, {15, 6}, {21, 10}, {3, 6}};
+static const struct WinCoords sUnknown_8478E6C[] = {{12, 6}, {18, 10}, {23, 6}, {1, 6}, {6, 10}};
+
+static const struct WinCoords * const sUnknown_8478E80[] =
+{
+    sUnknown_8478E44,
+    sUnknown_8478E48,
+    sUnknown_8478E50,
+    sUnknown_8478E5C,
+    sUnknown_8478E6C,
+};
+
+static const u8 *const sUnknown_8478E94[] =
+{
+    gText_1Colon,
+    gText_2Colon,
+    gText_3Colon,
+    gText_4Colon,
+    gText_5Colon,
+};
+
+static const u16 sUnknown_8478EA8[] = {92, 132, 172, 212};
+static const u16 sUnknown_8478EB0[] = {30, 45, 60, 75, 90};
+static const u16 sUnknown_8478EBA[] = {12, 28, 44, 60, 76};
+
+struct
+{
+    u8 id;
+    void (*func)(void);
+} const gUnknown_8478EC4[] =
+{
+    {0, sub_8154A2C},
+    {1, sub_8154B34},
+    {2, sub_8154F80},
+    {3, sub_81556E0},
+    {4, sub_8155A78},
+    {5, sub_8155B4C},
+    {6, sub_8155C2C},
+    {7, sub_8155C80},
+    {8, unused_0},
+    {9, nullsub_98},
+};
+
+void sub_81549D4(u8 arg0)
+{
+    u8 i;
+    for (i = 0; i < 10; i++)
+    {
+        if (gUnknown_8478EC4[i].id == arg0)
+            sub_8155E24(gUnknown_8478EC4[i].func);
+    }
+}
+
+static void sub_8154A08(u8 taskId)
+{
+    if (!gUnknown_203F440->finished)
+        sub_8155E54()();
+}
+
+static void sub_8154A2C(void)
+{
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        sub_8155EA0();
+        gUnknown_203F440->state++;
+        break;
+    case 1:
+        if (sub_8155FE0() == TRUE)
+            gUnknown_203F440->state++;
+        break;
+    case 2:
+        CopyToBgTilemapBuffer(3, sDodrioBerryBgTilemap1, 0, 0);
+        CopyToBgTilemapBuffer(1, sDodrioBerryBgTilemap2Left, 0, 0);
+        CopyToBgTilemapBuffer(2, sDodrioBerryBgTilemap2Right, 0, 0);
+        CopyBgTilemapBufferToVram(3);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        gUnknown_203F440->state++;
+        break;
+    case 3:
+        ShowBg(0);
+        ShowBg(3);
+        ShowBg(1);
+        ShowBg(2);
+        gUnknown_203F440->state++;
+        break;
+    case 4:
+        sub_81546EC(gSaveBlock2Ptr->optionsWindowFrameType);
+        sub_8154720();
+        gUnknown_203F440->state++;
+        break;
+    default:
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void sub_8154B34(void)
+{
+    u8 i, playersCount, id, colorsId, *name;
+    u32 left;
+    struct WindowTemplate window;
+    const struct WinCoords * ptr;
+
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        playersCount = sub_81533B4();
+        ptr = sUnknown_8478E80[playersCount - 1];
+        window.bg = 0;
+        window.width = 7;
+        window.height = 2;
+        window.paletteNum = 0xD;
+        window.baseBlock = 0x13;
+        for (i = 0; i < playersCount; ptr++, i++)
+        {
+            colorsId = 0;
+            id = sub_81537AC(i);
+            left = (56 - GetStringWidth(0, sub_81533C4(id), -1)) / 2u;
+            window.tilemapLeft = ptr->left;
+            window.tilemapTop = ptr->top;
+            gUnknown_203F440->unk3008[i] = AddWindow(&window);
+            ClearWindowTilemap(gUnknown_203F440->unk3008[i]);
+            FillWindowPixelBuffer(gUnknown_203F440->unk3008[i], PIXEL_FILL(1));
+            if (id == GetMultiplayerId())
+                colorsId = 2;
+            name = sub_81533C4(id);
+            AddTextPrinterParameterized3(gUnknown_203F440->unk3008[i], 0, left, 1, sTextColorTable[colorsId], -1, name);
+            CopyWindowToVram(gUnknown_203F440->unk3008[i], 2);
+            window.baseBlock += 0xE;
+            sub_8154868(&window);
+        }
+        gUnknown_203F440->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            playersCount = sub_81533B4();
+            for (i = 0; i < playersCount; i++)
+                PutWindowTilemap(gUnknown_203F440->unk3008[i]);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F440->state++;
+        }
+        break;
+    default:
+        if (++gUnknown_203F440->state > 180)
+        {
+            playersCount = sub_81533B4();
+            for (i = 0; i < playersCount; i++)
+            {
+                ClearWindowTilemap(gUnknown_203F440->unk3008[i]);
+                RemoveWindow(gUnknown_203F440->unk3008[i]);
+            }
+            FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F440->finished = TRUE;
+        }
+        break;
+    }
+}
+
+static void sub_8154D9C(u8 playersCount_)
+{
+    u8 i, r8 = 0, r6 = 0;
+    u8 playersCount = playersCount_; // Pointless variable, I know, but it's needed to match.
+    u8 *name;
+    u32 x, numWidth;
+    u8 numString[32];
+    u8 array[5] = {0, 1, 2, 3, 4};
+    struct DodrioSubstruct_3308 temp, structArray[5];
+
+    for (i = 0; i < playersCount; i++)
+    {
+        array[i] = i;
+        sub_81536A0(&temp, i);
+        structArray[i] = temp;
+    }
+
+    if (sub_81534AC() != 0)
+    {
+        do
+        {
+            for (i = 0; i < playersCount; i++)
+            {
+                if (structArray[i].unk0 == r8)
+                {
+                    array[r6] = i;
+                    r6++;
+                }
+            }
+            r8 = r6;
+        } while (r6 < playersCount);
+    }
+
+    for (i = 0; i < playersCount; i++)
+    {
+        if (structArray[i].unk4 == 0)
+            structArray[i].unk0 = playersCount - 1;
+    }
+
+    x = 216 - GetStringWidth(0, gText_SpacePoints, 0);
+    for (i = 0; i < playersCount; i++)
+    {
+        u8 colorsId = 0;
+        u8 id = array[i];
+        u32 points = structArray[id].unk4;
+
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, sUnknown_8478E94[structArray[id].unk0], 8, sUnknown_8478EBA[i], -1, NULL);
+        if (id == GetMultiplayerId())
+            colorsId = 2;
+        name = sub_81533C4(id);
+        AddTextPrinterParameterized3(gUnknown_203F440->unk3008[1], 0, 28, sUnknown_8478EBA[i], sTextColorTable[colorsId], -1, name);
+        ConvertIntToDecimalStringN(numString, points, STR_CONV_MODE_RIGHT_ALIGN, 7);
+        numWidth = GetStringWidth(0, numString, -1);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, numString, x - 35, sUnknown_8478EBA[i], -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, gText_SpacePoints, x, sUnknown_8478EBA[i], -1, NULL);
+    }
+}
+
+static void sub_8154F80(void)
+{
+    u8 i, j, itemGiveRet, playersCount = sub_81533B4();
+    u8 *name;
+    u32 strWidth, x;
+    u8 sp0C[100];
+    u8 sp70[20];
+
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        sub_81535B0();
+        gUnknown_203F440->unk301C = 0;
+        gUnknown_203F440->state++;
+        break;
+    case 1:
+        gUnknown_203F440->unk3008[0] = AddWindow(&sUnknown_8475674[0]);
+        gUnknown_203F440->unk3008[1] = AddWindow(&sUnknown_8475674[1]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[1]);
+        sub_8154868(&sUnknown_8475674[0]);
+        sub_8154868(&sUnknown_8475674[1]);
+        gUnknown_203F440->state++;
+        break;
+    case 2:
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[1], PIXEL_FILL(1));
+        strWidth = GetStringWidth(0, gText_BerryPickingResults, -1);
+        x = (224 - strWidth) / 2;
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 0, gText_BerryPickingResults, x, 2, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, gText_10P30P50P50P, 68, 16, -1, NULL);
+        for (i = 0; i < playersCount; i++)
+        {
+            u8 colorsId = 0;
+            if (i == GetMultiplayerId())
+                colorsId = 2;
+
+            name = sub_81533C4(i);
+            AddTextPrinterParameterized3(gUnknown_203F440->unk3008[1], 0, 2, sUnknown_8478EB0[i], sTextColorTable[colorsId], -1, name);
+            for (j = 0; j < 4; j++)
+            {
+                u32 width;
+                u16 result1 = Min(sub_8153404(i, j), 9999);
+                u16 result2 = Min(sub_81534F0(j), 9999);
+
+                ConvertIntToDecimalStringN(sp0C, result1, STR_CONV_MODE_LEFT_ALIGN, 4);
+                width = GetStringWidth(0, sp0C, -1);
+                if (result2 == result1 && result2 != 0)
+                    AddTextPrinterParameterized3(gUnknown_203F440->unk3008[1], 0, sUnknown_8478EA8[j] - width, sUnknown_8478EB0[i], sTextColorTable[1], -1, sp0C);
+                else
+                    AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, sp0C, sUnknown_8478EA8[j] - width, sUnknown_8478EB0[i], -1, NULL);
+            }
+        }
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        CopyWindowToVram(gUnknown_203F440->unk3008[1], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+            PutWindowTilemap(gUnknown_203F440->unk3008[1]);
+        }
+        CopyBgTilemapBufferToVram(0);
+        sub_8154324(FALSE);
+        gUnknown_203F440->state++;
+        break;
+    case 4:
+        if (++gUnknown_203F440->unk301C >= 30 && JOY_NEW(A_BUTTON))
+        {
+            gUnknown_203F440->unk301C = 0;
+            PlaySE(SE_SELECT);
+            sub_8154324(TRUE);
+            gUnknown_203F440->state++;
+        }
+        break;
+    case 5:
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[1], PIXEL_FILL(1));
+        strWidth = GetStringWidth(0, gText_AnnouncingRankings, -1);
+        x = (224 - strWidth) / 2;
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 0, gText_AnnouncingRankings, x, 2, -1, NULL);
+        gUnknown_203F440->state++;
+        break;
+    case 6:
+        sub_8154D9C(playersCount);
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        CopyWindowToVram(gUnknown_203F440->unk3008[1], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 7:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+            PutWindowTilemap(gUnknown_203F440->unk3008[1]);
+        }
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->state++;
+        break;
+    case 8:
+        if (++gUnknown_203F440->unk301C >= 30 && JOY_NEW(A_BUTTON))
+        {
+            gUnknown_203F440->unk301C = 0;
+            PlaySE(SE_SELECT);
+            if (sub_81534AC() < 3000)
+            {
+                gUnknown_203F440->state = 127;
+            }
+            else
+            {
+                StopMapMusic();
+                gUnknown_203F440->state++;
+            }
+
+            FillBgTilemapBufferRect_Palette0(0, 0, 0, 5, 30, 15);
+            RemoveWindow(gUnknown_203F440->unk3008[1]);
+            gUnknown_203F440->unk3008[1] = AddWindow(&sUnknown_8475684);
+            ClearWindowTilemap(gUnknown_203F440->unk3008[1]);
+            sub_8154868(&sUnknown_8475684);
+        }
+        break;
+    case 9:
+        PlayNewMapMusic(MUS_FANFA1);
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[1], PIXEL_FILL(1));
+        strWidth = GetStringWidth(0, gText_AnnouncingPrizes, -1);
+        x = (224 - strWidth) / 2;
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 0, gText_AnnouncingPrizes, x, 2, -1, NULL);
+        DynamicPlaceholderTextUtil_Reset();
+        CopyItemName(sub_8153390(), sp70);
+        DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, sp70);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(sp0C, gText_FirstPlacePrize);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, sp0C, 8, 2, -1, NULL);
+        itemGiveRet = sub_815372C();
+        if (itemGiveRet != 0 && itemGiveRet != 3)
+        {
+            DynamicPlaceholderTextUtil_Reset();
+            CopyItemName(sub_8153390(), sp70);
+            DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, sp70);
+            if (itemGiveRet == 2)
+                DynamicPlaceholderTextUtil_ExpandPlaceholders(sp0C, gText_CantHoldAnyMore);
+            else if (itemGiveRet == 1)
+                DynamicPlaceholderTextUtil_ExpandPlaceholders(sp0C, gText_FilledStorageSpace);
+            AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 0, sp0C, 8, 40, -1, NULL);
+        }
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        CopyWindowToVram(gUnknown_203F440->unk3008[1], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 10:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+            PutWindowTilemap(gUnknown_203F440->unk3008[1]);
+        }
+        CopyBgTilemapBufferToVram(0);
+        FadeOutAndFadeInNewMapMusic(MUS_WIN_YASEI, 20, 10);
+        gUnknown_203F440->state++;
+        break;
+    case 11:
+        if (++gUnknown_203F440->unk301C >= 30 && JOY_NEW(A_BUTTON))
+        {
+            gUnknown_203F440->unk301C = 0;
+            PlaySE(SE_SELECT);
+            gUnknown_203F440->state++;
+        }
+        break;
+    default:
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[1]);
+        RemoveWindow(gUnknown_203F440->unk3008[0]);
+        RemoveWindow(gUnknown_203F440->unk3008[1]);
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void sub_81556E0(void)
+{
+    u8 y;
+
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        gUnknown_203F440->unk3008[0] = AddWindow(&sUnknown_847568C[0]);
+        gUnknown_203F440->unk3008[1] = AddWindow(&sUnknown_847568C[1]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[1]);
+        sub_8154868(&sUnknown_847568C[0]);
+        sub_8154768(&sUnknown_847568C[1]);
+        gUnknown_203F440->state++;
+        gUnknown_203F440->unk3020 = 0;
+        gUnknown_203F440->unk3024 = 0;
+        break;
+    case 1:
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[1], PIXEL_FILL(1));
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 2, gText_WantToPlayAgain, 0, 6, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_Yes, 8, 2, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_No, 8, 16, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_SelectorArrow2, 0, 2, -1, NULL);
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        CopyWindowToVram(gUnknown_203F440->unk3008[1], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+            PutWindowTilemap(gUnknown_203F440->unk3008[1]);
+        }
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->state++;
+        break;
+    case 3:
+        y = gUnknown_203F440->unk3020;
+        if (y == 0)
+            y = 1;
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[1], PIXEL_FILL(1));
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_Yes, 8, 2, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_No, 8, 16, -1, NULL);
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[1], 2, gText_SelectorArrow2, 0, y == 1 ? 2 : 16, -1, NULL);
+        CopyWindowToVram(gUnknown_203F440->unk3008[1], 3);
+        // Increment state only if A or B button have been pressed.
+        if (JOY_NEW(A_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+            if (gUnknown_203F440->unk3020 == 0)
+                gUnknown_203F440->unk3020 = 1;
+            gUnknown_203F440->state++;
+        }
+        else if (JOY_NEW(DPAD_UP | DPAD_DOWN))
+        {
+            PlaySE(SE_SELECT);
+            switch (gUnknown_203F440->unk3020)
+            {
+            case 0:
+                gUnknown_203F440->unk3020 = 2;
+                break;
+            case 1:
+                gUnknown_203F440->unk3020 = 2;
+                break;
+            case 2:
+                gUnknown_203F440->unk3020 = 1;
+                break;
+            }
+        }
+        else if (JOY_NEW(B_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+            gUnknown_203F440->unk3020 = 2;
+            gUnknown_203F440->state++;
+        }
+        break;
+    default:
+        gUnknown_203F440->unk3024 = gUnknown_203F440->unk3020;
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[1]);
+        RemoveWindow(gUnknown_203F440->unk3008[0]);
+        RemoveWindow(gUnknown_203F440->unk3008[1]);
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void sub_8155A78(void)
+{
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        DrawDialogueFrame(0, FALSE);
+        AddTextPrinterParameterized2(0, 2, gText_SavingDontTurnOffThePower2, 0, NULL, TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY);
+        gUnknown_203F440->state++;
+        break;
+    case 1:
+        CopyWindowToVram(0, 3);
+        gUnknown_203F440->state++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            CreateTask(sub_80DA634, 0);
+            gUnknown_203F440->state++;
+        }
+        break;
+    case 3:
+        if (!FuncIsActiveTask(sub_80DA634))
+            gUnknown_203F440->state++;
+        break;
+    default:
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void sub_8155B4C(void)
+{
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        gUnknown_203F440->unk3008[0] = AddWindow(&sUnknown_84756A4);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        sub_8154868(&sUnknown_84756A4);
+        gUnknown_203F440->state++;
+        break;
+    case 1:
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 2, gText_CommunicationStandby3, 0, 6, -1, NULL);
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->state++;
+        break;
+    default:
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void sub_8155C2C(void)
+{
+    ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+    RemoveWindow(gUnknown_203F440->unk3008[0]);
+    FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+    CopyBgTilemapBufferToVram(0);
+    gUnknown_203F440->finished = TRUE;
+}
+
+static void sub_8155C80(void)
+{
+    switch (gUnknown_203F440->state)
+    {
+    case 0:
+        gUnknown_203F440->unk3008[0] = AddWindow(&sUnknown_847569C);
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        sub_8154868(&sUnknown_847569C);
+        gUnknown_203F440->state++;
+        gUnknown_203F440->unk301C = 0;
+        gUnknown_203F440->unk3020 = 0;
+        gUnknown_203F440->unk3024 = 0;
+        break;
+    case 1:
+        FillWindowPixelBuffer(gUnknown_203F440->unk3008[0], PIXEL_FILL(1));
+        AddTextPrinterParameterized(gUnknown_203F440->unk3008[0], 2, gText_SomeoneDroppedOut, 0, 6, TEXT_SPEED_FF, NULL);
+        CopyWindowToVram(gUnknown_203F440->unk3008[0], 2);
+        gUnknown_203F440->state++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            PutWindowTilemap(gUnknown_203F440->unk3008[0]);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->state++;
+        break;
+    case 3:
+        if (++gUnknown_203F440->unk301C >= 120)
+            gUnknown_203F440->state++;
+        break;
+    default:
+        gUnknown_203F440->unk3024 = 5;
+        ClearWindowTilemap(gUnknown_203F440->unk3008[0]);
+        RemoveWindow(gUnknown_203F440->unk3008[0]);
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F440->finished = TRUE;
+        break;
+    }
+}
+
+static void unused_0(void)
+{
+    DestroyTask(gUnknown_203F440->unk3004);
+    gUnknown_203F440->finished = TRUE;
+}
+
+static void nullsub_98(void)
+{
+
+}
+
+static void sub_8155E24(void (*func)(void))
+{
+    gUnknown_203F440->state = 0;
+    gUnknown_203F440->finished = FALSE;
+    gUnknown_203F440->unk3028 = func;
+}
+
+void (*sub_8155E54(void))(void)
+{
+    return gUnknown_203F440->unk3028;
+}
+
+bool32 sub_8155E68(void)
+{
+    if (gUnknown_203F440->finished == TRUE)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+u8 sub_8155E8C(void)
+{
+    return gUnknown_203F440->unk3024;
+}
+
+static void sub_8155EA0(void)
+{
+    DmaClearLarge16(3, (void *)VRAM, VRAM_SIZE, 0x1000);
+    DmaClear32(3,(void *)OAM, OAM_SIZE);
+    DmaClear16(3, (void *)PLTT, PLTT_SIZE);
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, sUnknown_847565C, ARRAY_COUNT(sUnknown_847565C));
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+    InitStandardTextBoxWindows();
+    ResetBg0();
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+    SetBgTilemapBuffer(3, gUnknown_203F440->tilemapBuffers[0]);
+    SetBgTilemapBuffer(1, gUnknown_203F440->tilemapBuffers[1]);
+    SetBgTilemapBuffer(2, gUnknown_203F440->tilemapBuffers[2]);
+}
+
+static bool32 sub_8155FE0(void)
+{
+    switch (gUnknown_203F440->unk3018)
+    {
+    case 0:
+        LoadPalette(sDodrioBerryBgPal1, 0, sizeof(sDodrioBerryBgPal1));
+        break;
+    case 1:
+        ResetTempTileDataBuffers();
+        break;
+    case 2:
+        DecompressAndCopyTileDataToVram(3, sDodrioBerryBgGfx1, 0, 0, 0);
+        break;
+    case 3:
+        DecompressAndCopyTileDataToVram(1, sDodrioBerryBgGfx2, 0, 0, 0);
+        break;
+    case 4:
+        if (FreeTempTileDataBuffersIfPossible() == TRUE)
+            return FALSE;
+        break;
+    case 5:
+        LoadPalette(stdpal_get(3), 0xD0, 0x20);
+        break;
+    default:
+        gUnknown_203F440->unk3018 = 0;
+        return TRUE;
+    }
+
+    gUnknown_203F440->unk3018++;
+    return FALSE;
+}
diff --git a/src/dodrio_berry_picking_3.c b/src/dodrio_berry_picking_3.c
new file mode 100644
index 000000000..fec1d62f7
--- /dev/null
+++ b/src/dodrio_berry_picking_3.c
@@ -0,0 +1,241 @@
+#include "global.h"
+#include "dodrio_berry_picking.h"
+#include "link.h"
+#include "link_rfu.h"
+
+void sub_815A5BC(s32 a0)
+{
+    struct Padded_U8 data[2];
+    data[0].value = 1;
+    data[1].value = a0;
+    RfuPrepareSend0x2f00(data);
+}
+
+u8 sub_815A5E8(s32 a0)
+{
+    u8 * r1;
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
+        return 0;
+    r1 = (u8 *)&gRecvCmds[a0][1];
+    if (r1[0] == 1)
+        return r1[4];
+    return 0;
+}
+
+struct UnkPacket2
+{
+    u8 id;
+    u8 unk1_0:4;
+    u8 unk1_1:4;
+    u16 unk2_0:4;
+    u16 unk2_1:4;
+    u16 unk3_0:4;
+    u16 unk3_1:4;
+    u16 unk4_0:4;
+    u16 unk4_1:4;
+    u16 unk5_0:4;
+    u16 unk5_1:4;
+    u16 unk6_0:2;
+    u16 unk6_1:2;
+    u16 unk6_2:2;
+    u16 unk6_3:2;
+    u16 unk7_0:2;
+    u16 unk7_1:2;
+    u16 unk7_2:2;
+    u16 unk7_3:2;
+    u8 unk8_0:2;
+    u8 unk8_1:2;
+    u8 unk8_2:2;
+    u8 unk8_3:2;
+    u8 unk9_0:2;
+    u8 unk9_1:2;
+    u8 unk9_2:2;
+    u8 unk9_3:1;
+    u8 unk9_4:1;
+    u8 unkA_0:1;
+    u8 unkA_1:1;
+    u8 unkA_2:1;
+    u8 unkA_3:5;
+    u8 unkB_0:1;
+    u8 unkB_1:1;
+    u8 unkB_2:1;
+    u8 unkB_3:1;
+    u8 unkB_4:1;
+    u8 unkB_5:1;
+    u8 unkB_6:1;
+};
+
+void sub_815A61C(struct DodrioSubstruct_31A0 * arg0, struct DodrioSubstruct_31A0_2C * arg1, struct DodrioSubstruct_31A0_2C * arg2, struct DodrioSubstruct_31A0_2C * arg3, struct DodrioSubstruct_31A0_2C * arg4, struct DodrioSubstruct_31A0_2C * arg5, u8 arg6, u32 arg7, u32 arg8)
+{
+    struct UnkPacket2 packet;
+    struct DodrioSubstruct_31A0_14 * ptr = &arg0->unk14;
+
+    packet.id = 2;
+    packet.unk1_0 = ptr->unkB[0];
+    packet.unk1_1 = ptr->unkB[1];
+    packet.unk2_0 = ptr->unkB[2];
+    packet.unk2_1 = ptr->unkB[3];
+    packet.unk3_0 = ptr->unkB[4];
+    packet.unk3_1 = ptr->unkB[5];
+    packet.unk4_0 = ptr->unkB[6];
+    packet.unk4_1 = ptr->unkB[7];
+    packet.unk5_0 = ptr->unkB[8];
+    packet.unk5_1 = ptr->unkB[9];
+
+    packet.unk6_0 = ptr->unk0[0];
+    packet.unk6_1 = ptr->unk0[1];
+    packet.unk6_2 = ptr->unk0[2];
+    packet.unk6_3 = ptr->unk0[3];
+    packet.unk7_0 = ptr->unk0[4];
+    packet.unk7_1 = ptr->unk0[5];
+    packet.unk7_2 = ptr->unk0[6];
+    packet.unk7_3 = ptr->unk0[7];
+    packet.unk8_0 = ptr->unk0[8];
+    packet.unk8_1 = ptr->unk0[9];
+
+    packet.unk8_2 = arg1->unk0;
+    packet.unk8_3 = arg2->unk0;
+    packet.unk9_0 = arg3->unk0;
+    packet.unk9_1 = arg4->unk0;
+    packet.unk9_2 = arg5->unk0;
+
+    packet.unk9_3 = arg1->unk4;
+    packet.unk9_4 = arg2->unk4;
+    packet.unkA_0 = arg3->unk4;
+    packet.unkA_1 = arg4->unk4;
+    packet.unkA_2 = arg5->unk4;
+
+    packet.unkB_2 = arg1->unk8;
+    packet.unkB_3 = arg2->unk8;
+    packet.unkB_4 = arg3->unk8;
+    packet.unkB_5 = arg4->unk8;
+    packet.unkB_6 = arg5->unk8;
+
+    packet.unkA_3 = arg6;
+    packet.unkB_1 = arg7;
+    packet.unkB_0 = arg8;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+u32 sub_815A950(u32 unused, struct DodrioSubstruct_31A0 * arg0, struct DodrioSubstruct_31A0_2C * arg1, struct DodrioSubstruct_31A0_2C * arg2, struct DodrioSubstruct_31A0_2C * arg3, struct DodrioSubstruct_31A0_2C * arg4, struct DodrioSubstruct_31A0_2C * arg5, u8 *arg6, u32 *arg7, u32 *arg8)
+{
+    struct UnkPacket2 * packet;
+    struct DodrioSubstruct_31A0_14 * ptr = &arg0->unk14;
+
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
+        return 0;
+
+    packet = (void *)&gRecvCmds[0][1];
+    if (packet->id == 2)
+    {
+        ptr->unkB[0] = packet->unk1_0;
+        ptr->unkB[1] = packet->unk1_1;
+        ptr->unkB[2] = packet->unk2_0;
+        ptr->unkB[3] = packet->unk2_1;
+        ptr->unkB[4] = packet->unk3_0;
+        ptr->unkB[5] = packet->unk3_1;
+        ptr->unkB[6] = packet->unk4_0;
+        ptr->unkB[7] = packet->unk4_1;
+        ptr->unkB[8] = packet->unk5_0;
+        ptr->unkB[9] = packet->unk5_1;
+        ptr->unkB[10] = packet->unk1_0;
+
+        ptr->unk0[0] = packet->unk6_0;
+        ptr->unk0[1] = packet->unk6_1;
+        ptr->unk0[2] = packet->unk6_2;
+        ptr->unk0[3] = packet->unk6_3;
+        ptr->unk0[4] = packet->unk7_0;
+        ptr->unk0[5] = packet->unk7_1;
+        ptr->unk0[6] = packet->unk7_2;
+        ptr->unk0[7] = packet->unk7_3;
+        ptr->unk0[8] = packet->unk8_0;
+        ptr->unk0[9] = packet->unk8_1;
+        ptr->unk0[10] = packet->unk6_0;
+
+        arg1->unk0 = packet->unk8_2;
+        arg1->unk4 = packet->unk9_3;
+        arg1->unk8 = packet->unkB_2;
+
+        arg2->unk0 = packet->unk8_3;
+        arg2->unk4 = packet->unk9_4;
+        arg2->unk8 = packet->unkB_3;
+
+        arg3->unk0 = packet->unk9_0;
+        arg3->unk4 = packet->unkA_0;
+        arg3->unk8 = packet->unkB_4;
+
+        arg4->unk0 = packet->unk9_1;
+        arg4->unk4 = packet->unkA_1;
+        arg4->unk8 = packet->unkB_5;
+
+        arg5->unk0 = packet->unk9_2;
+        arg5->unk4 = packet->unkA_2;
+        arg5->unk8 = packet->unkB_6;
+
+        *arg6 = packet->unkA_3;
+        *arg7 = packet->unkB_1;
+        *arg8 = packet->unkB_0;
+        return 1;
+    }
+
+    return 0;
+}
+
+struct UnkPacket3
+{
+    u8 id;
+    u8 ALIGNED(4) unk4;
+};
+
+void sub_815AAD8(u8 arg0)
+{
+    struct UnkPacket3 packet;
+    packet.id = 3;
+    packet.unk4 = arg0;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+u32 sub_815AB04(u32 arg0, u8 *arg1)
+{
+    struct UnkPacket3 * packet;
+
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
+        return 0;
+
+    packet = (void *)&gRecvCmds[arg0][1];
+    if (packet->id == 3)
+    {
+        *arg1 = packet->unk4;
+        return 1;
+    }
+
+    return 0;
+}
+
+struct UnkPacket4
+{
+    u8 id;
+    u32 unk4;
+};
+
+void sub_815AB3C(u32 arg0)
+{
+    struct UnkPacket4 packet;
+    packet.id = 4;
+    packet.unk4 = arg0;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+u32 sub_815AB60(u32 arg0)
+{
+    struct UnkPacket4 * packet;
+
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
+        return 0;
+
+    packet = (void *)&gRecvCmds[arg0][1];
+    if (packet->id == 4)
+        return packet->unk4;
+
+    return 0;
+}
diff --git a/src/dynamic_placeholder_text_util.c b/src/dynamic_placeholder_text_util.c
index 6909fea30..921612cfc 100644
--- a/src/dynamic_placeholder_text_util.c
+++ b/src/dynamic_placeholder_text_util.c
@@ -1,17 +1,89 @@
 #include "global.h"
 #include "text.h"
-#include "dynamic_placeholder_text_util.h"
 #include "string_util.h"
+#include "constants/event_objects.h"
 
 static EWRAM_DATA const u8 *sStringPointers[8] = {0};
 
 static const u8 sTextColorTable[] =
 {
-     0,  0,  0, 16, 17, 17, 17, 16, 16,  0,  0, 17,  1,  0, 17, 16,
-     0, 16, 16,  0,  1,  1,  1,  1,  1,  1,  0,  0,  0,  1,  0,  0,
-    17,  1,  0,  0,  0, 16, 17,  0, 16, 16, 16,  0,  1,  0, 51, 51,
-    51, 51, 51, 51, 51, 51, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34,
-    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 50,
+ // [LOW_NYBBLE / 2]                               = 0xXY, // HIGH_NYBBLE
+    [OBJ_EVENT_GFX_RED_NORMAL / 2]              = 0x00, // OBJ_EVENT_GFX_RED_BIKE
+    [OBJ_EVENT_GFX_RED_SURF / 2]                 = 0x00, // OBJ_EVENT_GFX_RED_ITEM
+    [OBJ_EVENT_GFX_RED_FISH / 2]                = 0x00, // OBJ_EVENT_GFX_RED_ITEM_COPY
+    [OBJ_EVENT_GFX_RED_VS_SEEKER / 2]           = 0x10, // OBJ_EVENT_GFX_GREEN_NORMAL
+    [OBJ_EVENT_GFX_GREEN_BIKE / 2]              = 0x11, // OBJ_EVENT_GFX_GREEN_SURF
+    [OBJ_EVENT_GFX_GREEN_ITEM / 2]              = 0x11, // OBJ_EVENT_GFX_GREEN_FISH
+    [OBJ_EVENT_GFX_GREEN_ITEM_COPY / 2]         = 0x11, // OBJ_EVENT_GFX_GREEN_VS_SEEKER
+    [OBJ_EVENT_GFX_RS_BRENDAN / 2]              = 0x10, // OBJ_EVENT_GFX_RS_MAY
+    [OBJ_EVENT_GFX_LITTLE_BOY / 2]              = 0x10, // OBJ_EVENT_GFX_LITTLE_GIRL
+    [OBJ_EVENT_GFX_YOUNGSTER / 2]               = 0x00, // OBJ_EVENT_GFX_BOY
+    [OBJ_EVENT_GFX_BUG_CATCHER / 2]             = 0x00, // OBJ_EVENT_GFX_SITTING_BOY
+    [OBJ_EVENT_GFX_LASS / 2]                    = 0x11, // OBJ_EVENT_GFX_WOMAN_1
+    [OBJ_EVENT_GFX_BATTLE_GIRL / 2]             = 0x01, // OBJ_EVENT_GFX_MAN
+    [OBJ_EVENT_GFX_ROCKER / 2]                  = 0x00, // OBJ_EVENT_GFX_FAT_MAN
+    [OBJ_EVENT_GFX_WOMAN_2 / 2]                 = 0x11, // OBJ_EVENT_GFX_BEAUTY
+    [OBJ_EVENT_GFX_BALDING_MAN / 2]             = 0x10, // OBJ_EVENT_GFX_WOMAN_3
+    [OBJ_EVENT_GFX_OLD_MAN_1 / 2]               = 0x00, // OBJ_EVENT_GFX_OLD_MAN_2
+    [OBJ_EVENT_GFX_OLD_MAN_LYING_DOWN / 2]      = 0x10, // OBJ_EVENT_GFX_OLD_WOMAN
+    [OBJ_EVENT_GFX_TUBER_M_1 / 2]               = 0x10, // OBJ_EVENT_GFX_TUBER_F
+    [OBJ_EVENT_GFX_TUBER_M_2 / 2]               = 0x00, // OBJ_EVENT_GFX_CAMPER
+    [OBJ_EVENT_GFX_PICNICKER / 2]               = 0x01, // OBJ_EVENT_GFX_COOLTRAINER_M
+    [OBJ_EVENT_GFX_COOLTRAINER_F / 2]           = 0x01, // OBJ_EVENT_GFX_SWIMMER_M_WATER
+    [OBJ_EVENT_GFX_SWIMMER_F_WATER / 2]         = 0x01, // OBJ_EVENT_GFX_SWIMMER_M_LAND
+    [OBJ_EVENT_GFX_SWIMMER_F_LAND / 2]          = 0x01, // OBJ_EVENT_GFX_WORKER_M
+    [OBJ_EVENT_GFX_WORKER_F / 2]                = 0x01, // OBJ_EVENT_GFX_ROCKET_M
+    [OBJ_EVENT_GFX_ROCKET_F / 2]                = 0x01, // OBJ_EVENT_GFX_GBA_KID
+    [OBJ_EVENT_GFX_SUPER_NERD / 2]              = 0x00, // OBJ_EVENT_GFX_BIKER
+    [OBJ_EVENT_GFX_BLACKBELT / 2]               = 0x00, // OBJ_EVENT_GFX_SCIENTIST
+    [OBJ_EVENT_GFX_HIKER / 2]                   = 0x00, // OBJ_EVENT_GFX_FISHER
+    [OBJ_EVENT_GFX_CHANNELER / 2]               = 0x01, // OBJ_EVENT_GFX_CHEF
+    [OBJ_EVENT_GFX_POLICEMAN / 2]               = 0x00, // OBJ_EVENT_GFX_GENTLEMAN
+    [OBJ_EVENT_GFX_SAILOR / 2]                  = 0x00, // OBJ_EVENT_GFX_CAPTAIN
+    [OBJ_EVENT_GFX_NURSE / 2]                   = 0x11, // OBJ_EVENT_GFX_CABLE_CLUB_RECEPTIONIST
+    [OBJ_EVENT_GFX_UNION_ROOM_RECEPTIONIST / 2] = 0x01, // OBJ_EVENT_GFX_UNUSED_MALE_RECEPTIONIST
+    [OBJ_EVENT_GFX_CLERK / 2]                   = 0x00, // OBJ_EVENT_GFX_MG_DELIVERYMAN
+    [OBJ_EVENT_GFX_TRAINER_TOWER_DUDE / 2]      = 0x00, // OBJ_EVENT_GFX_PROF_OAK
+    [OBJ_EVENT_GFX_BLUE / 2]                    = 0x00, // OBJ_EVENT_GFX_BILL
+    [OBJ_EVENT_GFX_LANCE / 2]                   = 0x10, // OBJ_EVENT_GFX_AGATHA
+    [OBJ_EVENT_GFX_DAISY / 2]                   = 0x11, // OBJ_EVENT_GFX_LORELEI
+    [OBJ_EVENT_GFX_MR_FUJI / 2]                 = 0x00, // OBJ_EVENT_GFX_BRUNO
+    [OBJ_EVENT_GFX_BROCK / 2]                   = 0x10, // OBJ_EVENT_GFX_MISTY
+    [OBJ_EVENT_GFX_LT_SURGE / 2]                = 0x10, // OBJ_EVENT_GFX_ERIKA
+    [OBJ_EVENT_GFX_KOGA / 2]                    = 0x10, // OBJ_EVENT_GFX_SABRINA
+    [OBJ_EVENT_GFX_BLAINE / 2]                  = 0x00, // OBJ_EVENT_GFX_GIOVANNI
+    [OBJ_EVENT_GFX_MOM / 2]                     = 0x01, // OBJ_EVENT_GFX_CELIO
+    [OBJ_EVENT_GFX_TEACHY_TV_HOST / 2]          = 0x00, // OBJ_EVENT_GFX_GYM_GUY
+    [OBJ_EVENT_GFX_ITEM_BALL / 2]               = 0x33, // OBJ_EVENT_GFX_TOWN_MAP
+    [OBJ_EVENT_GFX_POKEDEX / 2]                 = 0x33, // OBJ_EVENT_GFX_CUT_TREE
+    [OBJ_EVENT_GFX_ROCK_SMASH_ROCK / 2]         = 0x33, // OBJ_EVENT_GFX_STRENGTH_BOULDER
+    [OBJ_EVENT_GFX_FOSSIL / 2]                  = 0x33, // OBJ_EVENT_GFX_RUBY
+    [OBJ_EVENT_GFX_SAPPHIRE / 2]                = 0x33, // OBJ_EVENT_GFX_OLD_AMBER
+    [OBJ_EVENT_GFX_GYM_SIGN / 2]                = 0x33, // OBJ_EVENT_GFX_SIGN
+    [OBJ_EVENT_GFX_TRAINER_TIPS / 2]            = 0x33, // OBJ_EVENT_GFX_CLIPBOARD
+    [OBJ_EVENT_GFX_METEORITE / 2]               = 0x33, // OBJ_EVENT_GFX_LAPRAS_DOLL
+    [OBJ_EVENT_GFX_SEAGALLOP / 2]               = 0x23, // OBJ_EVENT_GFX_SNORLAX
+    [OBJ_EVENT_GFX_SPEAROW / 2]                 = 0x22, // OBJ_EVENT_GFX_CUBONE
+    [OBJ_EVENT_GFX_POLIWRATH / 2]               = 0x22, // OBJ_EVENT_GFX_CLEFAIRY
+    [OBJ_EVENT_GFX_PIDGEOT / 2]                 = 0x22, // OBJ_EVENT_GFX_JIGGLYPUFF
+    [OBJ_EVENT_GFX_PIDGEY / 2]                  = 0x22, // OBJ_EVENT_GFX_CHANSEY
+    [OBJ_EVENT_GFX_OMANYTE / 2]                 = 0x22, // OBJ_EVENT_GFX_KANGASKHAN
+    [OBJ_EVENT_GFX_PIKACHU / 2]                 = 0x22, // OBJ_EVENT_GFX_PSYDUCK
+    [OBJ_EVENT_GFX_NIDORAN_F / 2]               = 0x22, // OBJ_EVENT_GFX_NIDORAN_M
+    [OBJ_EVENT_GFX_NIDORINO / 2]                = 0x22, // OBJ_EVENT_GFX_MEOWTH
+    [OBJ_EVENT_GFX_SEEL / 2]                    = 0x22, // OBJ_EVENT_GFX_VOLTORB
+    [OBJ_EVENT_GFX_SLOWPOKE / 2]                = 0x22, // OBJ_EVENT_GFX_SLOWBRO
+    [OBJ_EVENT_GFX_MACHOP / 2]                  = 0x22, // OBJ_EVENT_GFX_WIGGLYTUFF
+    [OBJ_EVENT_GFX_DODUO / 2]                   = 0x22, // OBJ_EVENT_GFX_FEAROW
+    [OBJ_EVENT_GFX_MACHOKE / 2]                 = 0x22, // OBJ_EVENT_GFX_LAPRAS
+    [OBJ_EVENT_GFX_ZAPDOS / 2]                  = 0x22, // OBJ_EVENT_GFX_MOLTRES
+    [OBJ_EVENT_GFX_ARTICUNO / 2]                = 0x22, // OBJ_EVENT_GFX_MEWTWO
+    [OBJ_EVENT_GFX_MEW / 2]                     = 0x22, // OBJ_EVENT_GFX_ENTEI
+    [OBJ_EVENT_GFX_SUICUNE / 2]                 = 0x22, // OBJ_EVENT_GFX_RAIKOU
+    [OBJ_EVENT_GFX_LUGIA / 2]                   = 0x22, // OBJ_EVENT_GFX_HO_OH
+    [OBJ_EVENT_GFX_CELEBI / 2]                  = 0x22, // OBJ_EVENT_GFX_KABUTO
+    [OBJ_EVENT_GFX_DEOXYS_D / 2]                = 0x22, // OBJ_EVENT_GFX_DEOXYS_A
+    [OBJ_EVENT_GFX_DEOXYS_N / 2]                = 0x32, // OBJ_EVENT_GFX_SS_ANNE
 };
 
 void DynamicPlaceholderTextUtil_Reset(void)
@@ -63,7 +135,7 @@ u8 GetColorFromTextColorTable(u16 graphicId)
     u32 test = graphicId >> 1;
     u32 shift = (graphicId & 1) << 2;
 
-    if (test > 0x4B)
+    if (test >= NELEMS(sTextColorTable))
         return 3;
     else
         return (sTextColorTable[graphicId >> 1] >> shift) & 0xF;
diff --git a/src/easy_chat.c b/src/easy_chat.c
index 1d2873fc2..657d178d7 100644
--- a/src/easy_chat.c
+++ b/src/easy_chat.c
@@ -1,33 +1,18 @@
 #include "global.h"
 #include "malloc.h"
-#include "bg.h"
 #include "data.h"
-#include "decompress.h"
-#include "dynamic_placeholder_text_util.h"
 #include "easy_chat.h"
 #include "event_data.h"
 #include "field_message_box.h"
-#include "field_weather.h"
-#include "gpu_regs.h"
-#include "graphics.h"
-#include "main.h"
 #include "mevent.h"
 #include "menu.h"
 #include "mail.h"
-#include "overworld.h"
-#include "palette.h"
 #include "pokedex.h"
 #include "random.h"
-#include "sound.h"
 #include "string_util.h"
 #include "strings.h"
-#include "task.h"
-#include "text_window.h"
-#include "window.h"
 #include "constants/easy_chat.h"
-#include "constants/object_events.h"
 #include "constants/flags.h"
-#include "constants/songs.h"
 #include "constants/species.h"
 
 struct Unk203A120
@@ -291,7 +276,7 @@ static u16 GetRandomWordFromAnyGroup(u16 groupId)
     return GetRandomWordFromGroup(groupId);
 }
 
-void Special_BufferEasyChatMessage(void)
+void ShowEasyChatMessage(void)
 {
     u16 *easyChatWords;
     int columns, rows;
diff --git a/src/easy_chat_2.c b/src/easy_chat_2.c
new file mode 100644
index 000000000..4b3c70b67
--- /dev/null
+++ b/src/easy_chat_2.c
@@ -0,0 +1,1363 @@
+#include "global.h"
+#include "gflib.h"
+#include "easy_chat.h"
+#include "event_data.h"
+#include "menu.h"
+#include "mevent.h"
+#include "overworld.h"
+#include "strings.h"
+#include "task.h"
+#include "constants/songs.h"
+
+#define EZCHAT_TASK_STATE        0
+#define EZCHAT_TASK_TYPE         1
+#define EZCHAT_TASK_WORDS        2
+#define EZCHAT_TASK_MAINCALLBACK 4
+#define EZCHAT_TASK_UNK06        6
+#define EZCHAT_TASK_SIZE         7
+
+struct EasyChatScreenTemplate
+{
+    u8 type;
+    u8 numColumns;
+    u8 numRows;
+    u8 frameId;
+    const u8 *titleText;
+    const u8 *instructionsText1;
+    const u8 *instructionsText2;
+    const u8 *confirmText1;
+    const u8 *confirmText2;
+};
+
+struct EasyChatScreen
+{
+    /*0x00*/ u8 type;
+    /*0x01*/ u8 templateId;
+    /*0x02*/ u8 numColumns;
+    /*0x03*/ u8 numRows;
+    /*0x04*/ u8 state;
+    /*0x05*/ s8 mainCursorColumn;
+    /*0x06*/ s8 mainCursorRow;
+    /*0x07*/ u8 numWords;
+    /*0x08*/ u8 stateBackup;
+    /*0x09*/ bool8 isAlphaMode;
+    /*0x0A*/ s8 selectGroupCursorX;
+    /*0x0B*/ s8 selectGroupCursorY;
+    /*0x0C*/ u8 selectGroupRowsAbove;
+    /*0x0D*/ u8 selectGroupNumRows;
+    /*0x0E*/ u8 selectWordRowsAbove;
+    /*0x0F*/ u8 selectWordNumRows;
+    /*0x10*/ s8 selectWordCursorX;
+    /*0x11*/ s8 selectWordCursorY;
+    /*0x14*/ u16 *words;
+    /*0x18*/ u16 ecWordBuffer[9];
+};
+
+static EWRAM_DATA struct EasyChatScreen * sEasyChatScreen = NULL;
+
+static void CB2_EasyChatScreen(void);
+static void Task_InitEasyChat(u8 taskId);
+static void Task_RunEasyChat(u8 taskId);
+static bool8 Task_InitEasyChatInternal(u8 taskId);
+static void DismantleEasyChat(MainCallback cb);
+static void CompareProfileResponseWithPassphrase(void);
+static void CompareQuestionnaireResponseWithPassphrase(void);
+static bool8 EasyChat_AllocateResources(u8 type, u16 *words);
+static void EasyChat_FreeResources(void);
+static u16 EasyChatScreen_HandleJoypad(void);
+static u16 HandleJoypad_SelectField(void);
+static u16 HandleJoypad_SelectFooter(void);
+static u16 HandleJoypad_SelectGroup(void);
+static u16 HandleJoypad_SelectWord(void);
+static u16 Cancel_HandleYesNoMenu(void);
+static u16 Confirm_HandleYesNoMenu(void);
+static u16 DelAll_HandleYesNoMenu(void);
+static u16 Cancel_CreateYesNoMenu(void);
+static u16 DelAll_CreateYesNoMenu(void);
+static u16 Confirm_CreateYesNoMenu(void);
+static u8 GetStateBackup(void);
+static int OpenSelectedGroup(void);
+static int BackOutFromGroupToFieldSelect(void);
+static int ToggleGroupAlphaMode(void);
+static int DeleteSelectedWord(void);
+static int PlaceSelectedWord(void);
+static void CommitECWords(void);
+static void DeleteAllECFields(void);
+static void SetEasyChatWordToField(u16 word);
+static bool8 HasECMessageChanged(void);
+static u16 SelectGroupCursorAction(u32 action);
+static int UpdateSelectGroupCursorPos_OutsideBlueBox_GroupMode(u32 action);
+static int UpdateSelectGroupCursorPos_OutsideBlueBox_AlphaMode(u32 action);
+static int UpdateSelectGroupCursorPos_InsideBlueBox(u32 action);
+static void GroupCursorMoveToBlueBox(void);
+static void GroupCursorWrapAroundLeft(void);
+static u16 SelectWordCursorAction(u32 action);
+static u16 GetSelectedFieldIndex(void);
+static u16 GetSelectedGroupIndex(void);
+static int GetSelectedLetter(void);
+static u16 GetSelectWordCursorPos(void);
+static u8 GetMaxGroupCursorXinAlphaMode(u8 unkB);
+static void MoveGroupCursorXToMaxCol(void);
+static void MoveWordCursorXToMaxCol(void);
+static bool8 GroupSelectCursorXPosTooFarRight(void);
+static bool8 WordSelectCursorXPosTooFarRight(void);
+static bool8 IsPhraseDifferentThanPlayerInput(const u16 *wordsToCompare, u8 numWords);
+static u8 GetEasyChatScreenTemplateId(u8 type);
+static bool32 IsEcWordBufferUninitialized(void);
+
+void DoEasyChatScreen(u8 type, u16 *words, MainCallback callback)
+{
+    u8 taskId;
+    ResetTasks();
+    taskId = CreateTask(Task_InitEasyChat, 0);
+    gTasks[taskId].data[EZCHAT_TASK_TYPE] = type;
+    SetWordTaskArg(taskId, EZCHAT_TASK_WORDS, (uintptr_t)words);
+    SetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK, (uintptr_t)callback);
+    SetMainCallback2(CB2_EasyChatScreen);
+}
+
+static void CB2_EasyChatScreen(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void VBlankCallback_EasyChatScreen(void)
+{
+    TransferPlttBuffer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+}
+
+static void SetEasyChatTaskFunc(u8 taskId, TaskFunc func)
+{
+    gTasks[taskId].func = func;
+    gTasks[taskId].data[EZCHAT_TASK_STATE] = 0;
+}
+
+static void Task_InitEasyChat(u8 taskId)
+{
+    if (!IsUpdateLinkStateCBActive())
+    {
+        while (Task_InitEasyChatInternal(taskId))
+            ;
+    }
+    else
+    {
+        if (Task_InitEasyChatInternal(taskId) == TRUE)
+            return;
+    }
+    SetEasyChatTaskFunc(taskId, Task_RunEasyChat);
+}
+
+static void Task_RunEasyChat(u8 taskId)
+{
+    u16 action;
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    switch (data[EZCHAT_TASK_STATE])
+    {
+    case 0:
+        SetVBlankCallback(VBlankCallback_EasyChatScreen);
+        BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+        BeginNormalPaletteFade(0xFFFFFFFF, -1, 16, 0, RGB_BLACK);
+        data[EZCHAT_TASK_STATE]++;
+        break;
+    case 1:
+        action = EasyChatScreen_HandleJoypad();
+        if (action == 23)
+        {
+            BeginNormalPaletteFade(0xFFFFFFFF, -1, 0, 16, RGB_BLACK);
+            data[EZCHAT_TASK_STATE] = 3;
+        }
+        else if (action != 0)
+        {
+            PlaySE(SE_SELECT);
+            EasyChatInterfaceCommand_Setup(action);
+            data[EZCHAT_TASK_STATE]++;
+        }
+        break;
+    case 2:
+        if (!EasyChatInterfaceCommand_Run())
+            data[EZCHAT_TASK_STATE] = 1;
+        break;
+    case 3:
+        if (!gPaletteFade.active)
+        {
+            if (data[EZCHAT_TASK_TYPE] == EASY_CHAT_TYPE_QUESTIONNAIRE)
+                CompareQuestionnaireResponseWithPassphrase();
+            if (data[EZCHAT_TASK_TYPE] == EASY_CHAT_TYPE_PROFILE)
+            {
+                FlagSet(FLAG_SYS_SET_TRAINER_CARD_PROFILE);
+                CompareProfileResponseWithPassphrase();
+            }
+            DismantleEasyChat((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+        }
+        break;
+    }
+}
+
+static bool8 Task_InitEasyChatInternal(u8 taskId)
+{
+    s16 *data;
+
+    data = gTasks[taskId].data;
+    switch (data[EZCHAT_TASK_STATE])
+    {
+    case 0:
+        SetVBlankCallback(NULL);
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        ResetPaletteFade();
+        break;
+    case 1:
+        if (!InitEasyChatSelection())
+        {
+            DismantleEasyChat((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+        }
+        break;
+    case 2:
+        if (!EasyChat_AllocateResources(data[EZCHAT_TASK_TYPE], (u16 *)GetWordTaskArg(taskId, EZCHAT_TASK_WORDS)))
+        {
+            DismantleEasyChat((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+        }
+        break;
+    case 3:
+        if (!InitEasyChatGraphicsWork())
+        {
+            DismantleEasyChat((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+        }
+        break;
+    case 4:
+        if (LoadEasyChatGraphics())
+        {
+            return TRUE;
+        }
+        break;
+    default:
+        return FALSE;
+    }
+    data[EZCHAT_TASK_STATE]++;
+    return TRUE;
+}
+
+static void DismantleEasyChat(MainCallback callback)
+{
+    DestroyEasyChatSelectionData();
+    EasyChat_FreeResources();
+    DestroyEasyChatGraphicsResources();
+    FreeAllWindowBuffers();
+    SetMainCallback2(callback);
+}
+
+void ShowEasyChatScreen(void)
+{
+    u16 *words;
+    switch (gSpecialVar_0x8004)
+    {
+    case EASY_CHAT_TYPE_PROFILE:
+        words = gSaveBlock1Ptr->easyChatProfile;
+        break;
+    case EASY_CHAT_TYPE_BATTLE_START:
+        words = gSaveBlock1Ptr->easyChatBattleStart;
+        break;
+    case EASY_CHAT_TYPE_BATTLE_WON:
+        words = gSaveBlock1Ptr->easyChatBattleWon;
+        break;
+    case EASY_CHAT_TYPE_BATTLE_LOST:
+        words = gSaveBlock1Ptr->easyChatBattleLost;
+        break;
+    case EASY_CHAT_TYPE_QUESTIONNAIRE:
+        words = GetMEventProfileECWordsMaybe();
+        break;
+    case EASY_CHAT_TYPE_MAIL:
+        words = gSaveBlock1Ptr->mail[gSpecialVar_0x8005].words;
+        break;
+    default:
+        return;
+    }
+    DoEasyChatScreen(gSpecialVar_0x8004, words, sub_80568C4);
+}
+
+static const u16 sECPhrase_MysteryEventIsExciting[] = {
+    EC_WORD_MYSTERY,
+    EC_WORD_EVENT,
+    EC_WORD_IS,
+    EC_WORD_EXCITING
+};
+
+static void CompareProfileResponseWithPassphrase(void)
+{
+    gSpecialVar_0x8004 = IsPhraseDifferentThanPlayerInput(sECPhrase_MysteryEventIsExciting, NELEMS(sECPhrase_MysteryEventIsExciting));
+}
+
+static const u16 sECPhrase_LinkTogetherWithAll[] = {
+    EC_WORD_LINK,
+    EC_WORD_TOGETHER,
+    EC_WORD_WITH,
+    EC_WORD_ALL
+};
+
+static void CompareQuestionnaireResponseWithPassphrase(void)
+{
+    gSpecialVar_0x8004 = IsPhraseDifferentThanPlayerInput(sECPhrase_LinkTogetherWithAll, NELEMS(sECPhrase_LinkTogetherWithAll));
+}
+
+static const struct EasyChatScreenTemplate sEasyChatScreenTemplates[] = {
+    {
+        .type = EASY_CHAT_TYPE_PROFILE,
+        .numColumns = 2,
+        .numRows = 2,
+        .frameId = 0,
+        .titleText =  gUnknown_8418A2B,
+        .instructionsText1 = gUnknown_84186D1,
+        .instructionsText2 = gUnknown_84186EF,
+        .confirmText1 = gUnknown_841880E,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_BATTLE_START,
+        .numColumns = 2,
+        .numRows = 3,
+        .frameId = 1,
+        .titleText =  gUnknown_8418A33,
+        .instructionsText1 = gUnknown_8418706,
+        .instructionsText2 = gUnknown_8418725,
+        .confirmText1 = gUnknown_841881B,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_BATTLE_WON,
+        .numColumns = 2,
+        .numRows = 3,
+        .frameId = 1,
+        .titleText =  gUnknown_8418A4A,
+        .instructionsText1 = gUnknown_8418706,
+        .instructionsText2 = gUnknown_8418725,
+        .confirmText1 = gUnknown_841883E,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_BATTLE_LOST,
+        .numColumns = 2,
+        .numRows = 3,
+        .frameId = 1,
+        .titleText =  gUnknown_8418A61,
+        .instructionsText1 = gUnknown_8418706,
+        .instructionsText2 = gUnknown_8418725,
+        .confirmText1 = gUnknown_841885F,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_MAIL,
+        .numColumns = 2,
+        .numRows = 5,
+        .frameId = 2,
+        .titleText =  NULL,
+        .instructionsText1 = gUnknown_8418780,
+        .instructionsText2 = gUnknown_841879E,
+        .confirmText1 = gUnknown_841888C,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_MAIL_NO_CONFIRM,
+        .numColumns = 2,
+        .numRows = 2,
+        .frameId = 0,
+        .instructionsText1 = gUnknown_8418780,
+        .instructionsText2 = gUnknown_841879E,
+    }, {
+        .type = EASY_CHAT_TYPE_BARD_SONG,
+        .numColumns = 2,
+        .numRows = 3,
+        .frameId = 1,
+        .titleText =  gUnknown_8418A77,
+        .instructionsText1 = gUnknown_84187B2,
+        .instructionsText2 = gUnknown_84187D1,
+        .confirmText1 = gUnknown_84188AC,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_INTERVIEW,
+        .numColumns = 2,
+        .numRows = 3,
+        .frameId = 1,
+        .titleText =  gUnknown_8418AA1,
+        .instructionsText1 = gUnknown_8418745,
+        .instructionsText2 = gUnknown_8418763,
+        .confirmText1 = gUnknown_8418881,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_TRENDY_PHRASE,
+        .numColumns = 2,
+        .numRows = 1,
+        .frameId = 3,
+        .titleText =  gUnknown_8418A87,
+        .instructionsText1 = gUnknown_84188B9,
+        .instructionsText2 = gUnknown_84188D6,
+        .confirmText1 = gUnknown_84188F0,
+        .confirmText2 = gUnknown_8418902
+    }, {
+        .type = EASY_CHAT_TYPE_QUESTIONNAIRE,
+        .numColumns = 2,
+        .numRows = 2,
+        .frameId = 0,
+        .titleText =  gUnknown_8418AB2,
+        .instructionsText1 = gUnknown_84186D1,
+        .instructionsText2 = gUnknown_84187EE,
+        .confirmText1 = gUnknown_8418881,
+        .confirmText2 = gUnknown_8418902
+    }
+};
+
+static bool8 EasyChat_AllocateResources(u8 type, u16 *words)
+{
+    u8 templateId;
+    int i;
+
+    sEasyChatScreen = malloc(sizeof(*sEasyChatScreen));
+    if (sEasyChatScreen == NULL)
+        return FALSE;
+
+    sEasyChatScreen->type = type;
+    sEasyChatScreen->words = words;
+    sEasyChatScreen->state = 0;
+    sEasyChatScreen->mainCursorColumn = 0;
+    sEasyChatScreen->mainCursorRow = 0;
+    sEasyChatScreen->isAlphaMode = FALSE;
+    templateId = GetEasyChatScreenTemplateId(type);
+
+    sEasyChatScreen->numColumns = sEasyChatScreenTemplates[templateId].numColumns;
+    sEasyChatScreen->numRows = sEasyChatScreenTemplates[templateId].numRows;
+    sEasyChatScreen->numWords = sEasyChatScreen->numColumns * sEasyChatScreen->numRows;
+    sEasyChatScreen->templateId = templateId;
+    if (sEasyChatScreen->numWords > 9)
+        sEasyChatScreen->numWords = 9;
+
+    CpuCopy16(words, sEasyChatScreen->ecWordBuffer, sEasyChatScreen->numWords * sizeof(u16));
+    sEasyChatScreen->selectGroupNumRows = (GetNumDisplayableGroups() - 1) / 2 + 1;
+    return TRUE;
+}
+
+static void EasyChat_FreeResources(void)
+{
+    if (sEasyChatScreen != NULL)
+        Free(sEasyChatScreen);
+}
+
+static u16 EasyChatScreen_HandleJoypad(void)
+{
+    switch (sEasyChatScreen->state)
+    {
+    case 0:
+        return HandleJoypad_SelectField();
+    case 1:
+        return HandleJoypad_SelectFooter();
+    case 2:
+        return HandleJoypad_SelectGroup();
+    case 3:
+        return HandleJoypad_SelectWord();
+    case 4:
+        return Cancel_HandleYesNoMenu();
+    case 5:
+        return DelAll_HandleYesNoMenu();
+    case 6:
+        return Confirm_HandleYesNoMenu();
+    }
+    return 0;
+}
+
+static u16 HandleJoypad_SelectField(void)
+{
+    do
+    {
+        if (JOY_NEW(A_BUTTON))
+        {
+            sEasyChatScreen->state = 2;
+            sEasyChatScreen->selectGroupCursorX = 0;
+            sEasyChatScreen->selectGroupCursorY = 0;
+            sEasyChatScreen->selectGroupRowsAbove = 0;
+            return 9;
+        }
+        else if (JOY_NEW(B_BUTTON))
+        {
+            return Cancel_CreateYesNoMenu();
+        }
+        else if (JOY_NEW(START_BUTTON))
+        {
+            return Confirm_CreateYesNoMenu();
+        }
+        else if (JOY_NEW(DPAD_UP))
+        {
+            sEasyChatScreen->mainCursorRow--;
+            break;
+        }
+        else if (JOY_NEW(DPAD_LEFT))
+        {
+            sEasyChatScreen->mainCursorColumn--;
+            break;
+        }
+        else if (JOY_NEW(DPAD_DOWN))
+        {
+            sEasyChatScreen->mainCursorRow++;
+            break;
+        }
+        else if (JOY_NEW(DPAD_RIGHT))
+        {
+            sEasyChatScreen->mainCursorColumn++;
+            break;
+        }
+
+        return 0;
+    } while (0);
+
+    if (sEasyChatScreen->mainCursorRow < 0)
+        sEasyChatScreen->mainCursorRow = sEasyChatScreenTemplates[sEasyChatScreen->templateId].numRows;
+
+    if (sEasyChatScreen->mainCursorRow > sEasyChatScreenTemplates[sEasyChatScreen->templateId].numRows)
+        sEasyChatScreen->mainCursorRow = 0;
+
+    if (sEasyChatScreen->mainCursorRow == sEasyChatScreenTemplates[sEasyChatScreen->templateId].numRows)
+    {
+        if (sEasyChatScreen->mainCursorColumn > 2)
+            sEasyChatScreen->mainCursorColumn = 2;
+
+        sEasyChatScreen->state = 1;
+        return 3;
+    }
+
+    if (sEasyChatScreen->mainCursorColumn < 0)
+        sEasyChatScreen->mainCursorColumn = sEasyChatScreenTemplates[sEasyChatScreen->templateId].numColumns - 1;
+
+    if (sEasyChatScreen->mainCursorColumn >= sEasyChatScreenTemplates[sEasyChatScreen->templateId].numColumns)
+        sEasyChatScreen->mainCursorColumn = 0;
+
+    if (GetEasyChatScreenFrameId() == 2 && sEasyChatScreen->mainCursorColumn == 1 && sEasyChatScreen->mainCursorRow == 4)
+        sEasyChatScreen->mainCursorColumn = 0;
+
+    return 2;
+}
+
+static u16 HandleJoypad_SelectFooter(void)
+{
+    do
+    {
+        if (JOY_NEW(A_BUTTON))
+        {
+            switch (sEasyChatScreen->mainCursorColumn)
+            {
+            case 0:
+                return DelAll_CreateYesNoMenu();
+            case 1:
+                return Cancel_CreateYesNoMenu();
+            case 2:
+                return Confirm_CreateYesNoMenu();
+            }
+        }
+
+        if (JOY_NEW(B_BUTTON))
+        {
+            return Cancel_CreateYesNoMenu();
+        }
+        else if (JOY_NEW(START_BUTTON))
+        {
+            return Confirm_CreateYesNoMenu();
+        }
+        else if (JOY_NEW(DPAD_UP))
+        {
+            sEasyChatScreen->mainCursorRow--;
+            break;
+        }
+        else if (JOY_NEW(DPAD_LEFT))
+        {
+            sEasyChatScreen->mainCursorColumn--;
+            break;
+        }
+        else if (JOY_NEW(DPAD_DOWN))
+        {
+            sEasyChatScreen->mainCursorRow = 0;
+            break;
+        }
+        else if (JOY_NEW(DPAD_RIGHT))
+        {
+            sEasyChatScreen->mainCursorColumn++;
+            break;
+        }
+
+        return 0;
+    } while (0);
+
+    if (sEasyChatScreen->mainCursorRow == sEasyChatScreenTemplates[sEasyChatScreen->templateId].numRows)
+    {
+        if (sEasyChatScreen->mainCursorColumn < 0)
+            sEasyChatScreen->mainCursorColumn = 2;
+
+        if (sEasyChatScreen->mainCursorColumn >= 3)
+            sEasyChatScreen->mainCursorColumn = 0;
+
+        return 3;
+    }
+
+    if (sEasyChatScreen->mainCursorColumn >= sEasyChatScreenTemplates[sEasyChatScreen->templateId].numColumns)
+        sEasyChatScreen->mainCursorColumn = sEasyChatScreenTemplates[sEasyChatScreen->templateId].numColumns - 1;
+
+    if (GetEasyChatScreenFrameId() == 2 && sEasyChatScreen->mainCursorColumn == 1 && sEasyChatScreen->mainCursorRow == 4)
+        sEasyChatScreen->mainCursorColumn = 0;
+
+    sEasyChatScreen->state = 0;
+    return 2;
+}
+
+static u16 HandleJoypad_SelectGroup(void)
+{
+    if (JOY_NEW(B_BUTTON))
+        return BackOutFromGroupToFieldSelect();
+
+    if (JOY_NEW(A_BUTTON))
+    {
+        if (sEasyChatScreen->selectGroupCursorX != -1)
+            return OpenSelectedGroup();
+
+        switch (sEasyChatScreen->selectGroupCursorY)
+        {
+        case 0:
+            return ToggleGroupAlphaMode();
+        case 1:
+            return DeleteSelectedWord();
+        case 2:
+            return BackOutFromGroupToFieldSelect();
+        }
+    }
+
+    if (JOY_NEW(SELECT_BUTTON))
+        return ToggleGroupAlphaMode();
+
+    if (JOY_REPT(DPAD_UP))
+        return SelectGroupCursorAction(2);
+
+    if (JOY_REPT(DPAD_DOWN))
+        return SelectGroupCursorAction(3);
+
+    if (JOY_REPT(DPAD_LEFT))
+        return SelectGroupCursorAction(1);
+
+    if (JOY_REPT(DPAD_RIGHT))
+        return SelectGroupCursorAction(0);
+
+    return 0;
+}
+
+static u16 HandleJoypad_SelectWord(void)
+{
+    if (JOY_NEW(B_BUTTON))
+    {
+        sEasyChatScreen->state = 2;
+        return 13;
+    }
+
+    if (JOY_NEW(A_BUTTON))
+        return PlaceSelectedWord();
+
+    if (JOY_NEW(START_BUTTON))
+        return SelectWordCursorAction(4);
+
+    if (JOY_NEW(SELECT_BUTTON))
+        return SelectWordCursorAction(5);
+
+    if (JOY_REPT(DPAD_UP))
+        return SelectWordCursorAction(2);
+
+    if (JOY_REPT(DPAD_DOWN))
+        return SelectWordCursorAction(3);
+
+    if (JOY_REPT(DPAD_LEFT))
+        return SelectWordCursorAction(1);
+
+    if (JOY_REPT(DPAD_RIGHT))
+        return SelectWordCursorAction(0);
+
+    return 0;
+}
+
+static u16 Cancel_HandleYesNoMenu(void)
+{
+    u8 var0;
+
+    switch (Menu_ProcessInputNoWrapClearOnChoose())
+    {
+    case MENU_B_PRESSED: // B Button
+    case 1: // No
+        sEasyChatScreen->state = GetStateBackup();
+        return 7;
+    case 0: // Yes
+        gSpecialVar_Result = 0;
+
+        return 23;
+    default:
+        return 0;
+    }
+}
+
+static u16 Confirm_HandleYesNoMenu(void)
+{
+    switch (Menu_ProcessInputNoWrapClearOnChoose())
+    {
+    case MENU_B_PRESSED: // B Button
+    case 1: // No
+        sEasyChatScreen->state = GetStateBackup();
+        return 7;
+    case 0: // Yes
+        gSpecialVar_Result = HasECMessageChanged();
+        CommitECWords();
+        return 23;
+    default:
+        return 0;
+    }
+}
+
+static u16 DelAll_HandleYesNoMenu(void)
+{
+    switch (Menu_ProcessInputNoWrapClearOnChoose())
+    {
+    case MENU_B_PRESSED: // B Button
+    case 1: // No
+        sEasyChatScreen->state = 1;
+        return 7;
+    case 0: // Yes
+        DeleteAllECFields();
+        sEasyChatScreen->state = 1;
+        return 8;
+    default:
+        return 0;
+    }
+}
+
+static u16 Cancel_CreateYesNoMenu(void)
+{
+    sEasyChatScreen->stateBackup = sEasyChatScreen->state;
+    sEasyChatScreen->state = 4;
+    return 5;
+}
+
+static u16 DelAll_CreateYesNoMenu(void)
+{
+    sEasyChatScreen->stateBackup = sEasyChatScreen->state;
+    sEasyChatScreen->state = 5;
+    return 4;
+}
+
+static u16 Confirm_CreateYesNoMenu(void)
+{
+    sEasyChatScreen->stateBackup = sEasyChatScreen->state;
+    if (IsEcWordBufferUninitialized())
+    {
+        sEasyChatScreen->state = 4;
+        return 5;
+    }
+    else
+    {
+        sEasyChatScreen->state = 6;
+        return 6;
+    }
+}
+
+static u8 GetStateBackup(void)
+{
+    return sEasyChatScreen->stateBackup;
+}
+
+static int OpenSelectedGroup(void)
+{
+    u16 numDisplayedWords;
+
+    if (!sEasyChatScreen->isAlphaMode)
+    {
+        u8 groupId = GetSelectedGroupByIndex(GetSelectedGroupIndex());
+        GetUnlockedECWords(FALSE, groupId);
+    }
+    else
+    {
+        GetUnlockedECWords(TRUE, GetSelectedLetter());
+    }
+
+    numDisplayedWords = GetNumDisplayedWords();
+    if (numDisplayedWords == 0)
+        return 0;
+
+    sEasyChatScreen->selectWordNumRows = (numDisplayedWords - 1) / 2;
+    sEasyChatScreen->selectWordRowsAbove = 0;
+    sEasyChatScreen->selectWordCursorX = 0;
+    sEasyChatScreen->selectWordCursorY = 0;
+    sEasyChatScreen->state = 3;
+    return 11;
+}
+
+static int BackOutFromGroupToFieldSelect(void)
+{
+    sEasyChatScreen->state = 0;
+    return 10;
+}
+
+static int ToggleGroupAlphaMode(void)
+{
+    sEasyChatScreen->selectGroupCursorX = 0;
+    sEasyChatScreen->selectGroupCursorY = 0;
+    sEasyChatScreen->selectGroupRowsAbove = 0;
+    if (!sEasyChatScreen->isAlphaMode)
+        sEasyChatScreen->isAlphaMode = TRUE;
+    else
+        sEasyChatScreen->isAlphaMode = FALSE;
+
+    return 22;
+}
+
+static int DeleteSelectedWord(void)
+{
+    SetEasyChatWordToField(0xFFFF);
+    return 1;
+}
+
+static int PlaceSelectedWord(void)
+{
+    u16 easyChatWord = GetDisplayedWordByIndex(GetSelectWordCursorPos());
+    SetEasyChatWordToField(easyChatWord);
+    sEasyChatScreen->state = 0;
+    return 12;
+}
+
+static void CommitECWords(void)
+{
+    u16 i;
+    for (i = 0; i < sEasyChatScreen->numWords; i++)
+        sEasyChatScreen->words[i] = sEasyChatScreen->ecWordBuffer[i];
+}
+
+static void DeleteAllECFields(void)
+{
+    u16 i;
+    for (i = 0; i < sEasyChatScreen->numWords; i++)
+        sEasyChatScreen->ecWordBuffer[i] = 0xFFFF;
+}
+
+static void SetEasyChatWordToField(u16 easyChatWord)
+{
+    u16 index = GetSelectedFieldIndex();
+    sEasyChatScreen->ecWordBuffer[index] = easyChatWord;
+}
+
+static bool8 HasECMessageChanged(void)
+{
+    u16 i;
+    for (i = 0; i < sEasyChatScreen->numWords; i++)
+    {
+        if (sEasyChatScreen->ecWordBuffer[i] != sEasyChatScreen->words[i])
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static u16 SelectGroupCursorAction(u32 action)
+{
+    if (sEasyChatScreen->selectGroupCursorX != -1)
+    {
+        if (!sEasyChatScreen->isAlphaMode)
+            return UpdateSelectGroupCursorPos_OutsideBlueBox_GroupMode(action);
+        else
+            return UpdateSelectGroupCursorPos_OutsideBlueBox_AlphaMode(action);
+    }
+    else
+    {
+        return UpdateSelectGroupCursorPos_InsideBlueBox(action);
+    }
+}
+
+static int UpdateSelectGroupCursorPos_OutsideBlueBox_GroupMode(u32 arg0)
+{
+    switch (arg0)
+    {
+    case 2:
+        if (sEasyChatScreen->selectGroupCursorY != -sEasyChatScreen->selectGroupRowsAbove)
+        {
+            if (sEasyChatScreen->selectGroupCursorY)
+            {
+                sEasyChatScreen->selectGroupCursorY--;
+                return 14;
+            }
+            else
+            {
+                sEasyChatScreen->selectGroupRowsAbove--;
+                return 16;
+            }
+        }
+        break;
+    case 3:
+        if (sEasyChatScreen->selectGroupCursorY + sEasyChatScreen->selectGroupRowsAbove < sEasyChatScreen->selectGroupNumRows - 1)
+        {
+            int var0;
+            if (sEasyChatScreen->selectGroupCursorY < 3)
+            {
+                sEasyChatScreen->selectGroupCursorY++;
+                var0 = 14;
+            }
+            else
+            {
+                sEasyChatScreen->selectGroupRowsAbove++;
+                var0 = 15;
+            }
+
+            MoveGroupCursorXToMaxCol();
+            return var0;
+        }
+        break;
+    case 1:
+        if (sEasyChatScreen->selectGroupCursorX)
+            sEasyChatScreen->selectGroupCursorX--;
+        else
+            GroupCursorMoveToBlueBox();
+
+        return 14;
+    case 0:
+        if (sEasyChatScreen->selectGroupCursorX < 1)
+        {
+            sEasyChatScreen->selectGroupCursorX++;
+            if (GroupSelectCursorXPosTooFarRight())
+                GroupCursorMoveToBlueBox();
+        }
+        else
+        {
+            GroupCursorMoveToBlueBox();
+        }
+        return 14;
+    }
+
+    return 0;
+}
+
+static int UpdateSelectGroupCursorPos_OutsideBlueBox_AlphaMode(u32 arg0)
+{
+    switch (arg0)
+    {
+    case 2:
+        if (sEasyChatScreen->selectGroupCursorY > 0)
+            sEasyChatScreen->selectGroupCursorY--;
+        else
+            sEasyChatScreen->selectGroupCursorY = 3;
+
+        MoveGroupCursorXToMaxCol();
+        return 14;
+    case 3:
+        if (sEasyChatScreen->selectGroupCursorY < 3)
+            sEasyChatScreen->selectGroupCursorY++;
+        else
+            sEasyChatScreen->selectGroupCursorY = 0;
+
+        MoveGroupCursorXToMaxCol();
+        return 14;
+    case 0:
+        sEasyChatScreen->selectGroupCursorX++;
+        if (GroupSelectCursorXPosTooFarRight())
+            GroupCursorMoveToBlueBox();
+
+        return 14;
+    case 1:
+        sEasyChatScreen->selectGroupCursorX--;
+        if (sEasyChatScreen->selectGroupCursorX < 0)
+            GroupCursorMoveToBlueBox();
+
+        return 14;
+    }
+
+    return 0;
+}
+
+static int UpdateSelectGroupCursorPos_InsideBlueBox(u32 arg0)
+{
+    switch (arg0)
+    {
+    case 2:
+        if (sEasyChatScreen->selectGroupCursorY)
+            sEasyChatScreen->selectGroupCursorY--;
+        else
+            sEasyChatScreen->selectGroupCursorY = 2;
+
+        return 14;
+    case 3:
+        if (sEasyChatScreen->selectGroupCursorY < 2)
+            sEasyChatScreen->selectGroupCursorY++;
+        else
+            sEasyChatScreen->selectGroupCursorY = 0;
+
+        return 14;
+    case 1:
+        sEasyChatScreen->selectGroupCursorY++;
+        GroupCursorWrapAroundLeft();
+        return 14;
+    case 0:
+        sEasyChatScreen->selectGroupCursorX = 0;
+        sEasyChatScreen->selectGroupCursorY++;
+        return 14;
+    }
+
+    return 0;
+}
+
+static void GroupCursorMoveToBlueBox(void)
+{
+    sEasyChatScreen->selectGroupCursorX = 0xFF;
+    if (sEasyChatScreen->selectGroupCursorY)
+        sEasyChatScreen->selectGroupCursorY--;
+}
+
+static void GroupCursorWrapAroundLeft(void)
+{
+    if (!sEasyChatScreen->isAlphaMode)
+    {
+        sEasyChatScreen->selectGroupCursorX = 1;
+        MoveGroupCursorXToMaxCol();
+    }
+    else
+    {
+        sEasyChatScreen->selectGroupCursorX = GetMaxGroupCursorXinAlphaMode(sEasyChatScreen->selectGroupCursorY);
+    }
+}
+
+static u16 SelectWordCursorAction(u32 arg0)
+{
+    u16 result;
+    switch (arg0)
+    {
+    case 2: // up
+        if (sEasyChatScreen->selectWordCursorY + sEasyChatScreen->selectWordRowsAbove > 0)
+        {
+            if (sEasyChatScreen->selectWordCursorY > 0)
+            {
+                sEasyChatScreen->selectWordCursorY--;
+                result = 17;
+            }
+            else
+            {
+                sEasyChatScreen->selectWordRowsAbove--;
+                result = 18;
+            }
+
+            MoveWordCursorXToMaxCol();
+            return result;
+        }
+        break;
+    case 3: // down
+        if (sEasyChatScreen->selectWordCursorY + sEasyChatScreen->selectWordRowsAbove < sEasyChatScreen->selectWordNumRows)
+        {
+            if (sEasyChatScreen->selectWordCursorY < 3)
+            {
+                sEasyChatScreen->selectWordCursorY++;
+                result = 17;
+            }
+            else
+            {
+                sEasyChatScreen->selectWordRowsAbove++;
+                result = 19;
+            }
+
+            MoveWordCursorXToMaxCol();
+            return result;
+        }
+        break;
+    case 1: // left
+        if (sEasyChatScreen->selectWordCursorX > 0)
+            sEasyChatScreen->selectWordCursorX--;
+        else
+            sEasyChatScreen->selectWordCursorX = 1;
+
+        MoveWordCursorXToMaxCol();
+        return 17;
+    case 0: // right
+        if (sEasyChatScreen->selectWordCursorX < 1)
+        {
+            sEasyChatScreen->selectWordCursorX++;
+            if (WordSelectCursorXPosTooFarRight())
+                sEasyChatScreen->selectWordCursorX = 0;
+        }
+        else
+        {
+            sEasyChatScreen->selectWordCursorX = 0;
+        }
+        return 17;
+    case 4: // pg up
+        if (sEasyChatScreen->selectWordRowsAbove)
+        {
+            if (sEasyChatScreen->selectWordRowsAbove > 3)
+                sEasyChatScreen->selectWordRowsAbove -= 4;
+            else
+                sEasyChatScreen->selectWordRowsAbove = 0;
+
+            return 20;
+        }
+        break;
+    case 5: // pg dn
+        if (sEasyChatScreen->selectWordRowsAbove <= sEasyChatScreen->selectWordNumRows - 4)
+        {
+            sEasyChatScreen->selectWordRowsAbove += 4;
+            if (sEasyChatScreen->selectWordRowsAbove > sEasyChatScreen->selectWordNumRows - 3)
+                sEasyChatScreen->selectWordRowsAbove = sEasyChatScreen->selectWordNumRows + -3u;
+
+            MoveWordCursorXToMaxCol();
+            return 21;
+        }
+        break;
+    }
+
+    return 0;
+}
+
+static u16 GetSelectedFieldIndex(void)
+{
+    return (sEasyChatScreen->mainCursorRow * sEasyChatScreen->numColumns) + sEasyChatScreen->mainCursorColumn;
+}
+
+static u16 GetSelectedGroupIndex(void)
+{
+    return 2 * (sEasyChatScreen->selectGroupCursorY + sEasyChatScreen->selectGroupRowsAbove) + sEasyChatScreen->selectGroupCursorX;
+}
+
+static const u8 sAlphabetLayout[][7] = {
+    { 1,  2,  3,  4,  5,  6},
+    { 7,  8,  9, 10, 11, 12},
+    {13, 14, 15, 16, 17, 18, 19},
+    {20, 21, 22, 23, 24, 25, 26}
+};
+
+static int GetSelectedLetter(void)
+{
+    int col = sEasyChatScreen->selectGroupCursorX < NELEMS(*sAlphabetLayout) ? sEasyChatScreen->selectGroupCursorX : 0;
+    int row = sEasyChatScreen->selectGroupCursorY < NELEMS(sAlphabetLayout) ? sEasyChatScreen->selectGroupCursorY : 0;
+    return sAlphabetLayout[row][col];
+}
+
+static u16 GetSelectWordCursorPos(void)
+{
+    return 2 * (sEasyChatScreen->selectWordCursorY + sEasyChatScreen->selectWordRowsAbove)  + sEasyChatScreen->selectWordCursorX;
+}
+
+static u8 GetMaxGroupCursorXinAlphaMode(u8 arg0)
+{
+    switch (arg0)
+    {
+    case 0:
+    default:
+        return 6;
+    case 1:
+        return 5;
+    }
+}
+
+static void MoveGroupCursorXToMaxCol(void)
+{
+    while (GroupSelectCursorXPosTooFarRight())
+    {
+        if (sEasyChatScreen->selectGroupCursorX)
+            sEasyChatScreen->selectGroupCursorX--;
+        else
+            break;
+    }
+}
+
+static void MoveWordCursorXToMaxCol(void)
+{
+    while (WordSelectCursorXPosTooFarRight())
+    {
+        if (sEasyChatScreen->selectWordCursorX)
+            sEasyChatScreen->selectWordCursorX--;
+        else
+            break;
+    }
+}
+
+static bool8 GroupSelectCursorXPosTooFarRight(void)
+{
+    if (!sEasyChatScreen->isAlphaMode)
+        return GetSelectedGroupIndex() >= GetNumDisplayableGroups() ? TRUE : FALSE;
+    else
+        return sEasyChatScreen->selectGroupCursorX > GetMaxGroupCursorXinAlphaMode(sEasyChatScreen->selectGroupCursorY) ? TRUE : FALSE;
+}
+
+static bool8 WordSelectCursorXPosTooFarRight(void)
+{
+    return GetSelectWordCursorPos() >= GetNumDisplayedWords() ? TRUE : FALSE;
+}
+
+u8 GetEasyChatScreenFrameId(void)
+{
+    return sEasyChatScreenTemplates[sEasyChatScreen->templateId].frameId;
+}
+
+const u8 *GetTitleText(void)
+{
+    return sEasyChatScreenTemplates[sEasyChatScreen->templateId].titleText;
+}
+
+u16 *GetEasyChatWordBuffer(void)
+{
+    return sEasyChatScreen->ecWordBuffer;
+}
+
+u8 GetNumRows(void)
+{
+    return sEasyChatScreen->numRows;
+}
+
+u8 GetNumColumns(void)
+{
+    return sEasyChatScreen->numColumns;
+}
+
+u8 GetMainCursorColumn(void)
+{
+    return sEasyChatScreen->mainCursorColumn;
+}
+
+u8 GetMainCursorRow(void)
+{
+    return sEasyChatScreen->mainCursorRow;
+}
+
+void GetEasyChatInstructionsText(const u8 **str1, const u8 **str2)
+{
+    *str1 = sEasyChatScreenTemplates[sEasyChatScreen->templateId].instructionsText1;
+    *str2 = sEasyChatScreenTemplates[sEasyChatScreen->templateId].instructionsText2;
+}
+
+void GetEasyChatConfirmText(const u8 **str1, const u8 **str2)
+{
+    *str1 = sEasyChatScreenTemplates[sEasyChatScreen->templateId].confirmText1;
+    *str2 = sEasyChatScreenTemplates[sEasyChatScreen->templateId].confirmText2;
+}
+
+void GetEasyChatConfirmCancelText(const u8 **str1, const u8 **str2)
+{
+    switch (sEasyChatScreen->type)
+    {
+    case EASY_CHAT_TYPE_MAIL:
+        *str1 = gUnknown_84189EE;
+        *str2 = NULL;
+        break;
+    default:
+        *str1 = gUnknown_84189E0;
+        *str2 = NULL;
+        break;
+    }
+
+}
+
+void GetEasyChatConfirmDeletionText(const u8 **str1, const u8 **str2)
+{
+    *str1 = gUnknown_8418937;
+    *str2 = gUnknown_8418956;
+}
+
+void GetECSelectGroupCursorCoords(u8 *Xp, u8 *Yp)
+{
+    *Xp = sEasyChatScreen->selectGroupCursorX;
+    *Yp = sEasyChatScreen->selectGroupCursorY;
+}
+
+bool8 IsEasyChatAlphaMode(void)
+{
+    return sEasyChatScreen->isAlphaMode;
+}
+
+u8 GetECSelectGroupRowsAbove(void)
+{
+    return sEasyChatScreen->selectGroupRowsAbove;
+}
+
+void GetECSelectWordCursorCoords(s8 *Xp, s8 *Yp)
+{
+    *Xp = sEasyChatScreen->selectWordCursorX;
+    *Yp = sEasyChatScreen->selectWordCursorY;
+}
+
+u8 GetECSelectWordRowsAbove(void)
+{
+    return sEasyChatScreen->selectWordRowsAbove;
+}
+
+u8 GetECSelectWordNumRows(void)
+{
+    return sEasyChatScreen->selectWordNumRows;
+}
+
+u8 unref_sub_80FFE60(void)
+{
+    return 0;
+}
+
+bool32 ShouldDrawECUpArrow(void)
+{
+    switch (sEasyChatScreen->state)
+    {
+    case 2:
+        if (!sEasyChatScreen->isAlphaMode && sEasyChatScreen->selectGroupRowsAbove != 0)
+            return TRUE;
+        break;
+    case 3:
+        if (sEasyChatScreen->selectWordRowsAbove != 0)
+            return TRUE;
+        break;
+    }
+
+    return FALSE;
+}
+
+bool32 ShouldDrawECDownArrow(void)
+{
+    switch (sEasyChatScreen->state)
+    {
+    case 2:
+        if (!sEasyChatScreen->isAlphaMode && sEasyChatScreen->selectGroupRowsAbove + 4 <= sEasyChatScreen->selectGroupNumRows - 1)
+            return TRUE;
+        break;
+    case 3:
+        if (sEasyChatScreen->selectWordRowsAbove + 4 <= sEasyChatScreen->selectWordNumRows)
+            return TRUE;
+        break;
+    }
+
+    return FALSE;
+}
+
+static bool8 IsPhraseDifferentThanPlayerInput(const u16 *phrase, u8 phraseLength)
+{
+    u8 i;
+
+    for (i = 0; i < phraseLength; i++)
+    {
+        if (phrase[i] != sEasyChatScreen->ecWordBuffer[i])
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static u8 GetEasyChatScreenTemplateId(u8 type)
+{
+    u32 i;
+
+    for (i = 0; i < NELEMS(sEasyChatScreenTemplates); i++)
+    {
+        if (sEasyChatScreenTemplates[i].type == type)
+            return i;
+    }
+
+    return 0;
+}
+
+static bool32 IsEcWordBufferUninitialized(void)
+{
+    int i;
+
+    for (i = 0; i < sEasyChatScreen->numWords; i++)
+    {
+        if (sEasyChatScreen->ecWordBuffer[i] != 0xFFFF)
+            return FALSE;
+    }
+
+    return TRUE;
+}
diff --git a/src/easy_chat_3.c b/src/easy_chat_3.c
new file mode 100644
index 000000000..1501762bc
--- /dev/null
+++ b/src/easy_chat_3.c
@@ -0,0 +1,2298 @@
+#include "global.h"
+#include "gflib.h"
+#include "keyboard_text.h"
+#include "decompress.h"
+#include "easy_chat.h"
+#include "graphics.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "strings.h"
+#include "text_window.h"
+
+struct ECWork
+{
+    u16 state;
+    u16 windowId;
+    u16 id;
+    u8 frameAnimIdx;
+    u8 frameAnimTarget;
+    s8 frameAnimDelta;
+    u8 modeIconState;
+    u8 ecPrintBuffer[0xC1];
+    u8 ecPaddedWordBuffer[0x200];
+    u16 bg2ScrollRow;
+    int tgtBgY;
+    int deltaBgY;
+    struct Sprite * selectDestFieldCursorSprite;
+    struct Sprite * rectCursorSpriteRight;
+    struct Sprite * rectCursorSpriteLeft;
+    struct Sprite * selectWordCursorSprite;
+    struct Sprite * selectGroupHelpSprite;
+    struct Sprite * modeIconsSprite;
+    struct Sprite * upTriangleCursorSprite;
+    struct Sprite * downTriangleCursorSprite;
+    struct Sprite * startPgUpButtonSprite;
+    struct Sprite * selectPgDnButtonSprite;
+    u16 bg1TilemapBuffer[BG_SCREEN_SIZE / 2];
+    u16 bg3TilemapBuffer[BG_SCREEN_SIZE / 2];
+};
+
+struct EasyChatPhraseFrameDimensions
+{
+    u8 left;
+    u8 top;
+    u8 width;
+    u8 height;
+};
+
+static EWRAM_DATA struct ECWork * sEasyChatGraphicsResources = NULL;
+
+static bool8 ECInterfaceCmd_01(void);
+static bool8 ECInterfaceCmd_02(void);
+static bool8 ECInterfaceCmd_03(void);
+static bool8 ECInterfaceCmd_05(void);
+static bool8 ECInterfaceCmd_06(void);
+static bool8 ECInterfaceCmd_04(void);
+static bool8 ECInterfaceCmd_07(void);
+static bool8 ECInterfaceCmd_08(void);
+static bool8 ECInterfaceCmd_09(void);
+static bool8 ECInterfaceCmd_10(void);
+static bool8 ECInterfaceCmd_22(void);
+static bool8 ECInterfaceCmd_14(void);
+static bool8 ECInterfaceCmd_15(void);
+static bool8 ECInterfaceCmd_16(void);
+static bool8 ECInterfaceCmd_11(void);
+static bool8 ECInterfaceCmd_12(void);
+static bool8 ECInterfaceCmd_13(void);
+static bool8 ECInterfaceCmd_17(void);
+static bool8 ECInterfaceCmd_19(void);
+static bool8 ECInterfaceCmd_18(void);
+static bool8 ECInterfaceCmd_21(void);
+static bool8 ECInterfaceCmd_20(void);
+static bool8 InitEasyChatGraphicsWork_Internal(void);
+static void SetGpuRegsForEasyChatInit(void);
+static void LoadEasyChatPals(void);
+static void PrintTitleText(void);
+static void EC_AddTextPrinterParameterized2(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 speed, u8 bg, u8 fg, u8 shadow);
+static void PrintECInstructionsText(void);
+static void PrintECInterfaceTextById(u8 a0);
+static void EC_CreateYesNoMenuWithInitialCursorPos(u8 initialCursorPos);
+static void CreatePhraseFrameWindow(void);
+static void PrintECFields(void);
+static void DrawECFrameInTilemapBuffer(u16 *buffer);
+static void PutWin2TilemapAndCopyToVram(void);
+static void PrintECMenuById(u32 a0);
+static void PrintECGroupOrAlphaMenu(void);
+static void PrintECGroupsMenu(void);
+static void PrintEasyChatKeyboardText(void);
+static void PrintECWordsMenu(void);
+static void UpdateWin2PrintWordsScrollDown(void);
+static void UpdateWin2PrintWordsScrollUp(void);
+static void UpdateWin2PrintWordsScrollPageDown(void);
+static void UpdateWin2PrintWordsScrollPageUp(void);
+static void PrintECRowsWin2(u8 row, u8 remrow);
+static void ClearECRowsWin2(u8 row, u8 remrow);
+static void ClearWin2AndCopyToVram(void);
+static void StartWin2FrameAnim(int a0);
+static bool8 AnimateFrameResize(void);
+static void RedrawFrameByIndex(u8 a0);
+static void RedrawFrameByRect(int left, int top, int width, int height);
+static void InitBg2Scroll(void);
+static void ScheduleBg2VerticalScroll(s16 direction, u8 speed);
+static bool8 AnimateBg2VerticalScroll(void);
+static int GetBg2ScrollRow(void);
+static void SetRegWin0Coords(u8 left, u8 top, u8 right, u8 bottom);
+static void LoadSpriteGfx(void);
+static void CreateSelectDestFieldCursorSprite(void);
+static void SpriteCB_BounceCursor(struct Sprite * sprite);
+static void SetSelectDestFieldCursorSpritePosAndResetAnim(u8 x, u8 y);
+static void FreezeSelectDestFieldCursorSprite(void);
+static void UnfreezeSelectDestFieldCursorSprite(void);
+static void CreateRedRectangularCursorSpritePair(void);
+static void DestroyRedRectangularCursor(void);
+static void EC_MoveCursor(void);
+static void MoveCursor_Group(s8 a0, s8 a1);
+static void MoveCursor_Alpha(s8 a0, s8 a1);
+static void CreateSelectWordCursorSprite(void);
+static void SpriteCB_SelectWordCursorSprite(struct Sprite * sprite);
+static void SetSelectWordCursorSpritePos(void);
+static void SetSelectWordCursorSpritePosExplicit(u8 x, u8 y);
+static void DestroySelectWordCursorSprite(void);
+static void CreateSelectGroupHelpSprite(void);
+static bool8 AnimateSeletGroupModeAndHelpSpriteEnter(void);
+static void StartModeIconHidingAnimation(void);
+static bool8 RunModeIconHidingAnimation(void);
+static void ShrinkModeIconsSprite(void);
+static void ShowModeIconsSprite(void);
+static bool8 ModeIconsSpriteAnimIsEnded(void);
+static void CreateVerticalScrollArrowSprites(void);
+static void UpdateVerticalScrollArrowVisibility(void);
+static void HideVerticalScrollArrowSprites(void);
+static void UpdateVerticalScrollArrowSpriteXPos(int a0);
+static void CreateStartSelectButtonsSprites(void);
+static void UpdateStartSelectButtonSpriteVisibility(void);
+static void HideStartSelectButtonSprites(void);
+static void CreateFooterWindow(void);
+
+static const u16 gUnknown_843F3B8[] = INCBIN_U16("graphics/link_rfu/unk_843F3F8.gbapal");
+static const u16 gUnknown_843F3D8[] = INCBIN_U16("graphics/link_rfu/unk_8E9BD28.gbapal");
+static const u16 sRightTriangleCursor_Tiles[] = INCBIN_U16("graphics/link_rfu/unk_843F3F8.4bpp");
+static const u16 sUpTriangleCursor_Tiles[] = INCBIN_U16("graphics/link_rfu/unk_843F418.4bpp");
+static const u16 sStartSelectButtons_Tiles[] = INCBIN_U16("graphics/link_rfu/unk_843F518.4bpp");
+static const u16 gUnknown_843F618[] = INCBIN_U16("graphics/link_rfu/unk_843F638.gbapal");
+static const u32 gUnknown_843F638[] = INCBIN_U32("graphics/link_rfu/unk_843F638.4bpp.lz");
+static const u16 gUnknown_843F76C[] = INCBIN_U16("graphics/link_rfu/unk_843F76C.gbapal");
+static const u16 gUnknown_843F78C[] = INCBIN_U16("graphics/link_rfu/unk_843F78C.gbapal");
+static const u32 gUnknown_843F7AC[] = INCBIN_U32("graphics/link_rfu/unk_843F7AC.4bpp.lz");
+
+static const u16 gUnknown_843F874[] = {
+    RGB( 0,  0,  0),
+    RGB( 0,  0,  0),
+    RGB( 7, 25, 31),
+    RGB(21, 21, 29)
+};
+
+static const u16 gUnknown_843F87C[] = {
+    RGB( 0,  0,  0),
+    RGB(31, 31, 31),
+    RGB(12, 12, 12),
+    RGB(27, 26, 27),
+    RGB( 8, 17,  9)
+};
+
+static const struct EasyChatPhraseFrameDimensions sPhraseFrameDimensions[] = {
+    {
+        .left = 0x03,
+        .top = 0x04,
+        .width = 0x18,
+        .height = 0x04
+    }, {
+        .left = 0x01,
+        .top = 0x04,
+        .width = 0x1b,
+        .height = 0x04
+    }, {
+        .left = 0x03,
+        .top = 0x00,
+        .width = 0x18,
+        .height = 0x0a
+    }, {
+        .left = 0x06,
+        .top = 0x06,
+        .width = 0x12,
+        .height = 0x04
+    }, {
+        .left = 0x10,
+        .top = 0x04,
+        .width = 0x09,
+        .height = 0x02
+    }, {
+        .left = 0x0e,
+        .top = 0x04,
+        .width = 0x12,
+        .height = 0x04
+    }
+};
+
+static const struct BgTemplate sEasyChatBgTemplates[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 28,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0,
+    }, {
+        .bg = 1,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0,
+    }, {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0x80,
+    }, {
+        .bg = 3,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0,
+    }
+};
+
+static const struct WindowTemplate sEasyChatWindowTemplates[] = {
+    {
+        .bg = 1,
+        .tilemapLeft = 7,
+        .tilemapTop = 0,
+        .width = 16,
+        .height = 2,
+        .paletteNum = 10,
+        .baseBlock = 0x10,
+    },
+    {
+        .bg = 0,
+        .tilemapLeft = 4,
+        .tilemapTop = 15,
+        .width = 22,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 0xA,
+    },
+    {
+        .bg = 2,
+        .tilemapLeft = 1,
+        .tilemapTop = 0,
+        .width = 28,
+        .height = 32,
+        .paletteNum = 3,
+        .baseBlock = 0,
+    },
+    DUMMY_WIN_TEMPLATE,
+};
+
+static const struct WindowTemplate sEasyChatYesNoWindowTemplate = {
+    .bg = 0,
+    .tilemapLeft = 22,
+    .tilemapTop = 9,
+    .width = 5,
+    .height = 4,
+    .paletteNum = 15,
+    .baseBlock = 0x062
+};
+
+static const u8 gUnknown_843F8D8[] = _("{UNDERSCORE}");
+static const u8 sText_Clear17[] = _("{CLEAR 17}");
+
+static const u8 *const sEasyChatKeyboardText[] = {
+    gUnknown_847A8D8,
+    gUnknown_847A8FA,
+    gUnknown_847A913,
+    gUnknown_847A934
+};
+
+static const struct SpriteSheet sEasyChatSpriteSheets[] = {
+    {sRightTriangleCursor_Tiles, 0x0020, 0},
+    {sUpTriangleCursor_Tiles, 0x0100, 2},
+    {sStartSelectButtons_Tiles, 0x0100, 3},
+    {}
+};
+
+static const struct SpritePalette sEasyChatSpritePalettes[] = {
+    {gUnknown_843F3B8, 0},
+    {gUnknown_843F3D8, 1},
+    {gUnknown_8E99F24, 2},
+    {gUnknown_843F618, 3},
+    {}
+};
+
+static const struct CompressedSpriteSheet sEasyChatCompressedSpriteSheets[] = {
+    {gUnknown_843F638, 0x0800, 5},
+    {gEasyChatRedRectangularCursor_Tiles, 0x1000, 1},
+    {gEasyChatSelectGroupHelp_Tiles, 0x0800, 6},
+    {gEasyChatModeIcons_Tiles, 0x1000, 4}
+};
+
+static const u8 sECDisplay_AlphaModeXCoords[] = {
+     0,
+    12,
+    24,
+    56,
+    68,
+    80,
+    92
+};
+
+static const struct OamData sOamData_RightTriangleCursor = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .mosaic = FALSE,
+    .shape = SPRITE_SHAPE(8x8),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(8x8),
+    .tileNum = 0x000,
+    .priority = 3,
+    .paletteNum = 0
+};
+
+static const struct SpriteTemplate sSpriteTemplate_RightTriangleCursor = {
+    .tileTag = 0,
+    .paletteTag = 0,
+    .oam = &sOamData_RightTriangleCursor,
+    .anims = gDummySpriteAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_BounceCursor
+};
+
+static const struct OamData sOamData_RedRectangularCursor = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .mosaic = FALSE,
+    .shape = SPRITE_SHAPE(64x32),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x32),
+    .tileNum = 0x000,
+    .priority = 1,
+    .paletteNum = 0
+};
+
+static const union AnimCmd sAnimCmd_RectCursor_Wide[] = {
+    ANIMCMD_FRAME(0x00, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_RectCursor_Norm[] = {
+    ANIMCMD_FRAME(0x20, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_RectCursor_NormTaller[] = {
+    ANIMCMD_FRAME(0x40, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_RectCursor_Narrow[] = {
+    ANIMCMD_FRAME(0x60, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sAnimTable_RedRectangularCursor[] = {
+    sAnimCmd_RectCursor_Wide,
+    sAnimCmd_RectCursor_Norm,
+    sAnimCmd_RectCursor_NormTaller,
+    sAnimCmd_RectCursor_Narrow
+};
+
+static const struct SpriteTemplate sSpriteTemplate_RedRectangularCursor = {
+    .tileTag = 1,
+    .paletteTag = 1,
+    .oam = &sOamData_RedRectangularCursor,
+    .anims = sAnimTable_RedRectangularCursor,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_BounceCursor
+};
+
+static const struct OamData sOamData_EasyChatModeIcons = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .mosaic = FALSE,
+    .shape = SPRITE_SHAPE(64x32),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x32),
+    .tileNum = 0x000,
+    .priority = 1,
+    .paletteNum = 0
+};
+
+static const union AnimCmd sAnim_EasyChatModeIcon_Hidden[] = {
+    ANIMCMD_FRAME(0x60, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_EasyChatModeIcon_ToGroupMode[] = {
+    ANIMCMD_FRAME(0x40, 4),
+    ANIMCMD_FRAME(0x20, 4),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_EasyChatModeIcon_ToAlphaMode[] = {
+    ANIMCMD_FRAME(0x40, 4),
+    ANIMCMD_FRAME(0x00, 4),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_EasyChatModeIcon_ToHidden[] = {
+    ANIMCMD_FRAME(0x40, 4),
+    ANIMCMD_FRAME(0x60, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_EasyChatModeIcon_HoldSmall[] = {
+    ANIMCMD_FRAME(0x40, 4),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sAnimTable_EasyChatModeIcons[] = {
+    sAnim_EasyChatModeIcon_Hidden,
+    sAnim_EasyChatModeIcon_ToGroupMode,
+    sAnim_EasyChatModeIcon_ToAlphaMode,
+    sAnim_EasyChatModeIcon_ToHidden,
+    sAnim_EasyChatModeIcon_HoldSmall
+};
+
+static const struct SpriteTemplate sSpriteTemplate_EasyChatModeIcons = {
+    .tileTag = 4,
+    .paletteTag = 2,
+    .oam = &sOamData_EasyChatModeIcons,
+    .anims = sAnimTable_EasyChatModeIcons,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct OamData sOamData_SelectGroupHelp = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0x000,
+    .priority = 3,
+    .paletteNum = 0
+};
+
+static const struct SpriteTemplate sSpriteTemplate_SelectGroupHelp = {
+    .tileTag = 6,
+    .paletteTag = 2,
+    .oam = &sOamData_SelectGroupHelp,
+    .anims = gDummySpriteAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct OamData gUnknown_843FA58 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x8),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(32x8),
+    .tileNum = 0x000,
+    .priority = 1,
+    .paletteNum = 0
+};
+
+static const struct OamData sOamData_UpTriangleCursor = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0x000,
+    .priority = 1,
+    .paletteNum = 0
+};
+
+static const union AnimCmd gUnknown_843FA68[] = {
+    ANIMCMD_FRAME(0, 0),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd gUnknown_843FA70[] = {
+    ANIMCMD_FRAME(4, 0),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd *const gUnknown_843FA78[] = {
+    gUnknown_843FA68,
+    gUnknown_843FA70,
+};
+
+static const struct SpriteTemplate sSpriteTemplate_StartSelectButtons = {
+    .tileTag = 3,
+    .paletteTag = 2,
+    .oam = &gUnknown_843FA58,
+    .anims = gUnknown_843FA78,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct SpriteTemplate sSpriteTemplate_UpTriangleCursor = {
+    .tileTag = 2,
+    .paletteTag = 2,
+    .oam = &sOamData_UpTriangleCursor,
+    .anims = gUnknown_843FA78,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+bool8 InitEasyChatGraphicsWork(void)
+{
+    if (!InitEasyChatGraphicsWork_Internal())
+        return FALSE;
+    else
+        return TRUE;
+}
+
+bool8 LoadEasyChatGraphics(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, sEasyChatBgTemplates, NELEMS(sEasyChatBgTemplates));
+        SetBgTilemapBuffer(3, sEasyChatGraphicsResources->bg3TilemapBuffer);
+        SetBgTilemapBuffer(1, sEasyChatGraphicsResources->bg1TilemapBuffer);
+        InitWindows(sEasyChatWindowTemplates);
+        DeactivateAllTextPrinters();
+        LoadEasyChatPals();
+        SetGpuRegsForEasyChatInit();
+        CpuFastFill(0, (void *)VRAM + 0x1000000, 0x400);
+        break;
+    case 1:
+        DecompressAndLoadBgGfxUsingHeap(3, gEasyChatWindow_Gfx, 0, 0, 0);
+        CopyToBgTilemapBuffer(3, gEasyChatWindow_Tilemap, 0, 0);
+        CreatePhraseFrameWindow();
+        CreateFooterWindow();
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 2:
+        DrawECFrameInTilemapBuffer(sEasyChatGraphicsResources->bg1TilemapBuffer);
+        DecompressAndLoadBgGfxUsingHeap(1, gUnknown_843F7AC, 0, 0, 0);
+        CopyBgTilemapBufferToVram(1);
+        break;
+    case 3:
+        PrintTitleText();
+        PrintECInstructionsText();
+        PrintECFields();
+        PutWin2TilemapAndCopyToVram();
+        break;
+    case 4:
+        LoadSpriteGfx();
+        CreateSelectDestFieldCursorSprite();
+        break;
+    case 5:
+        if (IsDma3ManagerBusyWithBgCopy())
+        {
+            return TRUE;
+        }
+        else
+        {
+            SetRegWin0Coords(0, 0, 0, 0);
+            SetGpuReg(REG_OFFSET_WININ, WIN_RANGE(0, 63));
+            SetGpuReg(REG_OFFSET_WINOUT, WIN_RANGE(0, 59));
+            ShowBg(3);
+            ShowBg(1);
+            ShowBg(2);
+            ShowBg(0);
+            CreateVerticalScrollArrowSprites();
+            CreateStartSelectButtonsSprites();
+        }
+        break;
+    default:
+        return FALSE;
+    }
+
+    sEasyChatGraphicsResources->state++;
+    return TRUE;
+}
+
+void DestroyEasyChatGraphicsResources(void)
+{
+    if (sEasyChatGraphicsResources)
+        Free(sEasyChatGraphicsResources);
+}
+
+void EasyChatInterfaceCommand_Setup(u16 id)
+{
+    sEasyChatGraphicsResources->id = id;
+    sEasyChatGraphicsResources->state = 0;
+    EasyChatInterfaceCommand_Run();
+}
+
+bool8 EasyChatInterfaceCommand_Run(void)
+{
+    switch (sEasyChatGraphicsResources->id)
+    {
+    case 0:  return FALSE;
+    case 1:  return ECInterfaceCmd_01();
+    case 2:  return ECInterfaceCmd_02();
+    case 3:  return ECInterfaceCmd_03();
+    case 4:  return ECInterfaceCmd_04();
+    case 5:  return ECInterfaceCmd_05();
+    case 6:  return ECInterfaceCmd_06();
+    case 7:  return ECInterfaceCmd_07();
+    case 8:  return ECInterfaceCmd_08();
+    case 9:  return ECInterfaceCmd_09();
+    case 10: return ECInterfaceCmd_10();
+    case 11: return ECInterfaceCmd_11();
+    case 12: return ECInterfaceCmd_12();
+    case 13: return ECInterfaceCmd_13();
+    case 14: return ECInterfaceCmd_14();
+    case 15: return ECInterfaceCmd_15();
+    case 16: return ECInterfaceCmd_16();
+    case 17: return ECInterfaceCmd_17();
+    case 18: return ECInterfaceCmd_18();
+    case 19: return ECInterfaceCmd_19();
+    case 20: return ECInterfaceCmd_20();
+    case 21: return ECInterfaceCmd_21();
+    case 22: return ECInterfaceCmd_22();
+    default: return FALSE;
+    }
+}
+
+static bool8 ECInterfaceCmd_01(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        PrintECFields();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_02(void)
+{
+    u8 i;
+    u16 *ecWordBuffer;
+    u16 *ecWord;
+    u8 frameId;
+    u8 cursorColumn, cursorRow, numColumns;
+    s16 var1;
+    int stringWidth;
+    int trueStringWidth;
+    int var2;
+    u8 str[64];
+
+    ecWordBuffer = GetEasyChatWordBuffer();
+    frameId = GetEasyChatScreenFrameId();
+    cursorColumn = GetMainCursorColumn();
+    cursorRow = GetMainCursorRow();
+    numColumns = GetNumColumns();
+    ecWord = &ecWordBuffer[cursorRow * numColumns];
+    var1 = 8 * sPhraseFrameDimensions[frameId].left + 13;
+    for (i = 0; i < cursorColumn; i++)
+    {
+        if (*ecWord == 0xFFFF)
+        {
+            stringWidth = GetStringWidth(1, gUnknown_843F8D8, 0) * 7;
+        }
+        else
+        {
+            CopyEasyChatWord(str, *ecWord);
+            stringWidth = GetStringWidth(1, str, 0);
+        }
+
+        trueStringWidth = stringWidth + 17;
+        var1 += trueStringWidth;
+        ecWord++;
+    }
+
+    var2 = 8 * (sPhraseFrameDimensions[frameId].top + cursorRow * 2 + 1) + 1;
+    SetSelectDestFieldCursorSpritePosAndResetAnim(var1, var2);
+    return FALSE;
+}
+
+static bool8 ECInterfaceCmd_03(void)
+{
+    u8 xOffset;
+    switch (GetMainCursorColumn())
+    {
+    case 0:
+        xOffset = 28;
+        break;
+    case 1:
+        xOffset = 115;
+        break;
+    case 2:
+        xOffset = 191;
+        break;
+    default:
+        return FALSE;
+    }
+    SetSelectDestFieldCursorSpritePosAndResetAnim(xOffset, 97);
+    return FALSE;
+}
+
+static bool8 ECInterfaceCmd_05(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        FreezeSelectDestFieldCursorSprite();
+        PrintECInterfaceTextById(2);
+        EC_CreateYesNoMenuWithInitialCursorPos(1);
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_06(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        FreezeSelectDestFieldCursorSprite();
+        PrintECInterfaceTextById(3);
+        EC_CreateYesNoMenuWithInitialCursorPos(0);
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_04(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        FreezeSelectDestFieldCursorSprite();
+        PrintECInterfaceTextById(1);
+        EC_CreateYesNoMenuWithInitialCursorPos(1);
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_07(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UnfreezeSelectDestFieldCursorSprite();
+        PrintECInterfaceTextById(0);
+        ShowBg(0);
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_08(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UnfreezeSelectDestFieldCursorSprite();
+        PrintECInterfaceTextById(0);
+        PrintECFields();
+        sEasyChatGraphicsResources->state++;
+        // Fall through
+    case 1:
+        return IsDma3ManagerBusyWithBgCopy();
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_09(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        FreezeSelectDestFieldCursorSprite();
+        HideBg(0);
+        SetRegWin0Coords(0, 0, 0, 0);
+        PrintECGroupOrAlphaMenu();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            StartWin2FrameAnim(0);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy() && !AnimateFrameResize())
+            sEasyChatGraphicsResources->state++;
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            CreateSelectGroupHelpSprite();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 4:
+        if (!AnimateSeletGroupModeAndHelpSpriteEnter())
+        {
+            CreateRedRectangularCursorSpritePair();
+            UpdateVerticalScrollArrowSpriteXPos(0);
+            UpdateVerticalScrollArrowVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    default:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_10(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        DestroyRedRectangularCursor();
+        StartModeIconHidingAnimation();
+        HideVerticalScrollArrowSprites();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (RunModeIconHidingAnimation() == TRUE)
+            break;
+
+        StartWin2FrameAnim(1);
+        sEasyChatGraphicsResources->state++;
+        // Fall through
+    case 2:
+        if (!AnimateFrameResize())
+            sEasyChatGraphicsResources->state++;
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            UnfreezeSelectDestFieldCursorSprite();
+            ShowBg(0);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 4:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_22(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        DestroyRedRectangularCursor();
+        HideVerticalScrollArrowSprites();
+        ShrinkModeIconsSprite();
+        StartWin2FrameAnim(5);
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!AnimateFrameResize() && !ModeIconsSpriteAnimIsEnded())
+        {
+            PrintECGroupOrAlphaMenu();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            StartWin2FrameAnim(6);
+            ShowModeIconsSprite();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 3:
+        if (!AnimateFrameResize() && !ModeIconsSpriteAnimIsEnded())
+        {
+            UpdateVerticalScrollArrowVisibility();
+            CreateRedRectangularCursorSpritePair();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 4:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_14(void)
+{
+    EC_MoveCursor();
+    return FALSE;
+}
+
+static bool8 ECInterfaceCmd_15(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        ScheduleBg2VerticalScroll(1, 2);
+        sEasyChatGraphicsResources->state++;
+        // Fall through
+    case 1:
+        if (!AnimateBg2VerticalScroll())
+        {
+            EC_MoveCursor();
+            UpdateVerticalScrollArrowVisibility();
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_16(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        ScheduleBg2VerticalScroll(-1, 2);
+        sEasyChatGraphicsResources->state++;
+        // Fall through
+    case 1:
+        if (!AnimateBg2VerticalScroll())
+        {
+            UpdateVerticalScrollArrowVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 2:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_11(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        DestroyRedRectangularCursor();
+        StartModeIconHidingAnimation();
+        HideVerticalScrollArrowSprites();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!RunModeIconHidingAnimation())
+        {
+            ClearWin2AndCopyToVram();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            StartWin2FrameAnim(2);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 3:
+        if (!AnimateFrameResize())
+        {
+            PrintECMenuById(2);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 4:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            CreateSelectWordCursorSprite();
+            UpdateVerticalScrollArrowSpriteXPos(1);
+            UpdateVerticalScrollArrowVisibility();
+            UpdateStartSelectButtonSpriteVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 5:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_12(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        PrintECFields();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        DestroySelectWordCursorSprite();
+        HideVerticalScrollArrowSprites();
+        HideStartSelectButtonSprites();
+        ClearWin2AndCopyToVram();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            StartWin2FrameAnim(3);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 3:
+        if (!AnimateFrameResize())
+        {
+            ShowBg(0);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 4:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            UnfreezeSelectDestFieldCursorSprite();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 5:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_13(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        DestroySelectWordCursorSprite();
+        HideVerticalScrollArrowSprites();
+        HideStartSelectButtonSprites();
+        ClearWin2AndCopyToVram();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            StartWin2FrameAnim(4);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!AnimateFrameResize())
+        {
+            PrintECGroupOrAlphaMenu();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            CreateSelectGroupHelpSprite();
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 4:
+        if (!AnimateSeletGroupModeAndHelpSpriteEnter())
+        {
+            CreateRedRectangularCursorSpritePair();
+            UpdateVerticalScrollArrowSpriteXPos(0);
+            UpdateVerticalScrollArrowVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_17(void)
+{
+    SetSelectWordCursorSpritePos();
+    return FALSE;
+}
+
+static bool8 ECInterfaceCmd_19(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UpdateWin2PrintWordsScrollDown();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ScheduleBg2VerticalScroll(1, 2);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!AnimateBg2VerticalScroll())
+        {
+            SetSelectWordCursorSpritePos();
+            UpdateVerticalScrollArrowVisibility();
+            UpdateStartSelectButtonSpriteVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_18(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UpdateWin2PrintWordsScrollUp();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ScheduleBg2VerticalScroll(-1, 2);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!AnimateBg2VerticalScroll())
+        {
+            UpdateVerticalScrollArrowVisibility();
+            UpdateStartSelectButtonSpriteVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_21(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UpdateWin2PrintWordsScrollPageDown();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            s16 direction = GetECSelectWordRowsAbove() - GetBg2ScrollRow();
+            ScheduleBg2VerticalScroll(direction, 4);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!AnimateBg2VerticalScroll())
+        {
+            SetSelectWordCursorSpritePos();
+            UpdateVerticalScrollArrowVisibility();
+            UpdateStartSelectButtonSpriteVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 ECInterfaceCmd_20(void)
+{
+    switch (sEasyChatGraphicsResources->state)
+    {
+    case 0:
+        UpdateWin2PrintWordsScrollPageUp();
+        sEasyChatGraphicsResources->state++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            s16 direction = GetECSelectWordRowsAbove() - GetBg2ScrollRow();
+            ScheduleBg2VerticalScroll(direction, 4);
+            sEasyChatGraphicsResources->state++;
+        }
+        break;
+    case 2:
+        if (!AnimateBg2VerticalScroll())
+        {
+            UpdateVerticalScrollArrowVisibility();
+            UpdateStartSelectButtonSpriteVisibility();
+            sEasyChatGraphicsResources->state++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 InitEasyChatGraphicsWork_Internal(void)
+{
+    sEasyChatGraphicsResources = Alloc(sizeof(*sEasyChatGraphicsResources));
+    if (sEasyChatGraphicsResources == NULL)
+        return FALSE;
+
+    sEasyChatGraphicsResources->state = 0;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite = NULL;
+    sEasyChatGraphicsResources->rectCursorSpriteRight = NULL;
+    sEasyChatGraphicsResources->rectCursorSpriteLeft = NULL;
+    sEasyChatGraphicsResources->selectWordCursorSprite = NULL;
+    sEasyChatGraphicsResources->selectGroupHelpSprite = NULL;
+    sEasyChatGraphicsResources->modeIconsSprite = NULL;
+    sEasyChatGraphicsResources->upTriangleCursorSprite = NULL;
+    sEasyChatGraphicsResources->downTriangleCursorSprite = NULL;
+    sEasyChatGraphicsResources->startPgUpButtonSprite = NULL;
+    sEasyChatGraphicsResources->selectPgDnButtonSprite = NULL;
+    return TRUE;
+}
+
+static void SetGpuRegsForEasyChatInit(void)
+{
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON);
+}
+
+static void LoadEasyChatPals(void)
+{
+    ResetPaletteFade();
+    LoadPalette(gEasyChatMode_Pal, 0, 32);
+    LoadPalette(gUnknown_843F76C,  1 * 16, 32);
+    LoadPalette(gUnknown_843F78C,  4 * 16, 32);
+    LoadPalette(gUnknown_843F874, 10 * 16, 8);
+    LoadPalette(gUnknown_843F87C, 11 * 16, 10);
+    LoadPalette(gUnknown_843F87C, 15 * 16, 10);
+    LoadPalette(gUnknown_843F87C,  3 * 16, 10);
+}
+
+static void PrintTitleText(void)
+{
+    int xOffset;
+    const u8 *titleText = GetTitleText();
+    if (titleText == NULL)
+        return;
+
+    xOffset = (128 - GetStringWidth(1, titleText, 0)) / 2u;
+    FillWindowPixelBuffer(0, PIXEL_FILL(0));
+    EC_AddTextPrinterParameterized2(0, 1, titleText, xOffset, 0, TEXT_SPEED_FF, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY);
+    PutWindowTilemap(0);
+    CopyWindowToVram(0, 3);
+}
+
+static void EC_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16))
+{
+    if (fontId == 1) y += 2;
+    AddTextPrinterParameterized(windowId, fontId, str, x, y, speed, callback);
+}
+
+static void EC_AddTextPrinterParameterized2(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, u8 bg, u8 fg, u8 shadow)
+{
+    u8 color[3];
+    if (fontId == 1) y += 2;
+    color[0] = bg;
+    color[1] = fg;
+    color[2] = shadow;
+    AddTextPrinterParameterized3(windowId, fontId, x, y, color, speed, str);
+}
+
+static void PrintECInstructionsText(void)
+{
+    FillBgTilemapBufferRect(0, 0, 0, 0, 32, 20, 17);
+    TextWindow_SetUserSelectedFrame(1, 1, 0xE0);
+    DrawTextBorderOuter(1, 1, 14);
+    PrintECInterfaceTextById(0);
+    PutWindowTilemap(1);
+    CopyBgTilemapBufferToVram(0);
+}
+
+static void PrintECInterfaceTextById(u8 direction)
+{
+    const u8 *text2 = NULL;
+    const u8 *text1 = NULL;
+    switch (direction)
+    {
+    case 0:
+        GetEasyChatInstructionsText(&text1, &text2);
+        break;
+    case 2:
+        GetEasyChatConfirmCancelText(&text1, &text2);
+        break;
+    case 3:
+        GetEasyChatConfirmText(&text1, &text2);
+        break;
+    case 1:
+        GetEasyChatConfirmDeletionText(&text1, &text2);
+        break;
+    }
+
+    FillWindowPixelBuffer(1, PIXEL_FILL(1));
+    if (text1)
+        EC_AddTextPrinterParameterized(1, 1, text1, 0, 0, TEXT_SPEED_FF, NULL);
+
+    if (text2)
+        EC_AddTextPrinterParameterized(1, 1, text2, 0, 16, TEXT_SPEED_FF, NULL);
+
+    CopyWindowToVram(1, 3);
+}
+
+static void EC_CreateYesNoMenuWithInitialCursorPos(u8 initialCursorPos)
+{
+    CreateYesNoMenu(&sEasyChatYesNoWindowTemplate, 1, 0, 2, 0x001, 14, initialCursorPos);
+}
+
+static void CreatePhraseFrameWindow(void)
+{
+    u8 frameId;
+    struct WindowTemplate template;
+
+    frameId = GetEasyChatScreenFrameId();
+    template.bg = 3;
+    template.tilemapLeft = sPhraseFrameDimensions[frameId].left;
+    template.tilemapTop = sPhraseFrameDimensions[frameId].top;
+    template.width = sPhraseFrameDimensions[frameId].width;
+    template.height = sPhraseFrameDimensions[frameId].height;
+    template.paletteNum = 11;
+    template.baseBlock = 0x060;
+    sEasyChatGraphicsResources->windowId = AddWindow(&template);
+    PutWindowTilemap(sEasyChatGraphicsResources->windowId);
+}
+
+static void PrintECFields(void)
+{
+    u16 *ecWord;
+    u8 numColumns, numRows;
+    u8 *str;
+    u8 frameId;
+    int i, j, k;
+
+    ecWord = GetEasyChatWordBuffer();
+    numColumns = GetNumColumns();
+    numRows = GetNumRows();
+    frameId = GetEasyChatScreenFrameId();
+    FillWindowPixelBuffer(sEasyChatGraphicsResources->windowId, PIXEL_FILL(1));
+    for (i = 0; i < numRows; i++)
+    {
+        str = sEasyChatGraphicsResources->ecPrintBuffer;
+        str[0] = EOS;
+        str = StringAppend(str, sText_Clear17);
+        for (j = 0; j < numColumns; j++)
+        {
+            if (*ecWord != 0xFFFF)
+            {
+                str = CopyEasyChatWord(str, *ecWord);
+                ecWord++;
+            }
+            else
+            {
+                str = WriteColorChangeControlCode(str, 0, TEXT_COLOR_RED);
+                ecWord++;
+                for (k = 0; k < 7; k++)
+                {
+                    *str++ = CHAR_EXTRA_EMOJI;
+                    *str++ = 9;
+                }
+
+                str = WriteColorChangeControlCode(str, 0, TEXT_COLOR_DARK_GREY);
+            }
+
+            str = StringAppend(str, sText_Clear17);
+            if (frameId == 2)
+            {
+                if (j == 0 && i == 4)
+                    break;
+            }
+        }
+
+        *str = EOS;
+        EC_AddTextPrinterParameterized(sEasyChatGraphicsResources->windowId, 1, sEasyChatGraphicsResources->ecPrintBuffer, 0, i * 16, TEXT_SPEED_FF, NULL);
+    }
+
+    CopyWindowToVram(sEasyChatGraphicsResources->windowId, 3);
+}
+
+static void DrawECFrameInTilemapBuffer(u16 *tilemap)
+{
+    u8 frameId;
+    int right, bottom;
+    int x, y;
+
+    frameId = GetEasyChatScreenFrameId();
+    CpuFastFill(0, tilemap, BG_SCREEN_SIZE);
+    if (frameId == 2)
+    {
+        right = sPhraseFrameDimensions[frameId].left + sPhraseFrameDimensions[frameId].width;
+        bottom = sPhraseFrameDimensions[frameId].top + sPhraseFrameDimensions[frameId].height;
+        for (y = sPhraseFrameDimensions[frameId].top; y < bottom; y++)
+        {
+            x = sPhraseFrameDimensions[frameId].left - 1;
+            tilemap[y * 32 + x] = 0x1005;
+            x++;
+            for (; x < right; x++)
+                tilemap[y * 32 + x] = 0x1000;
+
+            tilemap[y* 32 + x] = 0x1007;
+        }
+    }
+    else
+    {
+        y = sPhraseFrameDimensions[frameId].top - 1;
+        x = sPhraseFrameDimensions[frameId].left - 1;
+        right = sPhraseFrameDimensions[frameId].left + sPhraseFrameDimensions[frameId].width;
+        bottom = sPhraseFrameDimensions[frameId].top + sPhraseFrameDimensions[frameId].height;
+        tilemap[y * 32 + x] = 0x1001;
+        x++;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x1002;
+
+        tilemap[y * 32 + x] = 0x1003;
+        y++;
+        for (; y < bottom; y++)
+        {
+            x = sPhraseFrameDimensions[frameId].left - 1;
+            tilemap[y * 32 + x] = 0x1005;
+            x++;
+            for (; x < right; x++)
+                tilemap[y * 32 + x] = 0x1000;
+
+            tilemap[y* 32 + x] = 0x1007;
+        }
+
+        x = sPhraseFrameDimensions[frameId].left - 1;
+        tilemap[y * 32 + x] = 0x1009;
+        x++;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x100A;
+
+        tilemap[y * 32 + x] = 0x100B;
+    }
+}
+
+static void PutWin2TilemapAndCopyToVram(void)
+{
+    PutWindowTilemap(2);
+    CopyBgTilemapBufferToVram(2);
+}
+
+static void PrintECMenuById(u32 id)
+{
+    InitBg2Scroll();
+    FillWindowPixelBuffer(2, PIXEL_FILL(1));
+    switch (id)
+    {
+    case 0:
+        PrintECGroupsMenu();
+        break;
+    case 1:
+        PrintEasyChatKeyboardText();
+        break;
+    case 2:
+        PrintECWordsMenu();
+        break;
+    }
+
+    CopyWindowToVram(2, 2);
+}
+
+static void PrintECGroupOrAlphaMenu(void)
+{
+    if (!IsEasyChatAlphaMode())
+        PrintECMenuById(0);
+    else
+        PrintECMenuById(1);
+}
+
+static void PrintECGroupsMenu(void)
+{
+    int i;
+    int x, y;
+
+    i = 0;
+    y = 96;
+    while (1)
+    {
+        for (x = 0; x < 2; x++)
+        {
+            u8 groupId = GetSelectedGroupByIndex(i++);
+            if (groupId == EC_NUM_GROUPS)
+            {
+                ScheduleBg2VerticalScroll(GetECSelectGroupRowsAbove(), 0);
+                return;
+            }
+
+            EC_AddTextPrinterParameterized(2, 1, GetEasyChatWordGroupName(groupId), x * 84 + 10, y, TEXT_SPEED_FF, NULL);
+        }
+
+        y += 16;
+    }
+}
+
+static void PrintEasyChatKeyboardText(void)
+{
+    u32 i;
+
+    for (i = 0; i < NELEMS(sEasyChatKeyboardText); i++)
+        EC_AddTextPrinterParameterized(2, 1, sEasyChatKeyboardText[i], 10, 96 + i * 16, TEXT_SPEED_FF, NULL);
+}
+
+static void PrintECWordsMenu(void)
+{
+    PrintECRowsWin2(0, 4);
+}
+
+static void UpdateWin2PrintWordsScrollDown(void)
+{
+    u8 rowsAbove = GetECSelectWordRowsAbove() + 3;
+    ClearECRowsWin2(rowsAbove, 1);
+    PrintECRowsWin2(rowsAbove, 1);
+}
+
+static void UpdateWin2PrintWordsScrollUp(void)
+{
+    u8 rowsAbove = GetECSelectWordRowsAbove();
+    ClearECRowsWin2(rowsAbove, 1);
+    PrintECRowsWin2(rowsAbove, 1);
+}
+
+static void UpdateWin2PrintWordsScrollPageDown(void)
+{
+    u8 row = GetECSelectWordRowsAbove();
+    u8 maxrow = row + 4;
+    u8 numrowsplus1 = GetECSelectWordNumRows() + 1;
+    if (maxrow > numrowsplus1)
+        maxrow = numrowsplus1;
+
+    if (row < maxrow)
+    {
+        u8 remrow = maxrow - row;
+        ClearECRowsWin2(row, remrow);
+        PrintECRowsWin2(row, remrow);
+    }
+}
+
+static void UpdateWin2PrintWordsScrollPageUp(void)
+{
+    u8 row = GetECSelectWordRowsAbove();
+    u8 maxrow = GetBg2ScrollRow();
+    if (row < maxrow)
+    {
+        u8 remrow = maxrow - row;
+        ClearECRowsWin2(row, remrow);
+        PrintECRowsWin2(row, remrow);
+    }
+}
+
+static void PrintECRowsWin2(u8 row, u8 remrow)
+{
+    int i, j;
+    u16 easyChatWord;
+    u8 *str;
+    int y;
+    u8 y_;
+    int ecWordIdx;
+
+    ecWordIdx = row * 2;
+    y = (row * 16 + 96) & 0xFF;
+
+    for (i = 0; i < remrow; i++)
+    {
+        for (j = 0; j < 2; j++)
+        {
+            // FIXME: Dumb trick needed to match
+            y_ = y << 18 >> 18;
+            easyChatWord = GetDisplayedWordByIndex(ecWordIdx++);
+            if (easyChatWord != 0xFFFF)
+            {
+
+                CopyEasyChatWordPadded(sEasyChatGraphicsResources->ecPaddedWordBuffer, easyChatWord, 0);
+
+                EC_AddTextPrinterParameterized(2, 1, sEasyChatGraphicsResources->ecPaddedWordBuffer, (j * 13 + 3) * 8, y_, TEXT_SPEED_FF, NULL);
+            }
+        }
+        y += 16;
+
+    }
+
+    CopyWindowToVram(2, 2);
+}
+
+static void ClearECRowsWin2(u8 row, u8 remrow)
+{
+    int y;
+    int totalHeight;
+    int heightWrappedAround;
+    int heightToBottom;
+
+    y = (row * 16 + 96) & 0xFF;
+    heightToBottom = remrow * 16;
+    totalHeight = y + heightToBottom;
+    if (totalHeight > 255)
+    {
+        heightWrappedAround = totalHeight - 256;
+        heightToBottom = 256 - y;
+    }
+    else
+    {
+        heightWrappedAround = 0;
+    }
+
+    FillWindowPixelRect(2, PIXEL_FILL(1), 0, y, 224, heightToBottom);
+    if (heightWrappedAround)
+        FillWindowPixelRect(2, PIXEL_FILL(1), 0, 0, 224, heightWrappedAround);
+}
+
+static void ClearWin2AndCopyToVram(void)
+{
+    FillWindowPixelBuffer(2, PIXEL_FILL(1));
+    CopyWindowToVram(2, 2);
+}
+
+static void StartWin2FrameAnim(int animNo)
+{
+    switch (animNo)
+    {
+    case 0:
+        sEasyChatGraphicsResources->frameAnimIdx = 0;
+        sEasyChatGraphicsResources->frameAnimTarget = 10;
+        break;
+    case 1:
+        sEasyChatGraphicsResources->frameAnimIdx = 9;
+        sEasyChatGraphicsResources->frameAnimTarget = 0;
+        break;
+    case 2:
+        sEasyChatGraphicsResources->frameAnimIdx = 11;
+        sEasyChatGraphicsResources->frameAnimTarget = 17;
+        break;
+    case 3:
+        sEasyChatGraphicsResources->frameAnimIdx = 17;
+        sEasyChatGraphicsResources->frameAnimTarget = 0;
+        break;
+    case 4:
+        sEasyChatGraphicsResources->frameAnimIdx = 17;
+        sEasyChatGraphicsResources->frameAnimTarget = 10;
+        break;
+    case 5:
+        sEasyChatGraphicsResources->frameAnimIdx = 18;
+        sEasyChatGraphicsResources->frameAnimTarget = 22;
+        break;
+    case 6:
+        sEasyChatGraphicsResources->frameAnimIdx = 22;
+        sEasyChatGraphicsResources->frameAnimTarget = 18;
+        break;
+    }
+
+    sEasyChatGraphicsResources->frameAnimDelta = sEasyChatGraphicsResources->frameAnimIdx < sEasyChatGraphicsResources->frameAnimTarget ? 1 : -1;
+}
+
+static bool8 AnimateFrameResize(void)
+{
+    if (sEasyChatGraphicsResources->frameAnimIdx == sEasyChatGraphicsResources->frameAnimTarget)
+        return FALSE;
+
+    sEasyChatGraphicsResources->frameAnimIdx += sEasyChatGraphicsResources->frameAnimDelta;
+    RedrawFrameByIndex(sEasyChatGraphicsResources->frameAnimIdx);
+    return sEasyChatGraphicsResources->frameAnimIdx != sEasyChatGraphicsResources->frameAnimTarget;
+}
+
+static void RedrawFrameByIndex(u8 direction)
+{
+    FillBgTilemapBufferRect_Palette0(1, 0, 0, 10, 30, 10);
+    switch (direction)
+    {
+    case 0:
+        break;
+    case 1:
+        RedrawFrameByRect(11, 14, 3, 2);
+        break;
+    case 2:
+        RedrawFrameByRect(9, 14, 7, 2);
+        break;
+    case 3:
+        RedrawFrameByRect(7, 14, 11, 2);
+        break;
+    case 4:
+        RedrawFrameByRect(5, 14, 15, 2);
+        break;
+    case 5:
+        RedrawFrameByRect(3, 14, 19, 2);
+        break;
+    case 6:
+        RedrawFrameByRect(1, 14, 23, 2);
+        break;
+    case 7:
+        RedrawFrameByRect(1, 13, 23, 4);
+        break;
+    case 8:
+        RedrawFrameByRect(1, 12, 23, 6);
+        break;
+    case 9:
+        RedrawFrameByRect(1, 11, 23, 8);
+        break;
+    case 10:
+        RedrawFrameByRect(1, 10, 23, 10);
+        break;
+    case 11:
+        RedrawFrameByRect(1, 10, 24, 10);
+        break;
+    case 12:
+        RedrawFrameByRect(1, 10, 25, 10);
+        break;
+    case 13:
+        RedrawFrameByRect(1, 10, 26, 10);
+        break;
+    case 14:
+        RedrawFrameByRect(1, 10, 27, 10);
+        break;
+    case 15:
+        RedrawFrameByRect(1, 10, 28, 10);
+        break;
+    case 16:
+        RedrawFrameByRect(1, 10, 29, 10);
+        break;
+    case 17:
+        RedrawFrameByRect(0, 10, 30, 10);
+        break;
+    case 18:
+        RedrawFrameByRect(1, 10, 23, 10);
+        break;
+    case 19:
+        RedrawFrameByRect(1, 11, 23, 8);
+        break;
+    case 20:
+        RedrawFrameByRect(1, 12, 23, 6);
+        break;
+    case 21:
+        RedrawFrameByRect(1, 13, 23, 4);
+        break;
+    case 22:
+        RedrawFrameByRect(1, 14, 23, 2);
+        break;
+    }
+
+    CopyBgTilemapBufferToVram(1);
+}
+
+static void RedrawFrameByRect(int left, int top, int width, int height)
+{
+    u16 *tilemap;
+    int right;
+    int bottom;
+    int x, y;
+
+    tilemap = sEasyChatGraphicsResources->bg1TilemapBuffer;
+    right = left + width - 1;
+    bottom = top + height - 1;
+    x = left;
+    y = top;
+    tilemap[y * 32 + x] = 0x4001;
+    x++;
+    for (; x < right; x++)
+        tilemap[y * 32 + x] = 0x4002;
+
+    tilemap[y * 32 + x] = 0x4003;
+    y++;
+    for (; y < bottom; y++)
+    {
+        tilemap[y * 32 + left] = 0x4005;
+        x = left + 1;
+        for (; x < right; x++)
+            tilemap[y * 32 + x] = 0x4000;
+
+        tilemap[y * 32 + x] = 0x4007;
+    }
+
+    tilemap[y * 32 + left] = 0x4009;
+    x = left + 1;
+    for (; x < right; x++)
+        tilemap[y * 32 + x] = 0x400A;
+
+    tilemap[y * 32 + x] = 0x400B;
+    SetRegWin0Coords((left + 1) * 8, (top + 1) * 8, (width - 2) * 8, (height - 2) * 8);
+}
+
+static void InitBg2Scroll(void)
+{
+    ChangeBgY(2, 0x800, 0);
+    sEasyChatGraphicsResources->bg2ScrollRow = 0;
+}
+
+static void ScheduleBg2VerticalScroll(s16 direction, u8 speed)
+{
+    int bgY;
+    s16 totalDelta;
+
+    bgY = GetBgY(2);
+    sEasyChatGraphicsResources->bg2ScrollRow += direction;
+    totalDelta = direction * 16;
+    bgY += totalDelta << 8;
+    if (speed)
+    {
+        sEasyChatGraphicsResources->tgtBgY = bgY;
+        sEasyChatGraphicsResources->deltaBgY = speed * 256;
+        if (totalDelta < 0)
+            sEasyChatGraphicsResources->deltaBgY = -sEasyChatGraphicsResources->deltaBgY;
+    }
+    else
+    {
+        ChangeBgY(2, bgY, 0);
+    }
+}
+
+static bool8 AnimateBg2VerticalScroll(void)
+{
+    int bgY;
+
+    bgY = GetBgY(2);
+    if (bgY == sEasyChatGraphicsResources->tgtBgY)
+    {
+        return FALSE;
+    }
+    else
+    {
+        ChangeBgY(2, sEasyChatGraphicsResources->deltaBgY, 1);
+        return TRUE;
+    }
+}
+
+static int GetBg2ScrollRow(void)
+{
+    return sEasyChatGraphicsResources->bg2ScrollRow;
+}
+
+static void SetRegWin0Coords(u8 left, u8 top, u8 width, u8 height)
+{
+    u16 horizontalDimensions = WIN_RANGE(left, left + width);
+    u16 verticalDimensions = WIN_RANGE(top, top + height);
+    SetGpuReg(REG_OFFSET_WIN0H, horizontalDimensions);
+    SetGpuReg(REG_OFFSET_WIN0V, verticalDimensions);
+}
+
+static void LoadSpriteGfx(void)
+{
+    u32 i;
+
+    LoadSpriteSheets(sEasyChatSpriteSheets);
+    LoadSpritePalettes(sEasyChatSpritePalettes);
+    for (i = 0; i < NELEMS(sEasyChatCompressedSpriteSheets); i++)
+        LoadCompressedSpriteSheet(&sEasyChatCompressedSpriteSheets[i]);
+}
+
+static void CreateSelectDestFieldCursorSprite(void)
+{
+    u8 frameId = GetEasyChatScreenFrameId();
+    s16 x = sPhraseFrameDimensions[frameId].left * 8 + 13;
+    s16 y = (sPhraseFrameDimensions[frameId].top + 1) * 8 + 1;
+    u8 spriteId = CreateSprite(&sSpriteTemplate_RightTriangleCursor, x, y, 2);
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite = &gSprites[spriteId];
+    gSprites[spriteId].data[1] = 1;
+}
+
+static void SpriteCB_BounceCursor(struct Sprite * sprite)
+{
+    if (sprite->data[1])
+    {
+        if (++sprite->data[0] > 2)
+        {
+            sprite->data[0] = 0;
+            if (++sprite->pos2.x > 0)
+                sprite->pos2.x = -6;
+        }
+    }
+}
+
+static void SetSelectDestFieldCursorSpritePosAndResetAnim(u8 x, u8 y)
+{
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->pos1.x = x;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->pos1.y = y;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->pos2.x = 0;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->data[0] = 0;
+}
+
+static void FreezeSelectDestFieldCursorSprite(void)
+{
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->data[0] = 0;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->data[1] = 0;
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->pos2.x = 0;
+}
+
+static void UnfreezeSelectDestFieldCursorSprite(void)
+{
+    sEasyChatGraphicsResources->selectDestFieldCursorSprite->data[1] = 1;
+}
+
+static void CreateRedRectangularCursorSpritePair(void)
+{
+    u8 spriteId = CreateSprite(&sSpriteTemplate_RedRectangularCursor, 0, 0, 3);
+    sEasyChatGraphicsResources->rectCursorSpriteRight = &gSprites[spriteId];
+    sEasyChatGraphicsResources->rectCursorSpriteRight->pos2.x = 32;
+
+    spriteId = CreateSprite(&sSpriteTemplate_RedRectangularCursor, 0, 0, 3);
+    sEasyChatGraphicsResources->rectCursorSpriteLeft = &gSprites[spriteId];
+    sEasyChatGraphicsResources->rectCursorSpriteLeft->pos2.x = -32;
+
+    sEasyChatGraphicsResources->rectCursorSpriteRight->hFlip = TRUE;
+    EC_MoveCursor();
+}
+
+static void DestroyRedRectangularCursor(void)
+{
+    DestroySprite(sEasyChatGraphicsResources->rectCursorSpriteRight);
+    sEasyChatGraphicsResources->rectCursorSpriteRight = NULL;
+    DestroySprite(sEasyChatGraphicsResources->rectCursorSpriteLeft);
+    sEasyChatGraphicsResources->rectCursorSpriteLeft = NULL;
+}
+
+static void EC_MoveCursor(void)
+{
+    u8 x;
+    u8 y;
+
+    if (sEasyChatGraphicsResources->rectCursorSpriteRight && sEasyChatGraphicsResources->rectCursorSpriteLeft)
+    {
+        GetECSelectGroupCursorCoords(&x, &y);
+        if (!IsEasyChatAlphaMode())
+            MoveCursor_Group(x, y);
+        else
+            MoveCursor_Alpha(x, y);
+    }
+}
+
+static void MoveCursor_Group(s8 x, s8 y)
+{
+    if (x != -1)
+    {
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteRight, 0);
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.x = x * 84 + 58;
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.y = y * 16 + 96;
+
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteLeft, 0);
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.x = x * 84 + 58;
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.y = y * 16 + 96;
+    }
+    else
+    {
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteRight, 1);
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.x = 216;
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.y = y * 16 + 112;
+
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteLeft, 1);
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.x = 216;
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.y = y * 16 + 112;
+    }
+}
+
+static void MoveCursor_Alpha(s8 cursorX, s8 cursorY)
+{
+    int anim;
+    int x, y;
+
+    if (cursorX != -1)
+    {
+        y = cursorY * 16 + 96;
+        x = 32;
+        if (cursorX == 6 && cursorY == 0)
+        {
+            x = 157;
+            anim = 2;
+        }
+        else
+        {
+            x += sECDisplay_AlphaModeXCoords[cursorX < NELEMS(sECDisplay_AlphaModeXCoords) ? cursorX : 0];
+            anim = 3;
+        }
+
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteRight, anim);
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.x = x;
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.y = y;
+
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteLeft, anim);
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.x = x;
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.y = y;
+    }
+    else
+    {
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteRight, 1);
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.x = 216;
+        sEasyChatGraphicsResources->rectCursorSpriteRight->pos1.y = cursorY * 16 + 112;
+
+        StartSpriteAnim(sEasyChatGraphicsResources->rectCursorSpriteLeft, 1);
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.x = 216;
+        sEasyChatGraphicsResources->rectCursorSpriteLeft->pos1.y = cursorY * 16 + 112;
+    }
+}
+
+static void CreateSelectWordCursorSprite(void)
+{
+    u8 spriteId = CreateSprite(&sSpriteTemplate_RightTriangleCursor, 0, 0, 4);
+    sEasyChatGraphicsResources->selectWordCursorSprite = &gSprites[spriteId];
+    sEasyChatGraphicsResources->selectWordCursorSprite->callback = SpriteCB_SelectWordCursorSprite;
+    sEasyChatGraphicsResources->selectWordCursorSprite->oam.priority = 2;
+    SetSelectWordCursorSpritePos();
+}
+
+static void SpriteCB_SelectWordCursorSprite(struct Sprite * sprite)
+{
+    if (++sprite->data[0] > 2)
+    {
+        sprite->data[0] = 0;
+        if (++sprite->pos2.x > 0)
+            sprite->pos2.x = -6;
+    }
+}
+
+static void SetSelectWordCursorSpritePos(void)
+{
+    s8 cursorX, cursorY;
+    u8 x, y;
+
+    GetECSelectWordCursorCoords(&cursorX, &cursorY);
+    x = cursorX * 13 + 3;
+    y = cursorY * 2 + 11;
+    SetSelectWordCursorSpritePosExplicit(x, y);
+}
+
+static void SetSelectWordCursorSpritePosExplicit(u8 x, u8 y)
+{
+    if (sEasyChatGraphicsResources->selectWordCursorSprite)
+    {
+        sEasyChatGraphicsResources->selectWordCursorSprite->pos1.x = x * 8 + 4;
+        sEasyChatGraphicsResources->selectWordCursorSprite->pos1.y = (y + 1) * 8 + 1;
+        sEasyChatGraphicsResources->selectWordCursorSprite->pos2.x = 0;
+        sEasyChatGraphicsResources->selectWordCursorSprite->data[0] = 0;
+    }
+}
+
+static void DestroySelectWordCursorSprite(void)
+{
+    if (sEasyChatGraphicsResources->selectWordCursorSprite)
+    {
+        DestroySprite(sEasyChatGraphicsResources->selectWordCursorSprite);
+        sEasyChatGraphicsResources->selectWordCursorSprite = NULL;
+    }
+}
+
+static void CreateSelectGroupHelpSprite(void)
+{
+    u8 spriteId = CreateSprite(&sSpriteTemplate_SelectGroupHelp, 208, 128, 6);
+    sEasyChatGraphicsResources->selectGroupHelpSprite = &gSprites[spriteId];
+    sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x = -64;
+
+    spriteId = CreateSprite(&sSpriteTemplate_EasyChatModeIcons, 208, 80, 5);
+    sEasyChatGraphicsResources->modeIconsSprite = &gSprites[spriteId];
+    sEasyChatGraphicsResources->modeIconState = 0;
+}
+
+static bool8 AnimateSeletGroupModeAndHelpSpriteEnter(void)
+{
+    switch (sEasyChatGraphicsResources->modeIconState)
+    {
+    default:
+        return FALSE;
+    case 0:
+        sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x += 8;
+        if (sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x >= 0)
+        {
+            sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x = 0;
+            if (!IsEasyChatAlphaMode())
+                StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 1);
+            else
+                StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 2);
+
+            sEasyChatGraphicsResources->modeIconState++;
+        }
+        break;
+    case 1:
+        if (sEasyChatGraphicsResources->modeIconsSprite->animEnded)
+        {
+            sEasyChatGraphicsResources->modeIconState = 2;
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static void StartModeIconHidingAnimation(void)
+{
+    sEasyChatGraphicsResources->modeIconState = 0;
+    StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 3);
+}
+
+static bool8 RunModeIconHidingAnimation(void)
+{
+    switch (sEasyChatGraphicsResources->modeIconState)
+    {
+    default:
+        return FALSE;
+    case 0:
+        if (sEasyChatGraphicsResources->modeIconsSprite->animEnded)
+            sEasyChatGraphicsResources->modeIconState = 1;
+        break;
+    case 1:
+        sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x -= 8;
+        if (sEasyChatGraphicsResources->selectGroupHelpSprite->pos2.x <= -64)
+        {
+            DestroySprite(sEasyChatGraphicsResources->modeIconsSprite);
+            DestroySprite(sEasyChatGraphicsResources->selectGroupHelpSprite);
+            sEasyChatGraphicsResources->modeIconsSprite = NULL;
+            sEasyChatGraphicsResources->selectGroupHelpSprite = NULL;
+            sEasyChatGraphicsResources->modeIconState++;
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static void ShrinkModeIconsSprite(void)
+{
+    StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 4);
+}
+
+static void ShowModeIconsSprite(void)
+{
+    if (!IsEasyChatAlphaMode())
+        StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 1);
+    else
+        StartSpriteAnim(sEasyChatGraphicsResources->modeIconsSprite, 2);
+}
+
+static bool8 ModeIconsSpriteAnimIsEnded(void)
+{
+    return !sEasyChatGraphicsResources->modeIconsSprite->animEnded;
+}
+
+static void CreateVerticalScrollArrowSprites(void)
+{
+    u8 spriteId = CreateSprite(&sSpriteTemplate_UpTriangleCursor, 96, 80, 0);
+    if (spriteId != MAX_SPRITES)
+        sEasyChatGraphicsResources->upTriangleCursorSprite = &gSprites[spriteId];
+
+    spriteId = CreateSprite(&sSpriteTemplate_UpTriangleCursor, 96, 156, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sEasyChatGraphicsResources->downTriangleCursorSprite = &gSprites[spriteId];
+        sEasyChatGraphicsResources->downTriangleCursorSprite->vFlip = TRUE;
+    }
+
+    HideVerticalScrollArrowSprites();
+}
+
+static void UpdateVerticalScrollArrowVisibility(void)
+{
+    sEasyChatGraphicsResources->upTriangleCursorSprite->invisible = !ShouldDrawECUpArrow();
+    sEasyChatGraphicsResources->downTriangleCursorSprite->invisible = !ShouldDrawECDownArrow();
+}
+
+static void HideVerticalScrollArrowSprites(void)
+{
+    sEasyChatGraphicsResources->upTriangleCursorSprite->invisible = TRUE;
+    sEasyChatGraphicsResources->downTriangleCursorSprite->invisible = TRUE;
+}
+
+static void UpdateVerticalScrollArrowSpriteXPos(int direction)
+{
+    if (!direction)
+    {
+        // Group select
+        sEasyChatGraphicsResources->upTriangleCursorSprite->pos1.x = 96;
+        sEasyChatGraphicsResources->downTriangleCursorSprite->pos1.x = 96;
+    }
+    else
+    {
+        // Word select
+        sEasyChatGraphicsResources->upTriangleCursorSprite->pos1.x = 120;
+        sEasyChatGraphicsResources->downTriangleCursorSprite->pos1.x = 120;
+    }
+}
+
+static void CreateStartSelectButtonsSprites(void)
+{
+    u8 spriteId = CreateSprite(&sSpriteTemplate_StartSelectButtons, 220, 84, 1);
+    if (spriteId != MAX_SPRITES)
+        sEasyChatGraphicsResources->startPgUpButtonSprite = &gSprites[spriteId];
+
+    spriteId = CreateSprite(&sSpriteTemplate_StartSelectButtons, 220, 156, 1);
+    if (spriteId != MAX_SPRITES)
+    {
+        sEasyChatGraphicsResources->selectPgDnButtonSprite = &gSprites[spriteId];
+        StartSpriteAnim(sEasyChatGraphicsResources->selectPgDnButtonSprite, 1);
+    }
+
+    HideStartSelectButtonSprites();
+}
+
+static void UpdateStartSelectButtonSpriteVisibility(void)
+{
+    sEasyChatGraphicsResources->startPgUpButtonSprite->invisible = !ShouldDrawECUpArrow();
+    sEasyChatGraphicsResources->selectPgDnButtonSprite->invisible = !ShouldDrawECDownArrow();
+}
+
+static void HideStartSelectButtonSprites(void)
+{
+    sEasyChatGraphicsResources->startPgUpButtonSprite->invisible = TRUE;
+    sEasyChatGraphicsResources->selectPgDnButtonSprite->invisible = TRUE;
+}
+
+static void CreateFooterWindow(void)
+{
+    u16 windowId;
+    struct WindowTemplate template;
+    template.bg = 3;
+    template.tilemapLeft = 4;
+    template.tilemapTop = 11;
+    template.width = 24;
+    template.height = 2;
+    template.paletteNum = 11;
+    template.baseBlock = 0x030;
+    windowId = AddWindow(&template);
+    FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
+    EC_AddTextPrinterParameterized(windowId, 1, gUnknown_841EE2B, 0, 0, 0, NULL);
+    PutWindowTilemap(windowId);
+}
diff --git a/src/ereader_helpers.c b/src/ereader_helpers.c
index cce6cefca..df1b1c279 100644
--- a/src/ereader_helpers.c
+++ b/src/ereader_helpers.c
@@ -1,25 +1,18 @@
 #include "global.h"
 #include "link.h"
-#include "unk_815c27c.h"
-
-enum {
-    EREADER_XFR_STATE_INIT,
-    EREADER_XFR_STATE_HANDSHAKE,
-    EREADER_XFR_STATE_START,
-    EREADER_XFR_STATE_TRANSFER,
-};
+#include "ereader_helpers.h"
 
 struct SendRecvMgr
 {
-    u8 sendOrRecv;
-    u8 state;
-    u8 field_02;
-    u8 field_03;
-    u8 field_04;
-    u32 * dataptr;
-    int cursor;
-    int size;
-    u32 checksum;
+    u8 master_slave;       // 0: clock slave; 1: clock master
+    u8 state;              // EREADER_XFR_STATE_*
+    u8 xferState;          // EREADER_XFER_*
+    u8 checksumResult;     // EREADER_CHECKSUM_*
+    u8 cancellationReason; // EREADER_CANCEL_*
+    u32 * dataptr;         // Payload source or destination
+    int cursor;            // Index of the next word
+    int size;              // Last word index
+    u32 checksum;          // Validation checksum
 };
 
 static bool16 DetermineSendRecvState(u8);
@@ -39,10 +32,9 @@ static u16 sSavedIme;
 static u16 sSavedIe;
 static u16 sSavedTm3Cnt;
 static u16 sSavedSioCnt;
-static u16 sSavedSioCnt;
 static u16 sSavedRCnt;
 
-int EReader_Send(size_t r6, const void * r5)
+int EReader_Send(size_t size, const void * src)
 {
     int result;
     EReaderHelper_SaveRegsState();
@@ -53,18 +45,18 @@ int EReader_Send(size_t r6, const void * r5)
         if (TEST_BUTTON(sJoyNew, B_BUTTON))
             gShouldAdvanceLinkState = 2;
 
-        sSendRecvStatus = EReaderHandleTransfer(1, r6, r5, NULL);
-        if ((sSendRecvStatus & 0x13) == 0x10)
+        sSendRecvStatus = EReaderHandleTransfer(1, size, src, NULL);
+        if ((sSendRecvStatus & 0x13) == 0x10) // checksum OK and xfer off
         {
             result = 0;
             break;
         }
-        else if (sSendRecvStatus & 8)
+        else if (sSendRecvStatus & 8) // cancelled by player
         {
             result = 1;
             break;
         }
-        else if (sSendRecvStatus & 4)
+        else if (sSendRecvStatus & 4) // timed out
         {
             result = 2;
             break;
@@ -81,7 +73,7 @@ int EReader_Send(size_t r6, const void * r5)
     return result;
 }
 
-int EReader_Recv(void * r5)
+int EReader_Recv(void * dest)
 {
     int result;
     EReaderHelper_SaveRegsState();
@@ -92,18 +84,18 @@ int EReader_Recv(void * r5)
         if (TEST_BUTTON(sJoyNew, B_BUTTON))
             gShouldAdvanceLinkState = 2;
 
-        sSendRecvStatus = EReaderHandleTransfer(0, 0, NULL, r5);
-        if ((sSendRecvStatus & 0x13) == 0x10)
+        sSendRecvStatus = EReaderHandleTransfer(0, 0, NULL, dest);
+        if ((sSendRecvStatus & 0x13) == 0x10) // checksum OK and xfer off
         {
             result = 0;
             break;
         }
-        else if (sSendRecvStatus & 8)
+        else if (sSendRecvStatus & 8) // cancelled by player
         {
             result = 1;
             break;
         }
-        else if (sSendRecvStatus & 4)
+        else if (sSendRecvStatus & 4) // timed out
         {
             result = 2;
             break;
@@ -159,92 +151,98 @@ u16 EReaderHandleTransfer(u8 mode, size_t size, const void * data, void * recvBu
 {
     switch (sSendRecvMgr.state)
     {
-    case 0:
+    case EREADER_XFR_STATE_INIT:
         OpenSerialMulti();
-        sSendRecvMgr.field_02 = 1;
-        sSendRecvMgr.state = 1;
+        sSendRecvMgr.xferState = EREADER_XFER_EXE;
+        sSendRecvMgr.state = EREADER_XFR_STATE_HANDSHAKE;
         break;
-    case 1:
+    case EREADER_XFR_STATE_HANDSHAKE:
         if (DetermineSendRecvState(mode))
             EnableSio();
         if (gShouldAdvanceLinkState == 2)
         {
-            sSendRecvMgr.field_04 = 2;
-            sSendRecvMgr.state = 6;
+            sSendRecvMgr.cancellationReason = EREADER_CANCEL_KEY;
+            sSendRecvMgr.state = EREADER_XFR_STATE_DONE;
         }
+        // Progression is handled by the serial callback
         break;
-    case 2:
+    case EREADER_XFR_STATE_START:
         OpenSerial32();
         SetUpTransferManager(size, data, recvBuffer);
-        sSendRecvMgr.state = 3;
+        sSendRecvMgr.state = EREADER_XFR_STATE_TRANSFER;
         // fallthrough
-    case 3:
+    case EREADER_XFR_STATE_TRANSFER:
         if (gShouldAdvanceLinkState == 2)
         {
-            sSendRecvMgr.field_04 = 2;
-            sSendRecvMgr.state = 6;
+            sSendRecvMgr.cancellationReason = EREADER_CANCEL_KEY;
+            sSendRecvMgr.state = EREADER_XFR_STATE_DONE;
         }
         else
         {
             sCounter1++;
             sCounter2++;
-            if (sSendRecvMgr.sendOrRecv == 0 && sCounter2 > 60)
+            if (sSendRecvMgr.master_slave == 0 && sCounter2 > 60)
             {
-                sSendRecvMgr.field_04 = 1;
-                sSendRecvMgr.state = 6;
+                sSendRecvMgr.cancellationReason = EREADER_CANCEL_TIMEOUT;
+                sSendRecvMgr.state = EREADER_XFR_STATE_DONE;
             }
-            if (sSendRecvMgr.field_02 != 2)
+            if (sSendRecvMgr.xferState != EREADER_XFER_CHK)
             {
-                if (sSendRecvMgr.sendOrRecv != 0 && sCounter1 > 2)
+                if (sSendRecvMgr.master_slave != 0 && sCounter1 > 2)
                 {
                     EnableSio();
-                    sSendRecvMgr.field_02 = 2;
+                    sSendRecvMgr.xferState = EREADER_XFER_CHK;
                 }
                 else
                 {
                     EnableSio();
-                    sSendRecvMgr.field_02 = 2;
+                    sSendRecvMgr.xferState = EREADER_XFER_CHK;
                 }
             }
         }
+        // Progression is handled by the serial callback
         break;
-    case 4:
+    case EREADER_XFR_STATE_TRANSFER_DONE:
         OpenSerialMulti();
-        sSendRecvMgr.state = 5;
+        sSendRecvMgr.state = EREADER_XFR_STATE_CHECKSUM;
         break;
-    case 5:
-        if (sSendRecvMgr.sendOrRecv == 1 && sCounter1 > 2)
+    case EREADER_XFR_STATE_CHECKSUM:
+        if (sSendRecvMgr.master_slave == 1 && sCounter1 > 2)
             EnableSio();
         if (++sCounter1 > 60)
         {
-            sSendRecvMgr.field_04 = 1;
-            sSendRecvMgr.state = 6;
+            sSendRecvMgr.cancellationReason = EREADER_CANCEL_TIMEOUT;
+            sSendRecvMgr.state = EREADER_XFR_STATE_DONE;
         }
         break;
-    case 6:
-        if (sSendRecvMgr.field_02 != 0)
+        // Progression is handled by the serial callback
+    case EREADER_XFR_STATE_DONE:
+        if (sSendRecvMgr.xferState != 0)
         {
             CloseSerial();
-            sSendRecvMgr.field_02 = 0;
+            sSendRecvMgr.xferState = 0;
         }
         break;
     }
-    return sSendRecvMgr.field_02 | (sSendRecvMgr.field_04 << 2) | (sSendRecvMgr.field_03 << 4);
+    return
+        (sSendRecvMgr.xferState << EREADER_XFER_SHIFT)
+      | (sSendRecvMgr.cancellationReason << EREADER_CANCEL_SHIFT)
+      | (sSendRecvMgr.checksumResult << EREADER_CHECKSUM_SHIFT);
 }
 
 static bool16 DetermineSendRecvState(u8 mode)
 {
     bool16 resp;
     if ((*(vu32 *)REG_ADDR_SIOCNT & (SIO_MULTI_SI | SIO_MULTI_SD)) == SIO_MULTI_SD && mode)
-        resp = sSendRecvMgr.sendOrRecv = TRUE;
+        resp = sSendRecvMgr.master_slave = TRUE;
     else
-        resp = sSendRecvMgr.sendOrRecv = FALSE;
+        resp = sSendRecvMgr.master_slave = FALSE;
     return resp;
 }
 
 static void SetUpTransferManager(size_t size, const void * data, void * recvBuffer)
 {
-    if (sSendRecvMgr.sendOrRecv)
+    if (sSendRecvMgr.master_slave)
     {
         REG_SIOCNT |= SIO_38400_BPS;
         sSendRecvMgr.dataptr = (void *)data;
@@ -284,7 +282,7 @@ void EReaderHelper_SerialCallback(void)
 
     switch (sSendRecvMgr.state)
     {
-    case 1:
+    case EREADER_XFR_STATE_HANDSHAKE:
         REG_SIOMLT_SEND = 0xCCD0;
         *(u64 *)recv = REG_SIOMLT_RECV;
         for (i = 0, cnt1 = 0, cnt2 = 0; i < 4; i++)
@@ -295,14 +293,17 @@ void EReaderHelper_SerialCallback(void)
                 cnt2++;
         }
         if (cnt1 == 2 && cnt2 == 0)
-            sSendRecvMgr.state = 2;
+            sSendRecvMgr.state = EREADER_XFR_STATE_START;
         break;
-    case 3:
+        // Progression is handled by software
+    case EREADER_XFR_STATE_TRANSFER:
         recv32 = REG_SIODATA32;
-        if (sSendRecvMgr.cursor == 0 && sSendRecvMgr.sendOrRecv == 0)
+        // The first value sent by the EReader is the payload size
+        if (sSendRecvMgr.cursor == 0 && sSendRecvMgr.master_slave == 0)
             sSendRecvMgr.size = recv32 / 4 + 1;
-        if (sSendRecvMgr.sendOrRecv == 1)
+        if (sSendRecvMgr.master_slave == 1)
         {
+            // Send mode
             if (sSendRecvMgr.cursor < sSendRecvMgr.size)
             {
                 REG_SIODATA32 = sSendRecvMgr.dataptr[sSendRecvMgr.cursor];
@@ -313,43 +314,51 @@ void EReaderHelper_SerialCallback(void)
         }
         else
         {
+            // Receive mode
             if (sSendRecvMgr.cursor > 0 && sSendRecvMgr.cursor < sSendRecvMgr.size + 1)
             {
+                // Receive next word
                 sSendRecvMgr.dataptr[sSendRecvMgr.cursor - 1] = recv32;
                 sSendRecvMgr.checksum += recv32;
             }
             else if (sSendRecvMgr.cursor != 0)
             {
+                // Reached the end, test the received checksum
                 if (sSendRecvMgr.checksum == recv32)
-                    sSendRecvMgr.field_03 = 1;
+                    sSendRecvMgr.checksumResult = EREADER_CHECKSUM_OK;
                 else
-                    sSendRecvMgr.field_03 = 2;
+                    sSendRecvMgr.checksumResult = EREADER_CHECKSUM_ERR;
             }
             sCounter2 = 0;
         }
         sSendRecvMgr.cursor++;
         if (sSendRecvMgr.cursor < sSendRecvMgr.size + 2)
         {
-            if (sSendRecvMgr.sendOrRecv != 0)
+            if (sSendRecvMgr.master_slave != 0)
+                // Clock master; start timer
                 REG_TM3CNT_H |= TIMER_ENABLE;
             else
+                // Clock slave; reset
                 EnableSio();
         }
         else
         {
-            sSendRecvMgr.state = 4;
+            sSendRecvMgr.state = EREADER_XFR_STATE_TRANSFER_DONE;
             sCounter1 = 0;
         }
         break;
-    case 5:
-        if (sSendRecvMgr.sendOrRecv == 0)
-            REG_SIODATA8 = sSendRecvMgr.field_03;
+        // Progression is handled by the software
+    case EREADER_XFR_STATE_CHECKSUM:
+        if (sSendRecvMgr.master_slave == 0)
+            // Clock slave
+            REG_SIODATA8 = sSendRecvMgr.checksumResult;
         *(vu64 *)recv = REG_SIOMLT_RECV;
-        if (recv[1] == 1 || recv[1] == 2)
+        if (recv[1] == EREADER_CHECKSUM_OK || recv[1] == EREADER_CHECKSUM_ERR)
         {
-            if (sSendRecvMgr.sendOrRecv == 1)
-                sSendRecvMgr.field_03 = recv[1];
-            sSendRecvMgr.state = 6;
+            if (sSendRecvMgr.master_slave == 1)
+                // EReader has (in)validated the payload
+                sSendRecvMgr.checksumResult = recv[1];
+            sSendRecvMgr.state = EREADER_XFR_STATE_DONE;
         }
         break;
     }
diff --git a/src/event_data.c b/src/event_data.c
index 010a4414c..a162e8701 100644
--- a/src/event_data.c
+++ b/src/event_data.c
@@ -24,7 +24,7 @@ EWRAM_DATA u16 gSpecialVar_MonBoxId = 0;
 EWRAM_DATA u16 gSpecialVar_MonBoxPos = 0;
 EWRAM_DATA u16 gSpecialVar_TextColor = 0;
 EWRAM_DATA u16 gSpecialVar_PrevTextColor = 0;
-EWRAM_DATA u16 gUnknown_20370DE = 0;
+EWRAM_DATA u16 gSpecialVar_0x8014 = 0;
 EWRAM_DATA u8 sSpecialFlags[SPECIAL_FLAGS_COUNT] = {};
 
 u16 gLastQuestLogStoredFlagOrVarIdx;
@@ -118,7 +118,7 @@ bool32 IsMysteryGiftEnabled(void)
     return FlagGet(FLAG_SYS_MYSTERY_GIFT_ENABLED);
 }
 
-void sub_806E2D0(void)
+void ResetMysteryEventFlags(void)
 {
     FlagClear(FLAG_MYSTERY_EVENT_DONE);
     FlagClear(FLAG_0x3D9);
@@ -138,7 +138,7 @@ void sub_806E2D0(void)
     FlagClear(FLAG_0x3E7);
 }
 
-void sub_806E370(void)
+void ResetMysteryEventVars(void)
 {
     VarSet(VAR_EVENT_PICHU_SLOT, 0);
     VarSet(VAR_0x40B6, 0);
@@ -321,5 +321,5 @@ void ResetSpecialVars(void)
     gSpecialVar_MonBoxPos = 0;
     gSpecialVar_TextColor = 0;
     gSpecialVar_PrevTextColor = 0;
-    gUnknown_20370DE = 0;
+    gSpecialVar_0x8014 = 0;
 }
diff --git a/src/event_object_80688E4.c b/src/event_object_80688E4.c
new file mode 100644
index 000000000..746b10f38
--- /dev/null
+++ b/src/event_object_80688E4.c
@@ -0,0 +1,653 @@
+#include "global.h"
+#include "event_object_movement.h"
+#include "field_effect.h"
+#include "field_ground_effect.h"
+
+// This is part of evobjmv.c (see assert statement in DoObjectUnionRoomWarpYDisplacement).
+
+static void DoObjectUnionRoomWarpYDisplacement(struct Sprite * sprite);
+
+bool8 FreezeObjectEvent(struct ObjectEvent * objectEvent)
+{
+    if (objectEvent->heldMovementActive || objectEvent->frozen)
+        return TRUE;
+    objectEvent->frozen = TRUE;
+    objectEvent->spriteAnimPausedBackup = gSprites[objectEvent->spriteId].animPaused;
+    objectEvent->spriteAffineAnimPausedBackup = gSprites[objectEvent->spriteId].affineAnimPaused;
+    gSprites[objectEvent->spriteId].animPaused = TRUE;
+    gSprites[objectEvent->spriteId].affineAnimPaused = TRUE;
+    return FALSE;
+}
+
+void FreezeObjectEvents(void)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (gObjectEvents[i].active && i != gPlayerAvatar.objectEventId)
+            FreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+void FreezeObjectEventsExceptOne(u8 noFreeze)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (i != noFreeze && gObjectEvents[i].active && i != gPlayerAvatar.objectEventId)
+            FreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+void UnfreezeObjectEvent(struct ObjectEvent * objectEvent)
+{
+    if (objectEvent->active && objectEvent->frozen)
+    {
+        objectEvent->frozen = FALSE;
+        gSprites[objectEvent->spriteId].animPaused = objectEvent->spriteAnimPausedBackup;
+        gSprites[objectEvent->spriteId].affineAnimPaused = objectEvent->spriteAffineAnimPausedBackup;
+    }
+}
+
+void UnfreezeObjectEvents(void)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (gObjectEvents[i].active)
+            UnfreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+#define tObjectEventId data[0]
+#define tZCoord        data[1]
+#define tInvisible     data[2]
+
+#define tDirection data[3]
+#define tSpeed     data[4]
+#define tStepNo    data[5]
+
+static void little_step(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += sDirectionToVectors[direction].x;
+    sprite->pos1.y += sDirectionToVectors[direction].y;
+}
+
+static void double_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 2 * (u16) sDirectionToVectors[direction].x;
+    sprite->pos1.y += 2 * (u16) sDirectionToVectors[direction].y;
+}
+
+static void triple_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 2 * (u16) sDirectionToVectors[direction].x + (u16) sDirectionToVectors[direction].x;
+    sprite->pos1.y += 2 * (u16) sDirectionToVectors[direction].y + (u16) sDirectionToVectors[direction].y;
+}
+
+static void quad_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 4 * (u16) sDirectionToVectors[direction].x;
+    sprite->pos1.y += 4 * (u16) sDirectionToVectors[direction].y;
+}
+
+static void oct_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 8 * (u16) sDirectionToVectors[direction].x;
+    sprite->pos1.y += 8 * (u16) sDirectionToVectors[direction].y;
+}
+
+void oamt_npc_ministep_reset(struct Sprite * sprite, u8 direction, u8 speed)
+{
+    sprite->tDirection = direction;
+    sprite->tSpeed = speed;
+    sprite->tStepNo = 0;
+}
+
+typedef void (*SpriteStepFunc)(struct Sprite *sprite, u8 direction);
+
+static const SpriteStepFunc sSpeed0[] = {
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step
+};
+
+static const SpriteStepFunc sSpeed1[] = {
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps
+};
+
+static const SpriteStepFunc sSpeed2[] = {
+    double_little_steps,
+    triple_little_steps,
+    triple_little_steps,
+    double_little_steps,
+    triple_little_steps,
+    triple_little_steps
+};
+
+static const SpriteStepFunc sSpeed3[] = {
+    quad_little_steps,
+    quad_little_steps,
+    quad_little_steps,
+    quad_little_steps
+};
+
+static const SpriteStepFunc sSpeed4[] = {
+    oct_little_steps,
+    oct_little_steps
+};
+
+static const SpriteStepFunc *const sSpriteStepFuncsBySpeed[] = {
+    sSpeed0,
+    sSpeed1,
+    sSpeed2,
+    sSpeed3,
+    sSpeed4
+};
+
+static const s16 sSpriteStepCountsBySpeed[] = {
+    NELEMS(sSpeed0),
+    NELEMS(sSpeed1),
+    NELEMS(sSpeed2),
+    NELEMS(sSpeed3),
+    NELEMS(sSpeed4)
+};
+
+bool8 obj_npc_ministep(struct Sprite *sprite)
+{
+    if (sprite->tStepNo >= sSpriteStepCountsBySpeed[sprite->tSpeed])
+        return FALSE;
+
+    sSpriteStepFuncsBySpeed[sprite->tSpeed][sprite->tStepNo](sprite, sprite->tDirection);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo < sSpriteStepCountsBySpeed[sprite->tSpeed])
+        return FALSE;
+
+    return TRUE;
+}
+
+#undef tStepNo
+#undef tSpeed
+#undef tDirection
+
+#define tDirection data[3]
+#define tDelay     data[4]
+#define tStepNo    data[5]
+
+void sub_8068BBC(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+// used by an_walk_any_2
+bool8 sub_8068BCC(struct Sprite *sprite)
+{
+    if (!(sprite->tDelay & 1))
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+
+    sprite->tDelay++;
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068C08(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068C18(struct Sprite *sprite)
+{
+    if (++sprite->tDelay < 3)
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+    else
+        sprite->tDelay = 0;
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068C58(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068C68(struct Sprite *sprite)
+{
+    if (++sprite->tDelay > 9)
+    {
+        sprite->tDelay = 0;
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068CA4(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068CB4(struct Sprite *sprite)
+{
+    if ((++sprite->tDelay) & 1)
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+    else
+    {
+        double_little_steps(sprite, sprite->tDirection);
+        sprite->tStepNo += 2;
+    }
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tStepNo
+#undef tDelay
+#undef tDirection
+
+#define tDirection  data[3]
+#define tJumpSpeed  data[4]
+#define tJumpHeight data[5]
+#define tStepNo     data[6]
+
+static const s8 sJumpHeight12[] = {
+    -4,  -6,  -8, -10, -11, -12, -12, -12, -11, -10,  -9,  -8,  -6,  -4,   0,   0
+};
+
+static const s8 sJumpHeight6[] = {
+    0,  -2,  -3,  -4,  -5,  -6,  -6,  -6,  -5,  -5,  -4,  -3,  -2,   0,   0,   0
+};
+
+static const s8 sJumpHeight10[] = {
+    -2,  -4,  -6,  -8,  -9, -10, -10, -10,  -9,  -8,  -6,  -5,  -3,  -2,   0,   0
+};
+
+static const s8 *const sYDisplacementPtrs[] = {
+    sJumpHeight12,
+    sJumpHeight6,
+    sJumpHeight10
+};
+
+static s16 GetJumpYDisplacement(s16 stepno, u8 jumpno)
+{
+    return sYDisplacementPtrs[jumpno][stepno];
+}
+
+void sub_8068D1C(struct Sprite *sprite, u8 direction, u8 speed, u8 height)
+{
+    sprite->tDirection = direction;
+    sprite->tJumpSpeed = speed;
+    sprite->tJumpHeight = height;
+    sprite->tStepNo = 0;
+}
+
+u8 sub_8068D3C(struct Sprite *sprite)
+{
+    s16 duration[3] = {0x10, 0x10, 0x20};
+    u8 shifts[3] = {0, 0, 1};
+    u8 jumpPhase = 0;
+
+    if (sprite->tJumpSpeed != 0)
+        little_step(sprite, sprite->tDirection);
+
+    sprite->pos2.y = GetJumpYDisplacement(sprite->tStepNo >> shifts[sprite->tJumpSpeed], sprite->tJumpHeight);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo == (duration[sprite->tJumpSpeed] >> 1))
+        jumpPhase = 1;
+
+    if (sprite->tStepNo >= duration[sprite->tJumpSpeed])
+    {
+        sprite->pos2.y = 0;
+        jumpPhase = -1;
+    }
+
+    return jumpPhase;
+}
+
+u8 sub_8068DC4(struct Sprite *sprite)
+{
+    s16 duration[3] = {0x20, 0x20, 0x40};
+    u8 shifts[3] = {1, 1, 2};
+    u8 jumpPhase = 0;
+
+    if (sprite->tJumpSpeed != 0 && !(sprite->tStepNo & 1))
+        little_step(sprite, sprite->tDirection);
+
+    sprite->pos2.y = GetJumpYDisplacement(sprite->tStepNo >> shifts[sprite->tJumpSpeed], sprite->tJumpHeight);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo == (duration[sprite->tJumpSpeed] >> 1))
+        jumpPhase = 1;
+
+    if (sprite->tStepNo >= duration[sprite->tJumpSpeed])
+    {
+        sprite->pos2.y = 0;
+        jumpPhase = -1;
+    }
+
+    return jumpPhase;
+}
+
+#undef tStepNo
+#undef tJumpHeight
+#undef tJumpSpeed
+#undef tDirection
+
+#define tDelay data[3]
+
+void SetMovementDelay(struct Sprite *sprite, s16 delay)
+{
+    sprite->tDelay = delay;
+}
+
+bool8 WaitForMovementDelay(struct Sprite *sprite)
+{
+    sprite->tDelay--;
+
+    if (sprite->tDelay == 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tDelay
+
+void SetAndStartSpriteAnim(struct Sprite *sprite, u8 animNum, u8 animCmdIndex)
+{
+    sprite->animNum = animNum;
+    sprite->animPaused = FALSE;
+    SeekSpriteAnim(sprite, animCmdIndex);
+}
+
+bool8 SpriteAnimEnded(struct Sprite *sprite)
+{
+    if (sprite->animEnded)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void UpdateObjectEventSpriteVisibility(struct Sprite *sprite, bool8 invisible)
+{
+    u16 x, y;
+    s16 x2, y2;
+
+    sprite->invisible = invisible;
+
+    if (sprite->coordOffsetEnabled)
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY;
+    }
+    else
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY;
+    }
+
+    x2 = x - (sprite->centerToCornerVecX >> 1);
+    y2 = y - (sprite->centerToCornerVecY >> 1);
+
+    if ((s16)x > 255 || x2 < -16)
+        sprite->invisible = TRUE;
+    if ((s16)y > 175 || y2 < -16)
+        sprite->invisible = TRUE;
+}
+
+void UpdateObjectEventSpriteSubpriorityAndVisibility(struct Sprite *sprite)
+{
+    DoObjectUnionRoomWarpYDisplacement(sprite);
+    SetObjectSubpriorityByZCoord(sprite->tZCoord, sprite, 1);
+    UpdateObjectEventSpriteVisibility(sprite, sprite->tInvisible);
+}
+
+void sub_8068FD0(void)
+{
+    s32 i;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if (sprite->inUse && sprite->callback == UpdateObjectEventSpriteSubpriorityAndVisibility)
+        {
+            DestroySprite(sprite);
+        }
+    }
+}
+
+#define tUnionRoomWarpAnimNo    data[3]
+#define tUnionRoomWarpAnimState data[4]
+
+static int GetObjectEventSpriteId(u8 objectEventId)
+{
+    int i;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if (sprite->inUse && sprite->callback == UpdateObjectEventSpriteSubpriorityAndVisibility && (u8)sprite->tObjectEventId == objectEventId)
+        {
+            return i;
+        }
+    }
+    return MAX_SPRITES;
+}
+
+void TurnObjectEvent(u8 objectEventId, u8 direction)
+{
+    u8 animNum;
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        StartSpriteAnim(sprite, GetFaceDirectionAnimNum(direction));
+    }
+}
+
+void RfuUnionObjectSetFacingDirection(u8 objectEventId, u8 direction)
+{
+    u8 animNum;
+    int spriteId = GetObjectEventSpriteId(objectEventId);
+    u16 baseBlock;
+    if (spriteId != MAX_SPRITES)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        const struct ObjectEventGraphicsInfo * info = GetObjectEventGraphicsInfo(direction);
+        baseBlock = sprite->oam.tileNum;
+        sprite->oam = *info->oam;
+        sprite->oam.tileNum = baseBlock;
+        sprite->oam.paletteNum = info->paletteSlot;
+        sprite->images = info->images;
+        if (info->subspriteTables == NULL)
+        {
+            sprite->subspriteTables = NULL;
+            sprite->subspriteTableNum = 0;
+            sprite->subspriteMode = SUBSPRITES_OFF;
+        }
+        else
+        {
+            SetSubspriteTables(sprite, info->subspriteTables);
+            sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+        }
+        StartSpriteAnim(sprite, 0);
+    }
+}
+
+void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 invisible)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        if (invisible)
+            gSprites[spriteId].tInvisible = TRUE;
+        else
+            gSprites[spriteId].tInvisible = FALSE;
+    }
+}
+
+bool32 RfuUnionObjectIsInvisible(u8 objectEventId)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId == MAX_SPRITES)
+        return FALSE;
+    return gSprites[spriteId].tInvisible == TRUE;
+}
+
+void RfuUnionObjectStartWarp(u8 objectEventId, u8 animNo)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].tUnionRoomWarpAnimNo = animNo;
+        gSprites[spriteId].tUnionRoomWarpAnimState = 0;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacementUpwards(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimState)
+    {
+    case 0:
+        sprite->pos2.y = 0;
+        sprite->tUnionRoomWarpAnimState++;
+        // fallthrough
+    case 1:
+        if ((sprite->pos2.y -= 8) == -160)
+        {
+            sprite->pos2.y = 0;
+            sprite->tInvisible = 1;
+            sprite->tUnionRoomWarpAnimNo = 0;
+            sprite->tUnionRoomWarpAnimState = 0;
+        }
+        break;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacementDownwards(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimState)
+    {
+    case 0:
+        sprite->pos2.y = -160;
+        sprite->tUnionRoomWarpAnimState++;
+        // fallthrough
+    case 1:
+        if ((sprite->pos2.y += 8) == 0)
+        {
+            sprite->tUnionRoomWarpAnimNo = 0;
+            sprite->tUnionRoomWarpAnimState = 0;
+        }
+        break;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacement(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimNo)
+    {
+    case 0:
+        break;
+    case 1:
+        DoObjectUnionRoomWarpYDisplacementDownwards(sprite);
+        break;
+    case 2:
+        DoObjectUnionRoomWarpYDisplacementUpwards(sprite);
+        break;
+    default:
+        sprite->tUnionRoomWarpAnimNo = 0;
+        AGB_ASSERT_EX(0, ABSPATH("evobjmv.c"), 13331);
+    }
+}
+
+bool32 RfuUnionObjectIsWarping(u8 objectEventId)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId == MAX_SPRITES)
+        return FALSE;
+    if (gSprites[spriteId].tUnionRoomWarpAnimNo)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tUnionRoomWarpAnimState
+#undef tUnionRoomWarpAnimNo
+#undef tInvisible
+#undef tZCoord
+#undef tObjectEventId
+
+u32 oe_exec_and_other_stuff(u8 fieldEffectId, struct ObjectEvent * objectEvent)
+{
+    ObjectEventGetLocalIdAndMap(objectEvent, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
+    return FieldEffectStart(fieldEffectId);
+}
+
+void DoShadowFieldEffect(struct ObjectEvent *objectEvent)
+{
+    if (!objectEvent->hasShadow)
+    {
+        objectEvent->hasShadow = TRUE;
+        oe_exec_and_other_stuff(FLDEFF_SHADOW, objectEvent);
+    }
+}
+
+void DoRippleFieldEffect(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+{
+    const struct ObjectEventGraphicsInfo *graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+    gFieldEffectArguments[0] = sprite->pos1.x;
+    gFieldEffectArguments[1] = sprite->pos1.y + (graphicsInfo->height >> 1) - 2;
+    gFieldEffectArguments[2] = 151;
+    gFieldEffectArguments[3] = 3;
+    FieldEffectStart(FLDEFF_RIPPLE);
+}
diff --git a/src/event_object_lock.c b/src/event_object_lock.c
index 996e0c19c..a72845ac7 100644
--- a/src/event_object_lock.c
+++ b/src/event_object_lock.c
@@ -3,9 +3,7 @@
 #include "field_player_avatar.h"
 #include "event_object_movement.h"
 #include "script_movement.h"
-#include "event_object_80688E4.h"
 #include "event_data.h"
-#include "event_object_lock.h"
 
 bool8 walkrun_is_standing_still(void)
 {
@@ -89,18 +87,18 @@ void sub_80696C0(void)
 {
     u8 objectEventId = GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0);
     ObjectEventClearHeldMovementIfFinished(&gObjectEvents[objectEventId]);
-    sub_80974D8();
+    ScriptMovement_UnfreezeObjectEvents();
     UnfreezeObjectEvents();
 }
 
-void sub_80696F0(void)
+void UnionRoom_UnlockPlayerAndChatPartner(void)
 {
     u8 objectEventId;
     if (gObjectEvents[gSelectedObjectEvent].active)
         ObjectEventClearHeldMovementIfFinished(&gObjectEvents[gSelectedObjectEvent]);
     objectEventId = GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0);
     ObjectEventClearHeldMovementIfFinished(&gObjectEvents[objectEventId]);
-    sub_80974D8();
+    ScriptMovement_UnfreezeObjectEvents();
     UnfreezeObjectEvents();
 }
 
diff --git a/src/event_object_movement.c b/src/event_object_movement.c
index 53008f3a0..7ec8dd8d1 100644
--- a/src/event_object_movement.c
+++ b/src/event_object_movement.c
@@ -1,8 +1,6 @@
 #include "global.h"
 #include "malloc.h"
 #include "event_data.h"
-#include "event_object_80688E4.h"
-#include "event_object_8097404.h"
 #include "event_object_movement.h"
 #include "field_camera.h"
 #include "field_control_avatar.h"
@@ -21,7 +19,6 @@
 #include "trig.h"
 #include "constants/event_object_movement.h"
 #include "constants/event_objects.h"
-#include "constants/object_events.h"
 
 #define NUM_FIELD_MAP_OBJECT_TEMPLATES 0x51
 
@@ -74,18 +71,18 @@ static u8 sub_8063304(struct ObjectEvent *, struct Sprite *);
 static u8 sub_8063324(struct ObjectEvent *, struct Sprite *);
 static u8 sub_8063344(struct ObjectEvent *, struct Sprite *);
 static void sub_8064544(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064988(struct ObjectEvent *, struct Sprite *);
-u8 sub_80649C8(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064A08(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064A48(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064A88(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064AC8(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064B08(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064B48(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064C5C(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064C9C(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064CDC(struct ObjectEvent *, struct Sprite *);
-u8 sub_8064D1C(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x9B_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x9C_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x9D_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x9E_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x08_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x09_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0A_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0B_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0D_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0C_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0E_1(struct ObjectEvent *, struct Sprite *);
+u8 MovementActionFunc_x0F_1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *, struct Sprite *);
@@ -98,10 +95,10 @@ u8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8065438(struct ObjectEvent *, struct Sprite *);
-bool8 sub_80654A4(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8065510(struct ObjectEvent *, struct Sprite *);
-bool8 sub_806557C(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA0_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA1_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA2_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA3_1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *, struct Sprite *);
@@ -118,18 +115,18 @@ u8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8065FE4(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8066024(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8066064(struct ObjectEvent *, struct Sprite *);
-bool8 sub_80660A4(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x41_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x42_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x43_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x44_1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *, struct Sprite *);
-bool8 sub_806629C(struct ObjectEvent *, struct Sprite *);
-bool8 sub_80662DC(struct ObjectEvent *, struct Sprite *);
-bool8 sub_806631C(struct ObjectEvent *, struct Sprite *);
-bool8 sub_806635C(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA6_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA7_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA8_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_xA9_1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpDown_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_JumpLeft_Step1(struct ObjectEvent *, struct Sprite *);
@@ -165,10 +162,10 @@ u8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite
 u8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *);
 u8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *);;
-bool8 sub_80676A4(struct ObjectEvent *, struct Sprite *);
-bool8 sub_80676E4(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8067724(struct ObjectEvent *, struct Sprite *);
-bool8 sub_8067764(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x94_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x95_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x96_1(struct ObjectEvent *, struct Sprite *);
+bool8 MovementActionFunc_x97_1(struct ObjectEvent *, struct Sprite *);
 
 #define movement_type_def(setup, table) \
 static u8 setup##_callback(struct ObjectEvent *, struct Sprite *);\
@@ -319,7 +316,6 @@ extern const struct UnkStruct_083A3698 gUnknown_83A3698[];
 extern const u8 gTrainerFacingDirectionMovementTypes[];
 extern bool8 (*const gOppositeDirectionBlockedMetatileFuncs[])(u8);
 extern bool8 (*const gDirectionBlockedMetatileFuncs[])(u8);
-extern const struct Coords16 sDirectionToVectors[];
 extern const u8 gFaceDirectionMovementActions[5];
 extern const u8 gWalkSlowMovementActions[5];
 extern const u8 gUnknown_83A64F6[];
@@ -793,7 +789,7 @@ static u8 sub_805E238(struct ObjectEventTemplate *template, u8 var, s16 x, s16 y
 
 static u8 sub_805E27C(struct ObjectEventTemplate *template, s16 x, s16 y)
 {
-    if ((u8) (template->graphicsId - OBJECT_EVENT_GFX_CUT_TREE) > 1)
+    if ((u8) (template->graphicsId - OBJ_EVENT_GFX_CUT_TREE) > 1)
         return 1;
 
     if (gSaveBlock1Ptr->pos.x < x)
@@ -826,7 +822,7 @@ static u8 sub_805E2E8(struct ObjectEventTemplate *template, s16 x, s16 y)
     x2 = gBackupMapLayout.Xsize - 16;
     y2 = gBackupMapLayout.Ysize - 15;
     
-    if ((u8) (template->graphicsId - OBJECT_EVENT_GFX_CUT_TREE) > 1)
+    if ((u8) (template->graphicsId - OBJ_EVENT_GFX_CUT_TREE) > 1)
         return 1;
     
     if (!gSaveBlock1Ptr->pos.x)
@@ -1043,7 +1039,7 @@ u8 SpawnSpecialObjectEvent(struct ObjectEventTemplate *objectEventTemplate)
     return TrySpawnObjectEventTemplate(objectEventTemplate, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY);
 }
 
-u8 SpawnSpecialObjectEventParameterized(u8 graphicsId, u8 movementBehavior, u8 localId, s16 x, s16 y, u8 z)
+int SpawnSpecialObjectEventParameterized(u8 graphicsId, u8 movementBehavior, u8 localId, s16 x, s16 y, u8 z)
 {
     struct ObjectEventTemplate objectEventTemplate;
 
@@ -4846,13 +4842,13 @@ bool8 sub_8064930(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064968(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064904(objectEvent, sprite, DIR_SOUTH);
-    return sub_8064988(objectEvent, sprite);
+    return MovementActionFunc_x9B_1(objectEvent, sprite);
 }
 
-bool8 sub_8064988(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064930(objectEvent, sprite))
     {
@@ -4862,13 +4858,13 @@ bool8 sub_8064988(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80649A8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064904(objectEvent, sprite, DIR_NORTH);
-    return sub_80649C8(objectEvent, sprite);
+    return MovementActionFunc_x9C_1(objectEvent, sprite);
 }
 
-bool8 sub_80649C8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064930(objectEvent, sprite))
     {
@@ -4878,13 +4874,13 @@ bool8 sub_80649C8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80649E8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064904(objectEvent, sprite, DIR_WEST);
-    return sub_8064A08(objectEvent, sprite);
+    return MovementActionFunc_x9D_1(objectEvent, sprite);
 }
 
-bool8 sub_8064A08(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064930(objectEvent, sprite))
     {
@@ -4894,13 +4890,13 @@ bool8 sub_8064A08(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064A28(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064904(objectEvent, sprite, DIR_EAST);
-    return sub_8064A48(objectEvent, sprite);
+    return MovementActionFunc_x9E_1(objectEvent, sprite);
 }
 
-bool8 sub_8064A48(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064930(objectEvent, sprite))
     {
@@ -4910,13 +4906,13 @@ bool8 sub_8064A48(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064A68(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x08_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064830(objectEvent, sprite, DIR_SOUTH);
-    return sub_8064A88(objectEvent, sprite);
+    return MovementActionFunc_x08_1(objectEvent, sprite);
 }
 
-bool8 sub_8064A88(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x08_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (an_walk_any_2(objectEvent, sprite))
     {
@@ -4926,13 +4922,13 @@ bool8 sub_8064A88(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064AA8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x09_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064830(objectEvent, sprite, DIR_NORTH);
-    return sub_8064AC8(objectEvent, sprite);
+    return MovementActionFunc_x09_1(objectEvent, sprite);
 }
 
-bool8 sub_8064AC8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x09_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (an_walk_any_2(objectEvent, sprite))
     {
@@ -4942,13 +4938,13 @@ bool8 sub_8064AC8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064AE8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064830(objectEvent, sprite, DIR_WEST);
-    return sub_8064B08(objectEvent, sprite);
+    return MovementActionFunc_x0A_1(objectEvent, sprite);
 }
 
-bool8 sub_8064B08(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (an_walk_any_2(objectEvent, sprite))
     {
@@ -4958,13 +4954,13 @@ bool8 sub_8064B08(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064B28(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064830(objectEvent, sprite, DIR_EAST);
-    return sub_8064B48(objectEvent, sprite);
+    return MovementActionFunc_x0B_1(objectEvent, sprite);
 }
 
-bool8 sub_8064B48(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (an_walk_any_2(objectEvent, sprite))
     {
@@ -5008,13 +5004,13 @@ bool8 sub_8064C04(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064C3C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064BD8(objectEvent, sprite, DIR_NORTH);
-    return sub_8064C5C(objectEvent, sprite);
+    return MovementActionFunc_x0D_1(objectEvent, sprite);
 }
 
-bool8 sub_8064C5C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064C04(objectEvent, sprite))
     {
@@ -5024,13 +5020,13 @@ bool8 sub_8064C5C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064C7C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064BD8(objectEvent, sprite, DIR_SOUTH);
-    return sub_8064C9C(objectEvent, sprite);
+    return MovementActionFunc_x0C_1(objectEvent, sprite);
 }
 
-bool8 sub_8064C9C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064C04(objectEvent, sprite))
     {
@@ -5040,13 +5036,13 @@ bool8 sub_8064C9C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064CBC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064BD8(objectEvent, sprite, DIR_WEST);
-    return sub_8064CDC(objectEvent, sprite);
+    return MovementActionFunc_x0E_1(objectEvent, sprite);
 }
 
-bool8 sub_8064CDC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064C04(objectEvent, sprite))
     {
@@ -5056,13 +5052,13 @@ bool8 sub_8064CDC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8064CFC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8064BD8(objectEvent, sprite, DIR_EAST);
-    return sub_8064D1C(objectEvent, sprite);
+    return MovementActionFunc_x0F_1(objectEvent, sprite);
 }
 
-bool8 sub_8064D1C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x0F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8064C04(objectEvent, sprite))
     {
@@ -5421,16 +5417,16 @@ bool8 sub_80653CC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-u8 sub_80653F8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_xA0_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_SOUTH)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_SOUTH));
     
     npc_apply_direction(objectEvent, sprite, DIR_SOUTH, 1);
-    return sub_8065438(objectEvent, sprite);
+    return MovementActionFunc_xA0_1(objectEvent, sprite);
 }
 
-bool8 sub_8065438(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA0_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     AnimateSprite(sprite);
     if (sub_80653CC(objectEvent, sprite))
@@ -5441,16 +5437,16 @@ bool8 sub_8065438(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-u8 sub_8065464(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_xA1_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_NORTH)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_NORTH));
     
     npc_apply_direction(objectEvent, sprite, DIR_NORTH, 1);
-    return sub_80654A4(objectEvent, sprite);
+    return MovementActionFunc_xA1_1(objectEvent, sprite);
 }
 
-bool8 sub_80654A4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA1_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     AnimateSprite(sprite);
     if (sub_80653CC(objectEvent, sprite))
@@ -5461,16 +5457,16 @@ bool8 sub_80654A4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-u8 sub_80654D0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_xA2_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_WEST)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_WEST));
     
     npc_apply_direction(objectEvent, sprite, DIR_WEST, 1);
-    return sub_8065510(objectEvent, sprite);
+    return MovementActionFunc_xA2_1(objectEvent, sprite);
 }
 
-bool8 sub_8065510(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA2_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     AnimateSprite(sprite);
     if (sub_80653CC(objectEvent, sprite))
@@ -5481,16 +5477,16 @@ bool8 sub_8065510(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-u8 sub_806553C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_xA3_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_EAST)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_EAST));
     
     npc_apply_direction(objectEvent, sprite, DIR_EAST, 1);
-    return sub_806557C(objectEvent, sprite);
+    return MovementActionFunc_xA3_1(objectEvent, sprite);
 }
 
-bool8 sub_806557C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA3_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     AnimateSprite(sprite);
     if (sub_80653CC(objectEvent, sprite))
@@ -5509,7 +5505,7 @@ void sub_80655A8(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire
     sprite->data[2] = 1;
 }
 
-u8 sub_80655D4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_x04_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_SOUTH)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_SOUTH));
@@ -5519,7 +5515,7 @@ u8 sub_80655D4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return TRUE;
 }
 
-u8 sub_8065610(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_x05_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_NORTH)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_NORTH));
@@ -5529,7 +5525,7 @@ u8 sub_8065610(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return TRUE;
 }
 
-u8 sub_806564C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_x06_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_WEST)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_WEST));
@@ -5539,7 +5535,7 @@ u8 sub_806564C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return TRUE;
 }
 
-u8 sub_8065688(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_x07_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if(objectEvent->facingDirection != DIR_EAST)
         StartSpriteAnim(sprite, GetFaceDirectionAnimNum(DIR_EAST));
@@ -5964,13 +5960,13 @@ bool8 sub_8065F8C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8065FC4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x41_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8065F60(objectEvent, sprite, DIR_SOUTH);
-    return sub_8065FE4(objectEvent, sprite);
+    return MovementActionFunc_x41_1(objectEvent, sprite);
 }
 
-bool8 sub_8065FE4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x41_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065F8C(objectEvent, sprite))
     {
@@ -5980,13 +5976,13 @@ bool8 sub_8065FE4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8066004(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x42_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8065F60(objectEvent, sprite, DIR_NORTH);
-    return sub_8066024(objectEvent, sprite);
+    return MovementActionFunc_x42_1(objectEvent, sprite);
 }
 
-bool8 sub_8066024(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x42_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065F8C(objectEvent, sprite))
     {
@@ -5996,13 +5992,13 @@ bool8 sub_8066024(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8066044(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x43_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8065F60(objectEvent, sprite, DIR_WEST);
-    return sub_8066064(objectEvent, sprite);
+    return MovementActionFunc_x43_1(objectEvent, sprite);
 }
 
-bool8 sub_8066064(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x43_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065F8C(objectEvent, sprite))
     {
@@ -6012,13 +6008,13 @@ bool8 sub_8066064(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8066084(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x44_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8065F60(objectEvent, sprite, DIR_SOUTH);
-    return sub_80660A4(objectEvent, sprite);
+    return MovementActionFunc_x44_1(objectEvent, sprite);
 }
 
-bool8 sub_80660A4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x44_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065F8C(objectEvent, sprite))
     {
@@ -6125,13 +6121,13 @@ bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *objectEvent, str
     return FALSE;
 }
 
-bool8 sub_806627C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA6_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066128(objectEvent, sprite, DIR_SOUTH);
-    return sub_806629C(objectEvent, sprite);
+    return MovementActionFunc_xA6_1(objectEvent, sprite);
 }
 
-bool8 sub_806629C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA6_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065040(objectEvent, sprite))
     {
@@ -6141,13 +6137,13 @@ bool8 sub_806629C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80662BC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA7_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066128(objectEvent, sprite, DIR_NORTH);
-    return sub_80662DC(objectEvent, sprite);
+    return MovementActionFunc_xA7_1(objectEvent, sprite);
 }
 
-bool8 sub_80662DC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA7_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065040(objectEvent, sprite))
     {
@@ -6157,13 +6153,13 @@ bool8 sub_80662DC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80662FC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA8_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066128(objectEvent, sprite, DIR_WEST);
-    return sub_806631C(objectEvent, sprite);
+    return MovementActionFunc_xA8_1(objectEvent, sprite);
 }
 
-bool8 sub_806631C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA8_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065040(objectEvent, sprite))
     {
@@ -6173,13 +6169,13 @@ bool8 sub_806631C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_806633C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA9_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066128(objectEvent, sprite, DIR_EAST);
-    return sub_806635C(objectEvent, sprite);
+    return MovementActionFunc_xA9_1(objectEvent, sprite);
 }
 
-bool8 sub_806635C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA9_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (sub_8065040(objectEvent, sprite))
     {
@@ -6504,23 +6500,23 @@ bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *objectEvent, st
 bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]);
-    FieldEffectStart(FLDEFF_HEART_ICON);
+    FieldEffectStart(FLDEFF_X_ICON);
     sprite->data[2] = 1;
     return TRUE;
 }
 
-bool8 sub_806698C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 do_double_excl_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]);
-    FieldEffectStart(FLDEFF_UNK_42);
+    FieldEffectStart(FLDEFF_DOUBLE_EXCL_MARK_ICON);
     sprite->data[2] = 1;
     return TRUE;
 }
 
-bool8 sub_80669B0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 do_smile_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]);
-    FieldEffectStart(FLDEFF_UNK_40);
+    FieldEffectStart(FLDEFF_SMILEY_FACE_ICON);
     sprite->data[2] = 1;
     return TRUE;
 }
@@ -6529,7 +6525,7 @@ bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *objectEvent, struct
 {
     if (objectEvent->movementType == MOVEMENT_TYPE_HIDDEN)
     {
-        sub_80824EC(objectEvent);
+        MovementAction_RevealTrainer_RunTrainerSeeFuncList(objectEvent);
         return FALSE;
     }
     if (objectEvent->movementType != MOVEMENT_TYPE_TREE_DISGUISE && objectEvent->movementType != MOVEMENT_TYPE_MOUNTAIN_DISGUISE)
@@ -6686,25 +6682,25 @@ void sub_8066C70(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire
     sprite->data[2] = 1;
 }
 
-bool8 sub_8066CB0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x70_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066C70(objectEvent, sprite, DIR_SOUTH);
     return TRUE;
 }
 
-bool8 sub_8066CC0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x71_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066C70(objectEvent, sprite, DIR_NORTH);
     return TRUE;
 }
 
-bool8 sub_8066CD0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x72_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066C70(objectEvent, sprite, DIR_WEST);
     return TRUE;
 }
 
-bool8 sub_8066CE0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x73_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_8066C70(objectEvent, sprite, DIR_EAST);
     return TRUE;
@@ -6993,25 +6989,25 @@ bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *objectEvent,
     return FALSE;
 }
 
-bool8 sub_8067304(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x88_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetFishingDirectionAnimNum(DIR_SOUTH), 8);
     return MovementAction_WalkInPlace_Step1(objectEvent, sprite);
 }
 
-bool8 sub_806733C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x89_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_80656C4(objectEvent, sprite, DIR_NORTH, GetFishingDirectionAnimNum(DIR_NORTH), 8);
     return MovementAction_WalkInPlace_Step1(objectEvent, sprite);
 }
 
-bool8 sub_8067374(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x8A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_80656C4(objectEvent, sprite, DIR_WEST, GetFishingDirectionAnimNum(DIR_WEST), 8);
     return MovementAction_WalkInPlace_Step1(objectEvent, sprite);
 }
 
-bool8 sub_80673AC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x8B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_80656C4(objectEvent, sprite, DIR_EAST, GetFishingDirectionAnimNum(DIR_EAST), 8);
     return MovementAction_WalkInPlace_Step1(objectEvent, sprite);
@@ -7165,13 +7161,13 @@ void sub_806764C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire
     SeekSpriteAnim(sprite, 0);
 }
 
-bool8 sub_8067684(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x94_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_806764C(objectEvent, sprite, DIR_SOUTH, 1);
-    return sub_80676A4(objectEvent, sprite);
+    return MovementActionFunc_x94_1(objectEvent, sprite);
 }
 
-bool8 sub_80676A4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x94_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite))
     {
@@ -7181,13 +7177,13 @@ bool8 sub_80676A4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80676C4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x95_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_806764C(objectEvent, sprite, DIR_NORTH, 1);
-    return sub_80676E4(objectEvent, sprite);
+    return MovementActionFunc_x95_1(objectEvent, sprite);
 }
 
-bool8 sub_80676E4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x95_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite))
     {
@@ -7197,13 +7193,13 @@ bool8 sub_80676E4(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8067704(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x96_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_806764C(objectEvent, sprite, DIR_WEST,  1);
-    return sub_8067724(objectEvent, sprite);
+    return MovementActionFunc_x96_1(objectEvent, sprite);
 }
 
-bool8 sub_8067724(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x96_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite))
     {
@@ -7213,13 +7209,13 @@ bool8 sub_8067724(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8067744(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x97_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sub_806764C(objectEvent, sprite, DIR_EAST, 1);
-    return sub_8067764(objectEvent, sprite);
+    return MovementActionFunc_x97_1(objectEvent, sprite);
 }
 
-bool8 sub_8067764(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x97_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite))
     {
@@ -7229,7 +7225,7 @@ bool8 sub_8067764(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8067784(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x98_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     StartSpriteAnim(sprite, 20);
     sprite->animPaused = FALSE;
@@ -7242,12 +7238,12 @@ bool8 sub_8067784(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80677C0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x98_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     return sprite->animEnded;
 }
 
-bool8 sub_80677CC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x99_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     s32 y;
     switch (sprite->data[7])
@@ -7294,7 +7290,7 @@ bool8 sub_80677CC(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_80678C0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     bool8 ret;
     sprite->data[7] = (sprite->data[7] + 4) & 0xFF;
@@ -7306,7 +7302,7 @@ bool8 sub_80678C0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return ret;
 }
 
-bool8 sub_80678F0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     StartSpriteAnim(sprite, 28);
     sprite->animPaused = FALSE;
@@ -7315,7 +7311,7 @@ bool8 sub_80678F0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8067924(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_x9F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     return sprite->animEnded;
 }
@@ -7331,14 +7327,14 @@ bool8 MovementAction_PauseSpriteAnim(struct ObjectEvent *objectEvent, struct Spr
     return TRUE;
 }
 
-bool8 sub_8067944(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA4_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sprite->pos2.y = 0;
     sprite->data[2]++;
     return FALSE;
 }
 
-bool8 sub_8067954(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA4_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sprite->pos2.y -= 8;
     if (sprite->pos2.y == -160)
@@ -7346,14 +7342,14 @@ bool8 sub_8067954(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-bool8 sub_8067978(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA5_0(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sprite->pos2.y = -160;
     sprite->data[2]++;
     return FALSE;
 }
 
-bool8 sub_806798C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+bool8 MovementActionFunc_xA5_1(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     sprite->pos2.y += 8;
     if (sprite->pos2.y == 0)
@@ -7361,7 +7357,7 @@ bool8 sub_806798C(struct ObjectEvent *objectEvent, struct Sprite *sprite)
     return FALSE;
 }
 
-u8 sub_80679A8(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+u8 MovementActionFunc_xA4_2(struct ObjectEvent *objectEvent, struct Sprite *sprite)
 {
     return TRUE;
 }
diff --git a/src/evolution_scene.c b/src/evolution_scene.c
index f3b05b32c..71eb3fc36 100644
--- a/src/evolution_scene.c
+++ b/src/evolution_scene.c
@@ -31,8 +31,6 @@
 #include "text.h"
 #include "text_window.h"
 #include "trig.h"
-#include "trade.h"
-#include "util.h"
 #include "battle_string_ids.h"
 #include "constants/species.h"
 #include "constants/songs.h"
diff --git a/src/fame_checker.c b/src/fame_checker.c
index c9a8aac5a..7b71610ed 100644
--- a/src/fame_checker.c
+++ b/src/fame_checker.c
@@ -1536,7 +1536,7 @@ static void PlaceListMenuCursor(bool8 isActive)
 {
     u16 cursorY = ListMenuGetYCoordForPrintingArrowCursor(sFameCheckerData->listMenuTaskId);
     if (isActive == TRUE)
-        AddTextPrinterParameterized4(FCWINDOWID_LIST, 2, 0, cursorY, 0, 0, sTextColor_DkGrey, 0, gFameCheckerText_ListMenuCursor);
+        AddTextPrinterParameterized4(FCWINDOWID_LIST, 2, 0, cursorY, 0, 0, sTextColor_DkGrey, 0, gText_SelectorArrow2);
     else
-        AddTextPrinterParameterized4(FCWINDOWID_LIST, 2, 0, cursorY, 0, 0, sTextColor_White, 0, gFameCheckerText_ListMenuCursor);
+        AddTextPrinterParameterized4(FCWINDOWID_LIST, 2, 0, cursorY, 0, 0, sTextColor_White, 0, gText_SelectorArrow2);
 }
diff --git a/src/field_camera.c b/src/field_camera.c
new file mode 100644
index 000000000..40ab8f464
--- /dev/null
+++ b/src/field_camera.c
@@ -0,0 +1,572 @@
+#include "global.h"
+#include "gflib.h"
+#include "field_camera.h"
+#include "field_player_avatar.h"
+#include "fieldmap.h"
+#include "event_object_movement.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+
+EWRAM_DATA bool8 gUnusedBikeCameraAheadPanback = FALSE;
+
+// Static type declarations
+struct FieldCameraOffset
+{
+    u8 xPixelOffset;
+    u8 yPixelOffset;
+    u8 xTileOffset;
+    u8 yTileOffset;
+    bool8 copyBGToVRAM;
+};
+
+// static functions
+static void RedrawMapSliceNorth(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout);
+static void RedrawMapSliceSouth(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout);
+static void RedrawMapSliceEast(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout);
+static void RedrawMapSliceWest(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout);
+static s32 MapPosToBgTilemapOffset(struct FieldCameraOffset *a, s32 x, s32 y);
+static void DrawWholeMapViewInternal(int x, int y, const struct MapLayout *mapLayout);
+static void DrawMetatileAt(const struct MapLayout *mapLayout, u16, int, int);
+static void DrawMetatile(s32 a, const u16 *b, u16 c);
+static void CameraPanningCB_PanAhead(void);
+
+// IWRAM bss vars
+static struct FieldCameraOffset sFieldCameraOffset;
+static s16 sHorizontalCameraPan;
+static s16 sVerticalCameraPan;
+static u8 gUnknown_3000E9C;
+static void (*sFieldCameraPanningCallback)(void);
+
+struct CameraObject gFieldCamera;
+u16 gTotalCameraPixelOffsetY;
+u16 gTotalCameraPixelOffsetX;
+
+// text
+static void move_tilemap_camera_to_upper_left_corner_(struct FieldCameraOffset *cameraOffset)
+{
+    cameraOffset->xTileOffset = 0;
+    cameraOffset->yTileOffset = 0;
+    cameraOffset->xPixelOffset = 0;
+    cameraOffset->yPixelOffset = 0;
+    cameraOffset->copyBGToVRAM = TRUE;
+}
+
+static void tilemap_move_something(struct FieldCameraOffset *cameraOffset, u32 b, u32 c)
+{
+    cameraOffset->xTileOffset += b;
+    cameraOffset->xTileOffset %= 32;
+    cameraOffset->yTileOffset += c;
+    cameraOffset->yTileOffset %= 32;
+}
+
+static void coords8_add(struct FieldCameraOffset *cameraOffset, u32 b, u32 c)
+{
+    cameraOffset->xPixelOffset += b;
+    cameraOffset->yPixelOffset += c;
+}
+
+void move_tilemap_camera_to_upper_left_corner(void)
+{
+    move_tilemap_camera_to_upper_left_corner_(&sFieldCameraOffset);
+}
+
+void FieldUpdateBgTilemapScroll(void)
+{
+    u32 r4, r5;
+    r5 = sFieldCameraOffset.xPixelOffset + sHorizontalCameraPan;
+    r4 = sVerticalCameraPan + sFieldCameraOffset.yPixelOffset + 8;
+
+    SetGpuReg(REG_OFFSET_BG1HOFS, r5);
+    SetGpuReg(REG_OFFSET_BG1VOFS, r4);
+    SetGpuReg(REG_OFFSET_BG2HOFS, r5);
+    SetGpuReg(REG_OFFSET_BG2VOFS, r4);
+    SetGpuReg(REG_OFFSET_BG3HOFS, r5);
+    SetGpuReg(REG_OFFSET_BG3VOFS, r4);
+}
+
+void sub_805A658(s16 *a, s16 *b)
+{
+    *a = sFieldCameraOffset.xPixelOffset + sHorizontalCameraPan;
+    *b = sFieldCameraOffset.yPixelOffset + sVerticalCameraPan + 8;
+}
+
+void DrawWholeMapView(void)
+{
+    DrawWholeMapViewInternal(gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y, gMapHeader.mapLayout);
+   // sFieldCameraOffset.copyBGToVRAM = TRUE;
+}
+
+static void DrawWholeMapViewInternal(int x, int y, const struct MapLayout *mapLayout)
+{
+    u8 i;
+    u8 j;
+    u32 r6;
+    u8 temp;
+
+    for (i = 0; i < 32; i += 2)
+    {
+        temp = sFieldCameraOffset.yTileOffset + i;
+        if (temp >= 32)
+            temp -= 32;
+        r6 = temp * 32;
+        for (j = 0; j < 32; j += 2)
+        {
+            temp = sFieldCameraOffset.xTileOffset + j;
+            if (temp >= 32)
+                temp -= 32;
+            DrawMetatileAt(mapLayout, r6 + temp, x + j / 2, y + i / 2);
+        }
+    }
+}
+
+static void RedrawMapSlicesForCameraUpdate(struct FieldCameraOffset *cameraOffset, int x, int y)
+{
+    const struct MapLayout *mapLayout = gMapHeader.mapLayout;
+
+    if (x > 0)
+        RedrawMapSliceWest(cameraOffset, mapLayout);
+    if (x < 0)
+        RedrawMapSliceEast(cameraOffset, mapLayout);
+    if (y > 0)
+        RedrawMapSliceNorth(cameraOffset, mapLayout);
+    if (y < 0)
+        RedrawMapSliceSouth(cameraOffset, mapLayout);
+    cameraOffset->copyBGToVRAM = TRUE;
+}
+
+static void RedrawMapSliceNorth(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout)
+{
+    u8 i;
+    u8 temp;
+    u32 r7;
+
+    temp = cameraOffset->yTileOffset + 28;
+    if (temp >= 32)
+        temp -= 32;
+    r7 = temp * 32;
+    for (i = 0; i < 32; i += 2)
+    {
+        temp = cameraOffset->xTileOffset + i;
+        if (temp >= 32)
+            temp -= 32;
+        DrawMetatileAt(mapLayout, r7 + temp, gSaveBlock1Ptr->pos.x + i / 2, gSaveBlock1Ptr->pos.y + 14);
+    }
+}
+
+static void RedrawMapSliceSouth(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout)
+{
+    u8 i;
+    u8 temp;
+    u32 r7 = cameraOffset->yTileOffset * 32;
+
+    for (i = 0; i < 32; i += 2)
+    {
+        temp = cameraOffset->xTileOffset + i;
+        if (temp >= 32)
+            temp -= 32;
+        DrawMetatileAt(mapLayout, r7 + temp, gSaveBlock1Ptr->pos.x + i / 2, gSaveBlock1Ptr->pos.y);
+    }
+}
+
+static void RedrawMapSliceEast(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout)
+{
+    u8 i;
+    u8 temp;
+    u32 r6 = cameraOffset->xTileOffset;
+
+    for (i = 0; i < 32; i += 2)
+    {
+        temp = cameraOffset->yTileOffset + i;
+        if (temp >= 32)
+            temp -= 32;
+        DrawMetatileAt(mapLayout, temp * 32 + r6, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y + i / 2);
+    }
+}
+
+static void RedrawMapSliceWest(struct FieldCameraOffset *cameraOffset, const struct MapLayout *mapLayout)
+{
+    u8 i;
+    u8 temp;
+    u8 r5 = cameraOffset->xTileOffset + 28;
+
+    if (r5 >= 32)
+        r5 -= 32;
+    for (i = 0; i < 32; i += 2)
+    {
+        temp = cameraOffset->yTileOffset + i;
+        if (temp >= 32)
+            temp -= 32;
+        DrawMetatileAt(mapLayout, temp * 32 + r5, gSaveBlock1Ptr->pos.x + 14, gSaveBlock1Ptr->pos.y + i / 2);
+    }
+}
+
+void CurrentMapDrawMetatileAt(int x, int y)
+{
+    int offset = MapPosToBgTilemapOffset(&sFieldCameraOffset, x, y);
+
+    if (offset >= 0)
+    {
+        DrawMetatileAt(gMapHeader.mapLayout, offset, x, y);
+       // sFieldCameraOffset.copyBGToVRAM = TRUE;
+    }
+}
+
+void DrawDoorMetatileAt(int x, int y, const u16 *arr)
+{
+    int offset = MapPosToBgTilemapOffset(&sFieldCameraOffset, x, y);
+
+    if (offset >= 0)
+    {
+        DrawMetatile(1, arr, offset);
+       // sFieldCameraOffset.copyBGToVRAM = TRUE;
+    }
+}
+
+static void DrawMetatileAt(const struct MapLayout *mapLayout, u16 offset, int x, int y)
+{
+    u16 metatileId = MapGridGetMetatileIdAt(x, y);
+    u16 *metatiles;
+
+    if (metatileId > NUM_METATILES_TOTAL)
+        metatileId = 0;
+    if (metatileId < NUM_METATILES_IN_PRIMARY)
+        metatiles = mapLayout->primaryTileset->metatiles;
+    else
+    {
+        metatiles = mapLayout->secondaryTileset->metatiles;
+        metatileId -= NUM_METATILES_IN_PRIMARY;
+    }
+    DrawMetatile(MapGridGetMetatileLayerTypeAt(x, y), metatiles + metatileId * 8, offset);
+}
+
+static void DrawMetatile(s32 metatileLayerType, const u16 *metatiles, u16 offset)
+{
+    switch (metatileLayerType)
+    {
+    case 2: // LAYER_TYPE_
+        // Draw metatile's bottom layer to the bottom background layer.
+        gBGTilemapBuffers3[offset] = metatiles[0];
+        gBGTilemapBuffers3[offset + 1] = metatiles[1];
+        gBGTilemapBuffers3[offset + 0x20] = metatiles[2];
+        gBGTilemapBuffers3[offset + 0x21] = metatiles[3];
+
+        // Draw transparent tiles to the middle background layer.
+        gBGTilemapBuffers1[offset] = 0;
+        gBGTilemapBuffers1[offset + 1] = 0;
+        gBGTilemapBuffers1[offset + 0x20] = 0;
+        gBGTilemapBuffers1[offset + 0x21] = 0;
+
+        // Draw metatile's top layer to the top background layer.
+        gBGTilemapBuffers2[offset] = metatiles[4];
+        gBGTilemapBuffers2[offset + 1] = metatiles[5];
+        gBGTilemapBuffers2[offset + 0x20] = metatiles[6];
+        gBGTilemapBuffers2[offset + 0x21] = metatiles[7];
+        break;
+    case 1:  // LAYER_TYPE_COVERED_BY_OBJECTS
+        // Draw metatile's bottom layer to the bottom background layer.
+        gBGTilemapBuffers3[offset] = metatiles[0];
+        gBGTilemapBuffers3[offset + 1] = metatiles[1];
+        gBGTilemapBuffers3[offset + 0x20] = metatiles[2];
+        gBGTilemapBuffers3[offset + 0x21] = metatiles[3];
+
+        // Draw metatile's top layer to the middle background layer.
+        gBGTilemapBuffers1[offset] = metatiles[4];
+        gBGTilemapBuffers1[offset + 1] = metatiles[5];
+        gBGTilemapBuffers1[offset + 0x20] = metatiles[6];
+        gBGTilemapBuffers1[offset + 0x21] = metatiles[7];
+
+        // Draw transparent tiles to the top background layer.
+        gBGTilemapBuffers2[offset] = 0;
+        gBGTilemapBuffers2[offset + 1] = 0;
+        gBGTilemapBuffers2[offset + 0x20] = 0;
+        gBGTilemapBuffers2[offset + 0x21] = 0;
+        break;
+    case 0: // LAYER_TYPE_NORMAL
+        // Draw garbage to the bottom background layer.
+        gBGTilemapBuffers3[offset] = 0x3014;
+        gBGTilemapBuffers3[offset + 1] = 0x3014;
+        gBGTilemapBuffers3[offset + 0x20] = 0x3014;
+        gBGTilemapBuffers3[offset + 0x21] = 0x3014;
+
+        // Draw metatile's bottom layer to the middle background layer.
+        gBGTilemapBuffers1[offset] = metatiles[0];
+        gBGTilemapBuffers1[offset + 1] = metatiles[1];
+        gBGTilemapBuffers1[offset + 0x20] = metatiles[2];
+        gBGTilemapBuffers1[offset + 0x21] = metatiles[3];
+
+        // Draw metatile's top layer to the top background layer, which covers object event sprites.
+        gBGTilemapBuffers2[offset] = metatiles[4];
+        gBGTilemapBuffers2[offset + 1] = metatiles[5];
+        gBGTilemapBuffers2[offset + 0x20] = metatiles[6];
+        gBGTilemapBuffers2[offset + 0x21] = metatiles[7];
+        break;
+    }
+    ScheduleBgCopyTilemapToVram(1);
+    ScheduleBgCopyTilemapToVram(2);
+    ScheduleBgCopyTilemapToVram(3);
+}
+
+static s32 MapPosToBgTilemapOffset(struct FieldCameraOffset *cameraOffset, s32 x, s32 y)
+{
+    x -= gSaveBlock1Ptr->pos.x;
+    x *= 2;
+    if (x >= 32 || x < 0)
+        return -1;
+    x = x + cameraOffset->xTileOffset;
+    if (x >= 32)
+        x -= 32;
+
+    y = (y - gSaveBlock1Ptr->pos.y) * 2;
+    if (y >= 32 || y < 0)
+        return -1;
+    y = y + cameraOffset->yTileOffset;
+    if (y >= 32)
+        y -= 32;
+
+    return y * 32 + x;
+}
+
+static void CameraUpdateCallback(struct CameraObject *fieldCamera)
+{
+    if (fieldCamera->spriteId != 0)
+    {
+        fieldCamera->movementSpeedX = gSprites[fieldCamera->spriteId].data[2];
+        fieldCamera->movementSpeedY = gSprites[fieldCamera->spriteId].data[3];
+    }
+}
+
+void ResetCameraUpdateInfo(void)
+{
+    gFieldCamera.movementSpeedX = 0;
+    gFieldCamera.movementSpeedY = 0;
+    gFieldCamera.x = 0;
+    gFieldCamera.y = 0;
+    gFieldCamera.spriteId = 0;
+    gFieldCamera.callback = NULL;
+}
+
+u32 InitCameraUpdateCallback(u8 trackedSpriteId)
+{
+    if (gFieldCamera.spriteId != 0)
+        DestroySprite(&gSprites[gFieldCamera.spriteId]);
+    gFieldCamera.spriteId = AddCameraObject(trackedSpriteId);
+    gFieldCamera.callback = CameraUpdateCallback;
+    return 0;
+}
+
+void CameraUpdate(void)
+{
+    int deltaX;
+    int deltaY;
+    int curMovementOffsetY;
+    int curMovementOffsetX;
+    int movementSpeedX;
+    int movementSpeedY;
+
+    if (gFieldCamera.callback != NULL)
+        gFieldCamera.callback(&gFieldCamera);
+    movementSpeedX = gFieldCamera.movementSpeedX;
+    movementSpeedY = gFieldCamera.movementSpeedY;
+    deltaX = 0;
+    deltaY = 0;
+    curMovementOffsetX = gFieldCamera.x;
+    curMovementOffsetY = gFieldCamera.y;
+
+
+    if (curMovementOffsetX == 0 && movementSpeedX != 0)
+    {
+        if (movementSpeedX > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+    if (curMovementOffsetY == 0 && movementSpeedY != 0)
+    {
+        if (movementSpeedY > 0)
+            deltaY = 1;
+        else
+            deltaY = -1;
+    }
+    if (curMovementOffsetX != 0 && curMovementOffsetX == -movementSpeedX)
+    {
+        if (movementSpeedX > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+    if (curMovementOffsetY != 0 && curMovementOffsetY == -movementSpeedY)
+    {
+        if (movementSpeedY > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+
+    gFieldCamera.x += movementSpeedX;
+    gFieldCamera.x = gFieldCamera.x - 16 * (gFieldCamera.x / 16);
+    gFieldCamera.y += movementSpeedY;
+    gFieldCamera.y = gFieldCamera.y - 16 * (gFieldCamera.y / 16);
+
+    if (deltaX != 0 || deltaY != 0)
+    {
+        CameraMove(deltaX, deltaY);
+        UpdateObjectEventsForCameraUpdate(deltaX, deltaY);
+        // RotatingGatePuzzleCameraUpdate(deltaX, deltaY);
+        // ResetBerryTreeSparkleFlags();
+        tilemap_move_something(&sFieldCameraOffset, deltaX * 2, deltaY * 2);
+        RedrawMapSlicesForCameraUpdate(&sFieldCameraOffset, deltaX * 2, deltaY * 2);
+    }
+
+    coords8_add(&sFieldCameraOffset, movementSpeedX, movementSpeedY);
+    gTotalCameraPixelOffsetX -= movementSpeedX;
+    gTotalCameraPixelOffsetY -= movementSpeedY;
+}
+
+void MoveCameraAndRedrawMap(int deltaX, int deltaY) // unused
+{
+    CameraMove(deltaX, deltaY);
+    UpdateObjectEventsForCameraUpdate(deltaX, deltaY);
+    DrawWholeMapView();
+    gTotalCameraPixelOffsetX -= deltaX * 16;
+    gTotalCameraPixelOffsetY -= deltaY * 16;
+}
+
+void sub_805ACF0(void)
+{
+    int deltaX;
+    int deltaY;
+    int curMovementOffsetY;
+    int curMovementOffsetX;
+    int movementSpeedX;
+    int movementSpeedY;
+
+    if (gFieldCamera.callback != NULL)
+        gFieldCamera.callback(&gFieldCamera);
+    movementSpeedX = gFieldCamera.movementSpeedX;
+    movementSpeedY = gFieldCamera.movementSpeedY;
+    deltaX = 0;
+    deltaY = 0;
+    curMovementOffsetX = gFieldCamera.x;
+    curMovementOffsetY = gFieldCamera.y;
+
+
+    if (curMovementOffsetX == 0 && movementSpeedX != 0)
+    {
+        if (movementSpeedX > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+    if (curMovementOffsetY == 0 && movementSpeedY != 0)
+    {
+        if (movementSpeedY > 0)
+            deltaY = 1;
+        else
+            deltaY = -1;
+    }
+    if (curMovementOffsetX != 0 && curMovementOffsetX == -movementSpeedX)
+    {
+        if (movementSpeedX > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+    if (curMovementOffsetY != 0 && curMovementOffsetY == -movementSpeedY)
+    {
+        if (movementSpeedY > 0)
+            deltaX = 1;
+        else
+            deltaX = -1;
+    }
+
+    gFieldCamera.x += movementSpeedX;
+    gFieldCamera.x = gFieldCamera.x - 16 * (gFieldCamera.x / 16);
+    gFieldCamera.y += movementSpeedY;
+    gFieldCamera.y = gFieldCamera.y - 16 * (gFieldCamera.y / 16);
+
+    if (deltaX != 0 || deltaY != 0)
+    {
+        CameraMove(deltaX, deltaY);
+        // UpdateObjectEventsForCameraUpdate(deltaX, deltaY);
+        // RotatingGatePuzzleCameraUpdate(deltaX, deltaY);
+        // ResetBerryTreeSparkleFlags();
+        tilemap_move_something(&sFieldCameraOffset, deltaX * 2, deltaY * 2);
+        RedrawMapSlicesForCameraUpdate(&sFieldCameraOffset, deltaX * 2, deltaY * 2);
+    }
+
+    coords8_add(&sFieldCameraOffset, movementSpeedX, movementSpeedY);
+    // gTotalCameraPixelOffsetX -= movementSpeedX;
+    // gTotalCameraPixelOffsetY -= movementSpeedY;
+}
+
+void SetCameraPanningCallback(void (*a)(void))
+{
+    sFieldCameraPanningCallback = a;
+}
+
+void SetCameraPanning(s16 a, s16 b)
+{
+    sHorizontalCameraPan = a;
+    sVerticalCameraPan = b + 32;
+}
+
+void InstallCameraPanAheadCallback(void)
+{
+    sFieldCameraPanningCallback = CameraPanningCB_PanAhead;
+    gUnknown_3000E9C = 0;
+    sHorizontalCameraPan = 0;
+    sVerticalCameraPan = 32;
+}
+
+void UpdateCameraPanning(void)
+{
+    if (sFieldCameraPanningCallback != NULL)
+        sFieldCameraPanningCallback();
+    // Update sprite offset of overworld objects
+    gSpriteCoordOffsetX = gTotalCameraPixelOffsetX - sHorizontalCameraPan;
+    gSpriteCoordOffsetY = gTotalCameraPixelOffsetY - sVerticalCameraPan - 8;
+}
+
+static void CameraPanningCB_PanAhead(void)
+{
+    u8 var;
+
+    if (gUnusedBikeCameraAheadPanback == FALSE)
+    {
+        InstallCameraPanAheadCallback();
+    }
+    else
+    {
+        // this code is never reached.
+        if (gPlayerAvatar.tileTransitionState == 1)
+        {
+            gUnknown_3000E9C ^= 1;
+            if (gUnknown_3000E9C == 0)
+                return;
+        }
+        else
+        {
+            gUnknown_3000E9C = 0;
+        }
+
+        var = GetPlayerMovementDirection();
+        if (var == 2)
+        {
+            if (sVerticalCameraPan > -8)
+                sVerticalCameraPan -= 2;
+        }
+        else if (var == 1)
+        {
+            if (sVerticalCameraPan < 72)
+                sVerticalCameraPan += 2;
+        }
+        else if (sVerticalCameraPan < 32)
+        {
+            sVerticalCameraPan += 2;
+        }
+        else if (sVerticalCameraPan > 32)
+        {
+            sVerticalCameraPan -= 2;
+        }
+    }
+}
diff --git a/src/field_door.c b/src/field_door.c
index cbf7a79ea..e17ef0d5a 100644
--- a/src/field_door.c
+++ b/src/field_door.c
@@ -4,6 +4,10 @@
 #include "fieldmap.h"
 #include "metatile_behavior.h"
 #include "constants/songs.h"
+#include "constants/metatile_labels.h"
+
+#define DOOR_SOUND_NORMAL  0
+#define DOOR_SOUND_SLIDING 1
 
 struct DoorAnimFrame
 {
@@ -14,7 +18,7 @@ struct DoorAnimFrame
 struct DoorGraphics
 {
     u16 metatileId;
-    s8 sliding;
+    u8 sound;
     u8 size;
     const u8 * tiles;
     const u8 * palettes;
@@ -26,204 +30,148 @@ static void SetDoorFramePalettes(const struct DoorGraphics * gfx, int x, int y,
 static void BufferDoorFrameTilesWithPalettes(u16 *a0, u16 a1, const u8 *a2);
 static bool32 PlayDoorAnimationFrame(const struct DoorGraphics * gfx, const struct DoorAnimFrame * frames, s16 *data);
 static const struct DoorAnimFrame * SeekToEndOfDoorAnim(const struct DoorAnimFrame * frames);
-static s8 GetDoorOpenType(const struct DoorGraphics * gfx, int x, int y);
-
-static const u8 gUnknown_8353088[] = INCBIN_U8("graphics/door_anims/frame_8353088_1.4bpp", "graphics/door_anims/frame_8353088_2.4bpp", "graphics/door_anims/frame_8353088_3.4bpp");
-static const u8 gUnknown_8353208[32] = {};
-static const u8 gUnknown_8353228[] = INCBIN_U8("graphics/door_anims/frame_8353228_1.4bpp", "graphics/door_anims/frame_8353228_2.4bpp", "graphics/door_anims/frame_8353228_3.4bpp");
-static const u8 gUnknown_83533A8[32] = {};
-static const u8 gUnknown_83533C8[] = INCBIN_U8("graphics/door_anims/frame_83533C8_1.4bpp", "graphics/door_anims/frame_83533C8_2.4bpp", "graphics/door_anims/frame_83533C8_3.4bpp");
-static const u8 gUnknown_8353548[32] = {};
-static const u8 gUnknown_8353568[] = INCBIN_U8("graphics/door_anims/frame_8353568_1.4bpp", "graphics/door_anims/frame_8353568_2.4bpp", "graphics/door_anims/frame_8353568_3.4bpp");
-static const u8 gUnknown_83536E8[32] = {};
-static const u8 gUnknown_8353708[] = INCBIN_U8("graphics/door_anims/frame_8353708_1.4bpp", "graphics/door_anims/frame_8353708_2.4bpp", "graphics/door_anims/frame_8353708_3.4bpp");
-static const u8 gUnknown_8353888[32] = {};
-static const u8 gUnknown_83538A8[] = INCBIN_U8("graphics/door_anims/frame_83538A8_1.4bpp", "graphics/door_anims/frame_83538A8_2.4bpp", "graphics/door_anims/frame_83538A8_3.4bpp");
-static const u8 gUnknown_8353A28[32] = {};
-static const u8 gUnknown_8353A48[] = INCBIN_U8("graphics/door_anims/frame_8353A48_1.4bpp", "graphics/door_anims/frame_8353A48_2.4bpp", "graphics/door_anims/frame_8353A48_3.4bpp");
-static const u8 gUnknown_8353BC8[32] = {};
-static const u8 gUnknown_8353BE8[] = INCBIN_U8("graphics/door_anims/frame_8353BE8_1.4bpp", "graphics/door_anims/frame_8353BE8_2.4bpp", "graphics/door_anims/frame_8353BE8_3.4bpp");
-static const u8 gUnknown_8353D68[32] = {};
-static const u8 gUnknown_8353D88[] = INCBIN_U8("graphics/door_anims/frame_8353D88_1.4bpp", "graphics/door_anims/frame_8353D88_2.4bpp", "graphics/door_anims/frame_8353D88_3.4bpp");
-static const u8 gUnknown_8353F08[32] = {};
-static const u8 gUnknown_8353F28[] = INCBIN_U8("graphics/door_anims/frame_8353F28_1.4bpp", "graphics/door_anims/frame_8353F28_2.4bpp", "graphics/door_anims/frame_8353F28_3.4bpp");
-static const u8 gUnknown_83540A8[32] = {};
-static const u8 gUnknown_83540C8[] = INCBIN_U8("graphics/door_anims/frame_83540C8_1.4bpp", "graphics/door_anims/frame_83540C8_2.4bpp", "graphics/door_anims/frame_83540C8_3.4bpp");
-static const u8 gUnknown_8354248[32] = {};
-static const u8 gUnknown_8354268[] = INCBIN_U8("graphics/door_anims/frame_8354268_1.4bpp", "graphics/door_anims/frame_8354268_2.4bpp", "graphics/door_anims/frame_8354268_3.4bpp");
-static const u8 gUnknown_83543E8[32] = {};
-static const u8 gUnknown_8354408[] = INCBIN_U8("graphics/door_anims/frame_8354408_1.4bpp", "graphics/door_anims/frame_8354408_2.4bpp", "graphics/door_anims/frame_8354408_3.4bpp");
-static const u8 gUnknown_8354588[32] = {};
-static const u8 gUnknown_83545A8[] = INCBIN_U8("graphics/door_anims/frame_83545A8_1.4bpp", "graphics/door_anims/frame_83545A8_2.4bpp", "graphics/door_anims/frame_83545A8_3.4bpp");
-static const u8 gUnknown_8354728[32] = {};
-static const u8 gUnknown_8354748[] = INCBIN_U8("graphics/door_anims/frame_8354748_1.4bpp", "graphics/door_anims/frame_8354748_2.4bpp", "graphics/door_anims/frame_8354748_3.4bpp");
-static const u8 gUnknown_83548C8[32] = {};
-static const u8 gUnknown_83548E8[] = INCBIN_U8("graphics/door_anims/frame_83548E8_1.4bpp", "graphics/door_anims/frame_83548E8_2.4bpp", "graphics/door_anims/frame_83548E8_3.4bpp");
-static const u8 gUnknown_8354A68[32] = {};
-static const u8 gUnknown_8354A88[] = INCBIN_U8("graphics/door_anims/frame_8354A88_1.4bpp", "graphics/door_anims/frame_8354A88_2.4bpp", "graphics/door_anims/frame_8354A88_3.4bpp");
-static const u8 gUnknown_8354C08[32] = {};
-static const u8 gUnknown_8354C28[] = INCBIN_U8("graphics/door_anims/frame_8354C28_1.4bpp", "graphics/door_anims/frame_8354C28_2.4bpp", "graphics/door_anims/frame_8354C28_3.4bpp");
-static const u8 gUnknown_8354F28[32] = {};
-static const u8 gUnknown_8354F48[] = INCBIN_U8("graphics/door_anims/frame_8354F48_1.4bpp", "graphics/door_anims/frame_8354F48_2.4bpp", "graphics/door_anims/frame_8354F48_3.4bpp");
-static const u8 gUnknown_8355248[32] = {};
-static const u8 gUnknown_8355268[] = INCBIN_U8("graphics/door_anims/frame_8355268_1.4bpp", "graphics/door_anims/frame_8355268_2.4bpp", "graphics/door_anims/frame_8355268_3.4bpp");
-static const u8 gUnknown_8355568[32] = {};
-static const u8 gUnknown_8355588[] = INCBIN_U8("graphics/door_anims/frame_8355588_1.4bpp", "graphics/door_anims/frame_8355588_2.4bpp", "graphics/door_anims/frame_8355588_3.4bpp");
-static const u8 gUnknown_8355888[32] = {};
-static const u8 gUnknown_83558A8[256] = {};
-static const u8 gUnknown_83559A8[256] = {};
-static const u8 gUnknown_8355AA8[256] = {};
-static const u8 gUnknown_8355BA8[32] = {};
-static const u8 gUnknown_8355BC8[256] = {};
-static const u8 gUnknown_8355CC8[256] = {};
-static const u8 gUnknown_8355DC8[256] = {};
-static const u8 gUnknown_8355EC8[32] = {};
-static const u8 gUnknown_8355EE8[256] = {};
-static const u8 gUnknown_8355FE8[256] = {};
-static const u8 gUnknown_83560E8[256] = {};
-static const u8 gUnknown_83561E8[32] = {};
-static const u8 gUnknown_8356208[256] = {};
-static const u8 gUnknown_8356308[256] = {};
-static const u8 gUnknown_8356408[256] = {};
-static const u8 gUnknown_8356508[32] = {};
-static const u8 gUnknown_8356528[256] = {};
-static const u8 gUnknown_8356628[256] = {};
-static const u8 gUnknown_8356728[256] = {};
-static const u8 gUnknown_8356828[32] = {};
-static const u8 gUnknown_8356848[256] = {};
-static const u8 gUnknown_8356948[256] = {};
-static const u8 gUnknown_8356A48[256] = {};
-static const u8 gUnknown_8356B48[32] = {};
-static const u8 gUnknown_8356B68[256] = {};
-static const u8 gUnknown_8356C68[256] = {};
-static const u8 gUnknown_8356D68[256] = {};
-static const u8 gUnknown_8356E68[32] = {};
-static const u8 gUnknown_8356E88[128] = {};
-static const u8 gUnknown_8356F08[128] = {};
-static const u8 gUnknown_8356F88[128] = {};
-static const u8 gUnknown_8357008[32] = {};
-static const u8 gUnknown_8357028[128] = {};
-static const u8 gUnknown_83570A8[128] = {};
-static const u8 gUnknown_8357128[128] = {};
-static const u8 gUnknown_83571A8[32] = {};
-static const u8 gUnknown_83571C8[128] = {};
-static const u8 gUnknown_8357248[128] = {};
-static const u8 gUnknown_83572C8[128] = {};
-static const u8 gUnknown_8357348[32] = {};
-static const u8 gUnknown_8357368[128] = {};
-static const u8 gUnknown_83573E8[128] = {};
-static const u8 gUnknown_8357468[128] = {};
-static const u8 gUnknown_83574E8[32] = {};
-static const u8 gUnknown_8357508[128] = {};
-static const u8 gUnknown_8357588[128] = {};
-static const u8 gUnknown_8357608[128] = {};
-static const u8 gUnknown_8357688[32] = {};
-static const u8 gUnknown_83576A8[128] = {};
-static const u8 gUnknown_8357728[128] = {};
-static const u8 gUnknown_83577A8[128] = {};
-static const u8 gUnknown_8357828[32] = {};
-static const u8 gUnknown_8357848[128] = {};
-static const u8 gUnknown_83578C8[128] = {};
-static const u8 gUnknown_8357948[128] = {};
-static const u8 gUnknown_83579C8[32] = {};
-static const u8 gUnknown_83579E8[128] = {};
-static const u8 gUnknown_8357A68[128] = {};
-static const u8 gUnknown_8357AE8[128] = {};
-static const u8 gUnknown_8357B68[32] = {};
-static const u8 gUnknown_8357B88[128] = {};
-static const u8 gUnknown_8357C08[128] = {};
-static const u8 gUnknown_8357C88[128] = {};
-static const u8 gUnknown_8357D08[32] = {};
-static const u8 gUnknown_8357D28[128] = {};
-static const u8 gUnknown_8357DA8[128] = {};
-static const u8 gUnknown_8357E28[128] = {};
-static const u8 gUnknown_8357EA8[32] = {};
-static const u8 gUnknown_8357EC8[128] = {};
-static const u8 gUnknown_8357F48[128] = {};
-static const u8 gUnknown_8357FC8[128] = {};
-static const u8 gUnknown_8358048[32] = {};
-static const u8 gUnknown_8358068[128] = {};
-static const u8 gUnknown_83580E8[128] = {};
-static const u8 gUnknown_8358168[128] = {};
-static const u8 gUnknown_83581E8[32] = {};
-static const u8 gUnknown_8358208[128] = {};
-static const u8 gUnknown_8358288[128] = {};
-static const u8 gUnknown_8358308[128] = {};
-static const u8 gUnknown_8358388[32] = {};
-static const u8 gUnknown_83583A8[128] = {};
-static const u8 gUnknown_8358428[128] = {};
-static const u8 gUnknown_83584A8[128] = {};
-static const u8 gUnknown_8358528[32] = {};
-static const u8 gUnknown_8358548[128] = {};
-static const u8 gUnknown_83585C8[128] = {};
-static const u8 gUnknown_8358648[128] = {};
-static const u8 gUnknown_83586C8[32] = {};
-static const u8 gUnknown_83586E8[128] = {};
-static const u8 gUnknown_8358768[128] = {};
-static const u8 gUnknown_83587E8[128] = {};
-static const u8 gUnknown_8358868[32] = {};
-static const u8 gUnknown_8358888[128] = {};
-static const u8 gUnknown_8358908[128] = {};
-static const u8 gUnknown_8358988[128] = {};
-static const u8 gUnknown_8358A08[32] = {};
-static const u8 gUnknown_8358A28[128] = {};
-static const u8 gUnknown_8358AA8[128] = {};
-static const u8 gUnknown_8358B28[128] = {};
-static const u8 gUnknown_8358BA8[32] = {};
-static const u8 gUnknown_8358BC8[128] = {};
-static const u8 gUnknown_8358C48[128] = {};
-static const u8 gUnknown_8358CC8[128] = {};
-static const u8 gUnknown_8358D48[32] = {};
-static const u8 gUnknown_8358D68[128] = {};
-static const u8 gUnknown_8358DE8[128] = {};
-static const u8 gUnknown_8358E68[128] = {};
-static const u8 gUnknown_8358EE8[32] = {};
-static const u8 gUnknown_8358F08[128] = {};
-static const u8 gUnknown_8358F88[128] = {};
-static const u8 gUnknown_8359008[128] = {};
-static const u8 gUnknown_8359088[32] = {};
-static const u8 gUnknown_83590A8[128] = {};
-static const u8 gUnknown_8359128[128] = {};
-static const u8 gUnknown_83591A8[128] = {};
-static const u8 gUnknown_8359228[32] = {};
-static const u8 gUnknown_8359248[128] = {};
-static const u8 gUnknown_83592C8[128] = {};
-static const u8 gUnknown_8359348[128] = {};
-static const u8 gUnknown_83593C8[32] = {};
-static const u8 gUnknown_83593E8[128] = {};
-static const u8 gUnknown_8359468[128] = {};
-static const u8 gUnknown_83594E8[128] = {};
-static const u8 gUnknown_8359568[32] = {};
-static const u8 gUnknown_8359588[] = INCBIN_U8("graphics/door_anims/frame_8359588_1.4bpp", "graphics/door_anims/frame_8359588_2.4bpp");
-static const u8 gUnknown_8359688[256] = {};
-static const u8 gUnknown_8359788[] = INCBIN_U8("graphics/door_anims/frame_8359788_1.4bpp", "graphics/door_anims/frame_8359788_2.4bpp", "graphics/door_anims/frame_8359788_3.4bpp", "graphics/door_anims/frame_8359788_4.4bpp");
-static const u8 gUnknown_8359888[256] = {};
-static const u8 gUnknown_8359988[] = INCBIN_U8("graphics/door_anims/frame_8359988_1.4bpp", "graphics/door_anims/frame_8359988_2.4bpp", "graphics/door_anims/frame_8359988_3.4bpp", "graphics/door_anims/frame_8359988_4.4bpp");
-static const u8 gUnknown_8359A88[256] = {};
-static const u8 gUnknown_8359B88[] = INCBIN_U8("graphics/door_anims/frame_8359B88_1.4bpp", "graphics/door_anims/frame_8359B88_2.4bpp", "graphics/door_anims/frame_8359B88_3.4bpp", "graphics/door_anims/frame_8359B88_4.4bpp");
-static const u8 gUnknown_8359C88[32] = {};
-static const u8 gUnknown_8359CA8[] = INCBIN_U8("graphics/door_anims/frame_8359CA8_1.4bpp", "graphics/door_anims/frame_8359CA8_2.4bpp", "graphics/door_anims/frame_8359CA8_3.4bpp");
-static const u8 gUnknown_8359FA8[32] = {};
-static const u8 gUnknown_8359FC8[] = INCBIN_U8("graphics/door_anims/frame_8359FC8_1.4bpp", "graphics/door_anims/frame_8359FC8_2.4bpp", "graphics/door_anims/frame_8359FC8_3.4bpp");
-static const u8 gUnknown_835A148[32] = {};
-static const u8 gUnknown_835A168[] = INCBIN_U8("graphics/door_anims/frame_835A168_1.4bpp", "graphics/door_anims/frame_835A168_2.4bpp", "graphics/door_anims/frame_835A168_3.4bpp");
-static const u8 gUnknown_835A2E8[32] = {};
-static const u8 gUnknown_835A308[] = INCBIN_U8("graphics/door_anims/frame_835A308_1.4bpp", "graphics/door_anims/frame_835A308_2.4bpp", "graphics/door_anims/frame_835A308_3.4bpp");
-static const u8 gUnknown_835A488[32] = {};
-static const u8 gUnknown_835A4A8[] = INCBIN_U8("graphics/door_anims/frame_835A4A8_1.4bpp", "graphics/door_anims/frame_835A4A8_2.4bpp", "graphics/door_anims/frame_835A4A8_3.4bpp");
-static const u8 gUnknown_835A628[32] = {};
-static const u8 gUnknown_835A648[] = INCBIN_U8("graphics/door_anims/frame_835A648_1.4bpp", "graphics/door_anims/frame_835A648_2.4bpp", "graphics/door_anims/frame_835A648_3.4bpp");
-static const u8 gUnknown_835A7C8[32] = {};
-static const u8 gUnknown_835A7E8[] = INCBIN_U8("graphics/door_anims/frame_835A7E8_1.4bpp", "graphics/door_anims/frame_835A7E8_2.4bpp", "graphics/door_anims/frame_835A7E8_3.4bpp");
-static const u8 gUnknown_835A968[32] = {};
-static const u8 gUnknown_835A988[] = INCBIN_U8("graphics/door_anims/frame_835A988_1.4bpp", "graphics/door_anims/frame_835A988_2.4bpp", "graphics/door_anims/frame_835A988_3.4bpp");
-static const u8 gUnknown_835AB08[32] = {};
-static const u8 gUnknown_835AB28[] = INCBIN_U8("graphics/door_anims/frame_835AB28_1.4bpp", "graphics/door_anims/frame_835AB28_2.4bpp", "graphics/door_anims/frame_835AB28_3.4bpp");
-static const u8 gUnknown_835AE28[32] = {};
-static const u8 gUnknown_835AE48[] = INCBIN_U8("graphics/door_anims/frame_835AE48_1.4bpp", "graphics/door_anims/frame_835AE48_2.4bpp", "graphics/door_anims/frame_835AE48_3.4bpp");
-static const u8 gUnknown_835B148[32] = {};
-static const u8 gUnknown_835B168[] = INCBIN_U8("graphics/door_anims/frame_835B168_1.4bpp", "graphics/door_anims/frame_835B168_2.4bpp", "graphics/door_anims/frame_835B168_3.4bpp");
-static const u8 gUnknown_835B468[32] = {};
+static s8 GetDoorSoundType(const struct DoorGraphics * gfx, int x, int y);
+
+static const u8 sDoorAnimTiles_General[] = INCBIN_U8("graphics/door_anims/general.4bpp");
+static const u16 sDoorNullPalette1[16] = {};
+static const u8 sDoorAnimTiles_SlidingSingle[] = INCBIN_U8("graphics/door_anims/sliding_single.4bpp");
+static const u16 sDoorNullPalette2[16] = {};
+static const u8 sDoorAnimTiles_SlidingDouble[] = INCBIN_U8("graphics/door_anims/sliding_double.4bpp");
+static const u16 sDoorNullPalette3[16] = {};
+static const u8 sDoorAnimTiles_Pallet[] = INCBIN_U8("graphics/door_anims/pallet.4bpp");
+static const u16 sDoorNullPalette4[16] = {};
+static const u8 sDoorAnimTiles_OaksLab[] = INCBIN_U8("graphics/door_anims/oaks_lab.4bpp");
+static const u16 sDoorNullPalette5[16] = {};
+static const u8 sDoorAnimTiles_Viridian[] = INCBIN_U8("graphics/door_anims/viridian.4bpp");
+static const u16 sDoorNullPalette6[16] = {};
+static const u8 sDoorAnimTiles_Pewter[] = INCBIN_U8("graphics/door_anims/pewter.4bpp");
+static const u16 sDoorNullPalette7[16] = {};
+static const u8 sDoorAnimTiles_Saffron[] = INCBIN_U8("graphics/door_anims/saffron.4bpp");
+static const u16 sDoorNullPalette8[16] = {};
+static const u8 sDoorAnimTiles_SilphCo[] = INCBIN_U8("graphics/door_anims/silph_co.4bpp");
+static const u16 sDoorNullPalette9[16] = {};
+static const u8 sDoorAnimTiles_Cerulean[] = INCBIN_U8("graphics/door_anims/cerulean.4bpp");
+static const u16 sDoorNullPalette10[16] = {};
+static const u8 sDoorAnimTiles_Lavender[] = INCBIN_U8("graphics/door_anims/lavender.4bpp");
+static const u16 sDoorNullPalette11[16] = {};
+static const u8 sDoorAnimTiles_Vermilion[] = INCBIN_U8("graphics/door_anims/vermilion.4bpp");
+static const u16 sDoorNullPalette12[16] = {};
+static const u8 sDoorAnimTiles_PokemonFanClub[] = INCBIN_U8("graphics/door_anims/pokemon_fan_club.4bpp");
+static const u16 sDoorNullPalette13[16] = {};
+static const u8 sDoorAnimTiles_DeptStore[] = INCBIN_U8("graphics/door_anims/dept_store.4bpp");
+static const u16 sDoorNullPalette14[16] = {};
+static const u8 sDoorAnimTiles_Fuchsia[] = INCBIN_U8("graphics/door_anims/fuchsia.4bpp");
+static const u16 sDoorNullPalette15[16] = {};
+static const u8 sDoorAnimTiles_SafariZone[] = INCBIN_U8("graphics/door_anims/safari_zone.4bpp");
+static const u16 sDoorNullPalette16[16] = {};
+static const u8 sDoorAnimTiles_CinnabarLab[] = INCBIN_U8("graphics/door_anims/cinnabar_lab.4bpp");
+static const u16 sDoorNullPalette17[16] = {};
+static const u8 sDoorAnimTiles_DeptStoreElevator[] = INCBIN_U8("graphics/door_anims/dept_store_elevator.4bpp");
+static const u16 sDoorNullPalette18[16] = {};
+static const u8 sDoorAnimTiles_CableClub[] = INCBIN_U8("graphics/door_anims/cable_club.4bpp");
+static const u16 sDoorNullPalette19[16] = {};
+static const u8 sDoorAnimTiles_HideoutElevator[] = INCBIN_U8("graphics/door_anims/hideout_elevator.4bpp");
+static const u16 sDoorNullPalette20[16] = {};
+static const u8 sDoorAnimTiles_SSAnne[] = INCBIN_U8("graphics/door_anims/ss_anne.4bpp");
+static const u16 sDoorNullPalette21[16] = {};
+
+// Doors from R/S dummied below
+static const u8 sDoorAnimTiles_Empty1[256 * 3] = {};
+static const u16 sDoorNullPalette22[16] = {};
+static const u8 sDoorAnimTiles_Empty2[256 * 3] = {};
+static const u16 sDoorNullPalette23[16] = {};
+static const u8 sDoorAnimTiles_Empty3[256 * 3] = {};
+static const u16 sDoorNullPalette24[16] = {};
+static const u8 sDoorAnimTiles_Empty4[256 * 3] = {};
+static const u16 sDoorNullPalette25[16] = {};
+static const u8 sDoorAnimTiles_Empty5[256 * 3] = {};
+static const u16 sDoorNullPalette26[16] = {};
+static const u8 sDoorAnimTiles_Empty6[256 * 3] = {};
+static const u16 sDoorNullPalette27[16] = {};
+static const u8 sDoorAnimTiles_Empty7[256 * 3] = {};
+static const u16 sDoorNullPalette28[16] = {};
+static const u8 sDoorAnimTiles_Empty8[128 * 3] = {};
+static const u16 sDoorNullPalette29[16] = {};
+static const u8 sDoorAnimTiles_Empty9[128 * 3] = {};
+static const u16 sDoorNullPalette30[16] = {};
+static const u8 sDoorAnimTiles_Empty10[128 * 3] = {};
+static const u16 sDoorNullPalette31[16] = {};
+static const u8 sDoorAnimTiles_Empty11[128 * 3] = {};
+static const u16 sDoorNullPalette32[16] = {};
+static const u8 sDoorAnimTiles_Empty12[128 * 3] = {};
+static const u16 sDoorNullPalette33[16] = {};
+static const u8 sDoorAnimTiles_Empty13[128 * 3] = {};
+static const u16 sDoorNullPalette34[16] = {};
+static const u8 sDoorAnimTiles_Empty14[128 * 3] = {};
+static const u16 sDoorNullPalette35[16] = {};
+static const u8 sDoorAnimTiles_Empty15[128 * 3] = {};
+static const u16 sDoorNullPalette36[16] = {};
+static const u8 sDoorAnimTiles_Empty16[128 * 3] = {};
+static const u16 sDoorNullPalette37[16] = {};
+static const u8 sDoorAnimTiles_Empty17[128 * 3] = {};
+static const u16 sDoorNullPalette38[16] = {};
+static const u8 sDoorAnimTiles_Empty18[128 * 3] = {};
+static const u16 sDoorNullPalette39[16] = {};
+static const u8 sDoorAnimTiles_Empty19[128 * 3] = {};
+static const u16 sDoorNullPalette40[16] = {};
+static const u8 sDoorAnimTiles_Empty20[128 * 3] = {};
+static const u16 sDoorNullPalette41[16] = {};
+static const u8 sDoorAnimTiles_Empty21[128 * 3] = {};
+static const u16 sDoorNullPalette42[16] = {};
+static const u8 sDoorAnimTiles_Empty22[128 * 3] = {};
+static const u16 sDoorNullPalette43[16] = {};
+static const u8 sDoorAnimTiles_Empty23[128 * 3] = {};
+static const u16 sDoorNullPalette44[16] = {};
+static const u8 sDoorAnimTiles_Empty24[128 * 3] = {};
+static const u16 sDoorNullPalette45[16] = {};
+static const u8 sDoorAnimTiles_Empty25[128 * 3] = {};
+static const u16 sDoorNullPalette46[16] = {};
+static const u8 sDoorAnimTiles_Empty26[128 * 3] = {};
+static const u16 sDoorNullPalette47[16] = {};
+static const u8 sDoorAnimTiles_Empty27[128 * 3] = {};
+static const u16 sDoorNullPalette48[16] = {};
+static const u8 sDoorAnimTiles_Empty28[128 * 3] = {};
+static const u16 sDoorNullPalette49[16] = {};
+static const u8 sDoorAnimTiles_Empty29[128 * 3] = {};
+static const u16 sDoorNullPalette50[16] = {};
+static const u8 sDoorAnimTiles_Empty30[128 * 3] = {};
+static const u16 sDoorNullPalette51[16] = {};
+static const u8 sDoorAnimTiles_Empty31[128 * 3] = {};
+static const u16 sDoorNullPalette52[16] = {};
+
+// Unused block of door tiles
+static const u8 sDoorAnimTiles_UnusedTop[] = INCBIN_U8("graphics/door_anims/unused_top.4bpp");
+static const u8 sDoorAnimTiles_Empty32[256] = {};
+static const u8 sDoorAnimTiles_UnusedMidTop[] = INCBIN_U8("graphics/door_anims/unused_midtop.4bpp");
+static const u8 sDoorAnimTiles_Empty33[256] = {};
+static const u8 sDoorAnimTiles_UnusedMidBottom[] = INCBIN_U8("graphics/door_anims/unused_midbottom.4bpp");
+static const u8 sDoorAnimTiles_Empty34[256] = {};
+static const u8 sDoorAnimTiles_UnusedBottom[] = INCBIN_U8("graphics/door_anims/unused_bottom.4bpp");
+static const u16 sDoorNullPalette53[16] = {};
+
+// Used FRLG doors resume
+static const u8 sDoorAnimTiles_SilphCoElevator[] = INCBIN_U8("graphics/door_anims/silph_co_elevator.4bpp");
+static const u16 sDoorNullPalette54[16] = {};
+static const u8 sDoorAnimTiles_Sevii123[] = INCBIN_U8("graphics/door_anims/sevii_123.4bpp");
+static const u16 sDoorNullPalette55[16] = {};
+static const u8 sDoorAnimTiles_JoyfulGameCorner[] = INCBIN_U8("graphics/door_anims/joyful_game_corner.4bpp");
+static const u16 sDoorNullPalette56[16] = {};
+static const u8 sDoorAnimTiles_OneIslandPokeCenter[] = INCBIN_U8("graphics/door_anims/one_island_poke_center.4bpp");
+static const u16 sDoorNullPalette57[16] = {};
+static const u8 sDoorAnimTiles_Sevii45[] = INCBIN_U8("graphics/door_anims/sevii_45.4bpp");
+static const u16 sDoorNullPalette58[16] = {};
+static const u8 sDoorAnimTiles_FourIslandDayCare[] = INCBIN_U8("graphics/door_anims/four_island_day_care.4bpp");
+static const u16 sDoorNullPalette59[16] = {};
+static const u8 sDoorAnimTiles_RocketWarehouse[] = INCBIN_U8("graphics/door_anims/rocket_warehouse.4bpp");
+static const u16 sDoorNullPalette60[16] = {};
+static const u8 sDoorAnimTiles_Sevii67[] = INCBIN_U8("graphics/door_anims/sevii_67.4bpp");
+static const u16 sDoorNullPalette61[16] = {};
+static const u8 sDoorAnimTiles_Teleporter[] = INCBIN_U8("graphics/door_anims/teleporter.4bpp");
+static const u16 sDoorNullPalette62[16] = {};
+static const u8 sDoorAnimTiles_TrainerTowerLobbyElevator[] = INCBIN_U8("graphics/door_anims/trainer_tower_lobby_elevator.4bpp");
+static const u16 sDoorNullPalette63[16] = {};
+static const u8 sDoorAnimTiles_TrainerTowerRoofElevator[] = INCBIN_U8("graphics/door_anims/trainer_tower_roof_elevator.4bpp");
+static const u16 sDoorNullPalette64[16] = {};
 
 static const struct DoorAnimFrame sDoorAnimFrames_OpenSmall[] = {
     {4, 0xFFFF},
@@ -257,72 +205,72 @@ static const struct DoorAnimFrame sDoorAnimFrames_CloseLarge[] = {
     {}
 };
 
-static const u8 gUnknown_835B4D8[] = {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2};
-static const u8 gUnknown_835B4E0[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B4E8[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B4F0[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B4F8[] = {0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa};
-static const u8 gUnknown_835B500[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B508[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B510[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B518[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B520[] = {0xc, 0xc, 0xc, 0xc, 0xc, 0xc, 0xc, 0xc};
-static const u8 gUnknown_835B528[] = {0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9};
-static const u8 gUnknown_835B530[] = {0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9};
-static const u8 gUnknown_835B538[] = {0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9};
-static const u8 gUnknown_835B540[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B548[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B550[] = {0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9, 0x9};
-static const u8 gUnknown_835B558[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B560[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B568[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B570[] = {0xc, 0xc, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2};
-static const u8 gUnknown_835B578[] = {0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7};
-static const u8 gUnknown_835B580[] = {0x8, 0x8, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2};
-static const u8 gUnknown_835B588[] = {0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5};
-static const u8 gUnknown_835B590[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B598[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B5A0[] = {0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5};
-static const u8 gUnknown_835B5A8[] = {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3};
-static const u8 gUnknown_835B5B0[] = {0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa};
-static const u8 gUnknown_835B5B8[] = {0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5};
-static const u8 gUnknown_835B5C0[] = {0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8};
-static const u8 gUnknown_835B5C8[] = {0x8, 0x8, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2};
-static const u8 gUnknown_835B5D0[] = {0xb, 0xb, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2};
+static const u8 sDoorAnimPalettes_General[] = {2, 2, 2, 2, 2, 2, 2, 2};
+static const u8 sDoorAnimPalettes_SlidingSingle[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_SlidingDouble[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_Pallet[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_OaksLab[] = {10, 10, 10, 10, 10, 10, 10, 10};
+static const u8 sDoorAnimPalettes_Viridian[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_Pewter[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_Saffron[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_SilphCo[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_Cerulean[] = {12, 12, 12, 12, 12, 12, 12, 12};
+static const u8 sDoorAnimPalettes_Lavender[] = {9, 9, 9, 9, 9, 9, 9, 9};
+static const u8 sDoorAnimPalettes_Vermilion[] = {9, 9, 9, 9, 9, 9, 9, 9};
+static const u8 sDoorAnimPalettes_PokemonFanClub[] = {9, 9, 9, 9, 9, 9, 9, 9};
+static const u8 sDoorAnimPalettes_DeptStore[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_Fuchsia[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_SafariZone[] = {9, 9, 9, 9, 9, 9, 9, 9};
+static const u8 sDoorAnimPalettes_CinnabarLab[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_DeptStoreElevator[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_CableClub[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_HideoutElevator[] = {12, 12, 2, 2, 2, 2, 2, 2};
+static const u8 sDoorAnimPalettes_SSAnne[] = {7, 7, 7, 7, 7, 7, 7, 7};
+static const u8 sDoorAnimPalettes_SilphCoElevator[] = {8, 8, 2, 2, 2, 2, 2, 2};
+static const u8 sDoorAnimPalettes_Sevii123[] = {5, 5, 5, 5, 5, 5, 5, 5};
+static const u8 sDoorAnimPalettes_JoyfulGameCorner[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_OneIslandPokeCenter[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_Sevii45[] = {5, 5, 5, 5, 5, 5, 5, 5};
+static const u8 sDoorAnimPalettes_FourIslandDayCare[] = {3, 3, 3, 3, 3, 3, 3, 3};
+static const u8 sDoorAnimPalettes_RocketWarehouse[] = {10, 10, 10, 10, 10, 10, 10, 10};
+static const u8 sDoorAnimPalettes_Sevii67[] = {5, 5, 5, 5, 5, 5, 5, 5};
+static const u8 sDoorAnimPalettes_Teleporter[] = {8, 8, 8, 8, 8, 8, 8, 8};
+static const u8 sDoorAnimPalettes_TrainerTowerLobbyElevator[] = {8, 8, 2, 2, 2, 2, 2, 2};
+static const u8 sDoorAnimPalettes_TrainerTowerRoofElevator[] = {11, 11, 2, 2, 2, 2, 2, 2};
 
 static const struct DoorGraphics sDoorGraphics[] = {
-    {0x03d, 0, 0, gUnknown_8353088, gUnknown_835B4D8},
-    {0x062, 1, 0, gUnknown_8353228, gUnknown_835B4E0},
-    {0x15b, 1, 0, gUnknown_83533C8, gUnknown_835B4E8},
-    {0x2a3, 0, 0, gUnknown_8353568, gUnknown_835B4F0},
-    {0x2ac, 0, 0, gUnknown_8353708, gUnknown_835B4F8},
-    {0x299, 0, 0, gUnknown_83538A8, gUnknown_835B500},
-    {0x2ce, 0, 0, gUnknown_8353A48, gUnknown_835B508},
-    {0x284, 0, 0, gUnknown_8353BE8, gUnknown_835B510},
-    {0x2bc, 1, 0, gUnknown_8353D88, gUnknown_835B518},
-    {0x298, 0, 0, gUnknown_8353F28, gUnknown_835B520},
-    {0x2a2, 0, 0, gUnknown_83540C8, gUnknown_835B528},
-    {0x29e, 0, 0, gUnknown_8354268, gUnknown_835B530},
-    {0x2e1, 0, 0, gUnknown_8354408, gUnknown_835B538},
-    {0x294, 1, 0, gUnknown_83545A8, gUnknown_835B540},
-    {0x2bf, 0, 0, gUnknown_8354748, gUnknown_835B548},
-    {0x2d2, 1, 0, gUnknown_83548E8, gUnknown_835B550},
-    {0x2ad, 0, 0, gUnknown_8354A88, gUnknown_835B558},
-    {0x297, 0, 0, gUnknown_8359FC8, gUnknown_835B588},
-    {0x29b, 1, 0, gUnknown_835A168, gUnknown_835B590},
-    {0x2eb, 0, 0, gUnknown_835A308, gUnknown_835B598},
-    {0x29a, 0, 0, gUnknown_835A4A8, gUnknown_835B5A0},
-    {0x2b9, 0, 0, gUnknown_835A648, gUnknown_835B5A8},
-    {0x2af, 0, 0, gUnknown_835A7E8, gUnknown_835B5B0},
-    {0x30c, 0, 0, gUnknown_835A988, gUnknown_835B5B8},
-    {0x28d, 1, 1, gUnknown_8354C28, gUnknown_835B560},
-    {0x2de, 1, 1, gUnknown_8354F48, gUnknown_835B568},
-    {0x2ab, 1, 1, gUnknown_8355268, gUnknown_835B570},
-    {0x281, 0, 1, gUnknown_8355588, gUnknown_835B578},
-    {0x2e2, 1, 1, gUnknown_8359CA8, gUnknown_835B580},
-    {0x296, 1, 1, gUnknown_835AB28, gUnknown_835B5C0},
-    {0x2c3, 1, 1, gUnknown_835AE48, gUnknown_835B5C8},
-    {0x356, 1, 1, gUnknown_835B168, gUnknown_835B5D0},
+    {METATILE_General_Door,                                DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_General, sDoorAnimPalettes_General},
+    {METATILE_General_SlidingSingleDoor,                   DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_SlidingSingle, sDoorAnimPalettes_SlidingSingle},
+    {METATILE_General_SlidingDoubleDoor,                   DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_SlidingDouble, sDoorAnimPalettes_SlidingDouble},
+    {METATILE_PalletTown_Door,                             DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Pallet, sDoorAnimPalettes_Pallet},
+    {METATILE_PalletTown_OaksLabDoor,                      DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_OaksLab, sDoorAnimPalettes_OaksLab},
+    {METATILE_ViridianCity_Door,                           DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Viridian, sDoorAnimPalettes_Viridian},
+    {METATILE_PewterCity_Door,                             DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Pewter, sDoorAnimPalettes_Pewter},
+    {METATILE_SaffronCity_Door,                            DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Saffron, sDoorAnimPalettes_Saffron},
+    {METATILE_SaffronCity_SilphCoDoor,                     DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_SilphCo, sDoorAnimPalettes_SilphCo},
+    {METATILE_CeruleanCity_Door,                           DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Cerulean, sDoorAnimPalettes_Cerulean},
+    {METATILE_LavenderTown_Door,                           DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Lavender, sDoorAnimPalettes_Lavender},
+    {METATILE_VermilionCity_Door,                          DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Vermilion, sDoorAnimPalettes_Vermilion},
+    {METATILE_VermilionCity_PokemonFanClubDoor,            DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_PokemonFanClub, sDoorAnimPalettes_PokemonFanClub},
+    {METATILE_CeladonCity_DeptStoreDoor,                   DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_DeptStore, sDoorAnimPalettes_DeptStore},
+    {METATILE_FuchsiaCity_Door,                            DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Fuchsia, sDoorAnimPalettes_Fuchsia},
+    {METATILE_FuchsiaCity_SafariZoneDoor,                  DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_SafariZone, sDoorAnimPalettes_SafariZone},
+    {METATILE_CinnabarIsland_LabDoor,                      DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_CinnabarLab, sDoorAnimPalettes_CinnabarLab},
+    {METATILE_SeviiIslands123_Door,                        DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Sevii123, sDoorAnimPalettes_Sevii123},
+    {METATILE_SeviiIslands123_GameCornerDoor,              DOOR_SOUND_SLIDING, 0, sDoorAnimTiles_JoyfulGameCorner, sDoorAnimPalettes_JoyfulGameCorner},
+    {METATILE_SeviiIslands123_PokeCenterDoor,              DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_OneIslandPokeCenter, sDoorAnimPalettes_OneIslandPokeCenter},
+    {METATILE_SeviiIslands45_Door,                         DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Sevii45, sDoorAnimPalettes_Sevii45},
+    {METATILE_SeviiIslands45_DayCareDoor,                  DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_FourIslandDayCare, sDoorAnimPalettes_FourIslandDayCare},
+    {METATILE_SeviiIslands45_RocketWarehouseDoor_Unlocked, DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_RocketWarehouse, sDoorAnimPalettes_RocketWarehouse},
+    {METATILE_SeviiIslands67_Door,                         DOOR_SOUND_NORMAL,  0, sDoorAnimTiles_Sevii67, sDoorAnimPalettes_Sevii67},
+    {METATILE_DepartmentStore_ElevatorDoor,                DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_DeptStoreElevator, sDoorAnimPalettes_DeptStoreElevator},
+    {METATILE_PokemonCenter_CableClubDoor,                 DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_CableClub, sDoorAnimPalettes_CableClub},
+    {METATILE_SilphCo_HideoutElevatorDoor,                 DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_HideoutElevator, sDoorAnimPalettes_HideoutElevator},
+    {METATILE_SSAnne_Door,                                 DOOR_SOUND_NORMAL,  1, sDoorAnimTiles_SSAnne, sDoorAnimPalettes_SSAnne},
+    {METATILE_SilphCo_ElevatorDoor,                        DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_SilphCoElevator, sDoorAnimPalettes_SilphCoElevator},
+    {METATILE_SeaCottage_Teleporter_Door,                  DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_Teleporter, sDoorAnimPalettes_Teleporter},
+    {METATILE_TrainerTower_LobbyElevatorDoor,              DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_TrainerTowerLobbyElevator, sDoorAnimPalettes_TrainerTowerLobbyElevator},
+    {METATILE_TrainerTower_RoofElevatorDoor,               DOOR_SOUND_SLIDING, 1, sDoorAnimTiles_TrainerTowerRoofElevator, sDoorAnimPalettes_TrainerTowerRoofElevator},
     {}
 };
 
@@ -418,7 +366,7 @@ static bool32 PlayDoorAnimationFrame(const struct DoorGraphics * gfx, const stru
     return TRUE;
 }
 
-static const struct DoorGraphics * door_find(const struct DoorGraphics * gfx, u16 id)
+static const struct DoorGraphics * GetDoorGraphics(const struct DoorGraphics * gfx, u16 id)
 {
     while (gfx->tiles != NULL)
     {
@@ -429,16 +377,18 @@ static const struct DoorGraphics * door_find(const struct DoorGraphics * gfx, u1
     return NULL;
 }
 
-static s8 task_overworld_door_add_if_inactive(const struct DoorGraphics * gfx, const struct DoorAnimFrame * frames, int a2, int a3)
+static s8 StartDoorAnimationTask(const struct DoorGraphics * gfx, const struct DoorAnimFrame * frames, int x, int y)
 {
     u8 taskId;
     s16 *data;
     if (FuncIsActiveTask(Task_AnimateDoor) == TRUE)
         return -1;
+
     taskId = CreateTask(Task_AnimateDoor, 80);
     data = gTasks[taskId].data;
-    data[6] = a2;
-    data[7] = a3;
+
+    data[6] = x;
+    data[7] = y;
     data[1] = (uintptr_t)frames;
     data[0] = (uintptr_t)frames >> 16;
     data[3] = (uintptr_t)gfx;
@@ -446,14 +396,14 @@ static s8 task_overworld_door_add_if_inactive(const struct DoorGraphics * gfx, c
     return taskId;
 }
 
-static void DrawClosedDoor(const struct DoorGraphics * gfx, int a1, int a2)
+static void DrawClosedDoor(const struct DoorGraphics * gfx, int x, int y)
 {
-    DrawDoorDefaultImage(gfx, a1, a2);
+    DrawDoorDefaultImage(gfx, x, y);
 }
 
 static void DrawOpenedDoor(const struct DoorGraphics * gfx, int x, int y)
 {
-    gfx = door_find(gfx, MapGridGetMetatileIdAt(x, y));
+    gfx = GetDoorGraphics(gfx, MapGridGetMetatileIdAt(x, y));
     if (gfx != NULL)
     {
         UpdateDrawDoorFrame(gfx, SeekToEndOfDoorAnim(gfx->size == 0 ? sDoorAnimFrames_OpenSmall : sDoorAnimFrames_OpenLarge), x, y);
@@ -469,24 +419,24 @@ static const struct DoorAnimFrame * SeekToEndOfDoorAnim(const struct DoorAnimFra
 
 static s8 AnimateDoorOpenInternal(const struct DoorGraphics * gfx, int x, int y)
 {
-    gfx = door_find(gfx, MapGridGetMetatileIdAt(x, y));
+    gfx = GetDoorGraphics(gfx, MapGridGetMetatileIdAt(x, y));
     if (gfx == NULL)
         return -1;
     else if (gfx->size == 0)
-        return task_overworld_door_add_if_inactive(gfx, sDoorAnimFrames_OpenSmall, x, y);
+        return StartDoorAnimationTask(gfx, sDoorAnimFrames_OpenSmall, x, y);
     else
-        return task_overworld_door_add_if_inactive(gfx, sDoorAnimFrames_OpenLarge, x, y);
+        return StartDoorAnimationTask(gfx, sDoorAnimFrames_OpenLarge, x, y);
 }
 
 static s8 AnimateDoorCloseInternal(const struct DoorGraphics * gfx, int x, int y)
 {
-    gfx = door_find(gfx, MapGridGetMetatileIdAt(x, y));
+    gfx = GetDoorGraphics(gfx, MapGridGetMetatileIdAt(x, y));
     if (gfx == NULL)
         return -1;
     else if (gfx->size == 0)
-        return task_overworld_door_add_if_inactive(gfx, sDoorAnimFrames_CloseSmall, x, y);
+        return StartDoorAnimationTask(gfx, sDoorAnimFrames_CloseSmall, x, y);
     else
-        return task_overworld_door_add_if_inactive(gfx, sDoorAnimFrames_CloseLarge, x, y);
+        return StartDoorAnimationTask(gfx, sDoorAnimFrames_CloseLarge, x, y);
 }
 
 void FieldSetDoorOpened(int x, int y)
@@ -522,16 +472,16 @@ bool8 FieldIsDoorAnimationRunning(void)
 
 u16 GetDoorSoundEffect(x, y)
 {
-    if (!GetDoorOpenType(sDoorGraphics, x, y))
+    if (GetDoorSoundType(sDoorGraphics, x, y) == DOOR_SOUND_NORMAL)
         return MUS_W_DOOR;
-    else
+    else // DOOR_SOUND_SLIDING
         return SE_JIDO_DOA;
 }
 
-static s8 GetDoorOpenType(const struct DoorGraphics * gfx, int x, int y)
+static s8 GetDoorSoundType(const struct DoorGraphics * gfx, int x, int y)
 {
-    gfx = door_find(gfx, MapGridGetMetatileIdAt(x, y));
+    gfx = GetDoorGraphics(gfx, MapGridGetMetatileIdAt(x, y));
     if (gfx == NULL)
         return -1;
-    return gfx->sliding;
+    return gfx->sound;
 }
diff --git a/src/field_effect.c b/src/field_effect.c
new file mode 100644
index 000000000..082aee32d
--- /dev/null
+++ b/src/field_effect.c
@@ -0,0 +1,3909 @@
+#include "global.h"
+#include "gflib.h"
+#include "data.h"
+#include "decompress.h"
+#include "event_data.h"
+#include "event_object_movement.h"
+#include "field_camera.h"
+#include "field_control_avatar.h"
+#include "field_effect.h"
+#include "field_effect_helpers.h"
+#include "field_effect_scripts.h"
+#include "field_fadetransition.h"
+#include "field_player_avatar.h"
+#include "field_weather.h"
+#include "fieldmap.h"
+#include "help_system.h"
+#include "metatile_behavior.h"
+#include "new_menu_helpers.h"
+#include "overworld.h"
+#include "party_menu.h"
+#include "quest_log.h"
+#include "script.h"
+#include "special_field_anim.h"
+#include "task.h"
+#include "trainer_pokemon_sprites.h"
+#include "trig.h"
+#include "util.h"
+#include "constants/event_object_movement.h"
+#include "constants/metatile_behaviors.h"
+#include "constants/songs.h"
+
+#define subsprite_table(ptr) {.subsprites = ptr, .subspriteCount = (sizeof ptr) / (sizeof(struct Subsprite))}
+#define FIELD_EFFECT_COUNT 32
+
+EWRAM_DATA u32 gFieldEffectArguments[8] = {0};
+
+static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT];
+
+static void FieldEffectActiveListAdd(u8 fldeff);
+static bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_end(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result);
+static bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result);
+static void FieldEffectScript_LoadTiles(const u8 **script);
+static void FieldEffectScript_LoadFadedPal(const u8 **script);
+static void FieldEffectScript_LoadPal(const u8 **script);
+static void FieldEffectScript_CallNative(const u8 **script, u32 *result);
+static void FieldEffectFreeTilesIfUnused(u16 tilesTag);
+static void FieldEffectFreePaletteIfUnused(u8 paletteNum);
+static void Task_PokecenterHeal(u8 taskId);
+static void SpriteCB_PokeballGlow(struct Sprite * sprite);
+static void SpriteCB_PokecenterMonitor(struct Sprite * sprite);
+static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite);
+
+static const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp");
+static const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal");
+static const u16 sUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp");
+static const u16 sUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal");
+static const u16 sUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp");
+static const u16 sUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal");
+static const u16 sUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp");
+static const u16 sFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp");
+static const u16 sFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal");
+static const u16 sFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin");
+static const u16 sDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp");
+static const u16 sDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal");
+static const u16 sDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin");
+static const u16 sFldEffUnk44_Tiles[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp");
+
+static bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = {
+    FieldEffectCmd_loadtiles,
+    FieldEffectCmd_loadfadedpal,
+    FieldEffectCmd_loadpal,
+    FieldEffectCmd_callnative,
+    FieldEffectCmd_end,
+    FieldEffectCmd_loadgfx_callnative,
+    FieldEffectCmd_loadtiles_callnative,
+    FieldEffectCmd_loadfadedpal_callnative
+};
+
+static const struct OamData sNewGameOakOamAttributes = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0x000,
+    .priority = 0,
+    .paletteNum = 0x0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_8x8 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(8x8),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(8x8),
+    .tileNum = 0x000,
+    .priority = 0,
+    .paletteNum = 0x0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_16x16 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0x000,
+    .priority = 0,
+    .paletteNum = 0x0,
+    .affineParam = 0
+};
+
+static const struct SpriteFrameImage sNewGameOakObjectSpriteFrames[] = {
+    {sNewGameOakObjectSpriteTiles, 0x800}
+};
+
+static const struct SpritePalette sNewGameOakObjectPaletteInfo = {
+    sNewGameOakObjectPals, 4102
+};
+
+static const union AnimCmd sNewGameOakAnim[] = {
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sNewGameOakAnimTable[] = {
+    sNewGameOakAnim
+};
+
+static const struct SpriteTemplate sNewGameOakObjectTemplate = {
+    .tileTag = SPRITE_INVALID_TAG,
+    .paletteTag = 4102,
+    .oam = &sNewGameOakOamAttributes,
+    .anims = sNewGameOakAnimTable,
+    .images = sNewGameOakObjectSpriteFrames,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+const struct SpritePalette gUnknown_83CBE9C = {
+    sUnknown_83CAFB0, 4103
+};
+
+const struct SpritePalette gUnknown_83CBEA4 = {
+    sUnknown_83CB3D0, 4112
+};
+
+static const struct OamData sOamData_83CBEAC = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(32x16),
+    .tileNum = 0x000,
+    .priority = 0,
+    .paletteNum = 0x0,
+    .affineParam = 0
+};
+
+static const struct SpriteFrameImage sUnknown_83CBEB4[] = {
+    {sUnknown_83CAF90, 0x20}
+};
+
+static const struct SpriteFrameImage sUnknown_83CBEBC[] = {
+    {sUnknown_83CAFD0 + 0x000, 0x100},
+    {sUnknown_83CAFD0 + 0x080, 0x100},
+    {sUnknown_83CAFD0 + 0x100, 0x100},
+    {sUnknown_83CAFD0 + 0x180, 0x100}
+};
+
+static const struct SpriteFrameImage sUnknown_83CBEDC[] = {
+    {sUnknown_83CB3F0 + 0x00, 0x80},
+    {sUnknown_83CB3F0 + 0x40, 0x80},
+    {sUnknown_83CB3F0 + 0x80, 0x80},
+    {sUnknown_83CB3F0 + 0xC0, 0x80}
+};
+
+static const struct Subsprite sUnknown_83CBEFC[] =
+{
+    {
+        .x = -12,
+        .y =  -8,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 0,
+        .priority = 2
+    }, {
+        .x =  4,
+        .y = -8,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 2,
+        .priority = 2
+    }, {
+        .x = -12,
+        .y =   0,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 3,
+        .priority = 2
+    }, {
+        .x = 4,
+        .y = 0,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 5,
+        .priority = 2
+    }
+};
+
+static const struct SubspriteTable sUnknown_83CBF0C = subsprite_table(sUnknown_83CBEFC);
+
+static const struct Subsprite sUnknown_83CBF14[] =
+{
+    {
+        .x = -32,
+        .y = -8,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 0,
+        .priority = 2
+    }, {
+        .x =  0,
+        .y = -8,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 4,
+        .priority = 2
+    }, {
+        .x = -32,
+        .y =  0,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 8,
+        .priority = 2
+    }, {
+        .x =   0,
+        .y =  0,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 12,
+        .priority = 2
+    }
+};
+
+static const struct SubspriteTable sUnknown_83CBF24 = subsprite_table(sUnknown_83CBF14);
+
+static const union AnimCmd sUnknown_83CBF2C[] = {
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd sUnknown_83CBF34[] = {
+    ANIMCMD_FRAME(1, 5),
+    ANIMCMD_FRAME(2, 5),
+    ANIMCMD_FRAME(3, 7),
+    ANIMCMD_FRAME(2, 5),
+    ANIMCMD_FRAME(1, 5),
+    ANIMCMD_FRAME(0, 5),
+    ANIMCMD_LOOP(3),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sUnknown_83CBF54[] = {
+    sUnknown_83CBF2C,
+    sUnknown_83CBF34
+};
+
+static const union AnimCmd sUnknown_83CBF5C[] = {
+    ANIMCMD_FRAME(3, 8),
+    ANIMCMD_FRAME(2, 8),
+    ANIMCMD_FRAME(1, 8),
+    ANIMCMD_FRAME(0, 8),
+    ANIMCMD_FRAME(1, 8),
+    ANIMCMD_FRAME(2, 8),
+    ANIMCMD_LOOP(2),
+    ANIMCMD_FRAME(1, 8),
+    ANIMCMD_FRAME(0, 8),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sUnknown_83CBF84[] = {
+    sUnknown_83CBF5C
+};
+
+static const struct SpriteTemplate sUnknown_83CBF88 = {
+    .tileTag = SPRITE_INVALID_TAG,
+    .paletteTag = 4103,
+    .oam = &sOamData_8x8,
+    .anims = sUnknown_83CBF54,
+    .images = sUnknown_83CBEB4,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_PokeballGlow
+};
+
+static const struct SpriteTemplate sUnknown_83CBFA0 = {
+    .tileTag = SPRITE_INVALID_TAG,
+    .paletteTag = 4103,
+    .oam = &sOamData_83CBEAC,
+    .anims = sUnknown_83CBF54,
+    .images = sUnknown_83CBEBC,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_PokecenterMonitor
+};
+
+static const struct SpriteTemplate sUnknown_83CBFB8 = {
+    .tileTag = SPRITE_INVALID_TAG,
+    .paletteTag = 4112,
+    .oam = &sOamData_16x16,
+    .anims = sUnknown_83CBF84,
+    .images = sUnknown_83CBEDC,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_HallOfFameMonitor
+};
+
+
+u32 FieldEffectStart(u8 fldeff)
+{
+    const u8 *script;
+    u32 result;
+    FieldEffectActiveListAdd(fldeff);
+    script = gFieldEffectScriptPointers[fldeff];
+    while (sFldEffScrcmdTable[*script](&script, &result))
+        ;
+    return result;
+}
+
+static bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadTiles(script);
+    return TRUE;
+}
+
+static bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadFadedPal(script);
+    return TRUE;
+}
+
+static bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadPal(script);
+    return TRUE;
+}
+static bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_CallNative(script, result);
+    return TRUE;
+}
+
+static bool8 FieldEffectCmd_end(const u8 **script, u32 *result)
+{
+    return FALSE;
+}
+
+static bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadTiles(script);
+    FieldEffectScript_LoadFadedPal(script);
+    FieldEffectScript_CallNative(script, result);
+    return TRUE;
+}
+
+static bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadTiles(script);
+    FieldEffectScript_CallNative(script, result);
+    return TRUE;
+}
+
+static bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result)
+{
+    (*script)++;
+    FieldEffectScript_LoadFadedPal(script);
+    FieldEffectScript_CallNative(script, result);
+    return TRUE;
+}
+
+static u32 FieldEffectScript_ReadWord(const u8 **script)
+{
+    return T2_READ_32(*script);
+}
+
+static void FieldEffectScript_LoadTiles(const u8 **script)
+{
+    const struct SpriteSheet * spriteSheet = (const struct SpriteSheet * )FieldEffectScript_ReadWord(script);
+    if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF)
+        LoadSpriteSheet(spriteSheet);
+    *script += sizeof(u32);
+}
+
+void sub_8083598(u8 paletteIdx)
+{
+    switch (gUnknown_2036E28)
+    {
+    case 0:
+        return;
+    case 1:
+        TintPalette_GrayScale(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10);
+        break;
+    case 2:
+        TintPalette_SepiaTone(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10);
+        break;
+    case 3:
+        sub_8111F38((paletteIdx + 16) * 16, 0x10);
+        TintPalette_GrayScale(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10);
+        break;
+    default:
+        return;
+    }
+    CpuFastCopy(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], &gPlttBufferFaded[(paletteIdx + 16) * 16], 0x20);
+}
+
+static void FieldEffectScript_LoadFadedPal(const u8 **script)
+{
+    const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script);
+    u8 idx = IndexOfSpritePaletteTag(spritePalette->tag);
+    LoadSpritePalette(spritePalette);
+    if (idx == 0xFF)
+        sub_8083598(IndexOfSpritePaletteTag(spritePalette->tag));
+    UpdateSpritePaletteWithWeather(IndexOfSpritePaletteTag(spritePalette->tag));
+    *script += sizeof(u32);
+}
+
+static void FieldEffectScript_LoadPal(const u8 **script)
+{
+    const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script);
+    u8 idx = IndexOfSpritePaletteTag(spritePalette->tag);
+    LoadSpritePalette(spritePalette);
+    if (idx != 0xFF)
+        sub_8083598(IndexOfSpritePaletteTag(spritePalette->tag));
+    *script += sizeof(u32);
+}
+
+static void FieldEffectScript_CallNative(const u8 **script, u32 *result)
+{
+    u32 (*func)(void) = (u32 (*)(void))FieldEffectScript_ReadWord(script);
+    *result = func();
+    *script += sizeof(u32);
+}
+
+static void FieldEffectFreeGraphicsResources(struct Sprite * sprite)
+{
+    u16 tileStart = sprite->sheetTileStart;
+    u8 paletteNum = sprite->oam.paletteNum;
+    DestroySprite(sprite);
+    FieldEffectFreeTilesIfUnused(tileStart);
+    FieldEffectFreePaletteIfUnused(paletteNum);
+}
+
+void FieldEffectStop(struct Sprite * sprite, u8 fldeff)
+{
+    FieldEffectFreeGraphicsResources(sprite);
+    FieldEffectActiveListRemove(fldeff);
+}
+
+static void FieldEffectFreeTilesIfUnused(u16 tileStart)
+{
+    u8 i;
+    u16 tileTag = GetSpriteTileTagByTileStart(tileStart);
+    if (tileTag == SPRITE_INVALID_TAG)
+        return;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        if (gSprites[i].inUse && gSprites[i].usingSheet && tileStart == gSprites[i].sheetTileStart)
+            return;
+    }
+    FreeSpriteTilesByTag(tileTag);
+}
+
+static void FieldEffectFreePaletteIfUnused(u8 paletteNum)
+{
+    u8 i;
+    u16 paletteTag = GetSpritePaletteTagByPaletteNum(paletteNum);
+    if (paletteTag == SPRITE_INVALID_TAG)
+        return;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        if (gSprites[i].inUse && gSprites[i].oam.paletteNum == paletteNum)
+            return;
+    }
+    FreeSpritePaletteByTag(paletteTag);
+}
+
+void FieldEffectActiveListClear(void)
+{
+    u8 i;
+    for (i = 0; i < FIELD_EFFECT_COUNT; i++)
+    {
+        sFieldEffectActiveList[i] = 0xFF;
+    }
+}
+
+static void FieldEffectActiveListAdd(u8 fldeff)
+{
+    u8 i;
+    for (i = 0; i < FIELD_EFFECT_COUNT; i++)
+    {
+        if (sFieldEffectActiveList[i] == 0xFF)
+        {
+            sFieldEffectActiveList[i] = fldeff;
+            return;
+        }
+    }
+}
+
+void FieldEffectActiveListRemove(u8 fldeff)
+{
+    u8 i;
+    for (i = 0; i < FIELD_EFFECT_COUNT; i++)
+    {
+        if (sFieldEffectActiveList[i] == fldeff)
+        {
+            sFieldEffectActiveList[i] = 0xFF;
+            return;
+        }
+    }
+}
+
+bool8 FieldEffectActiveListContains(u8 fldeff)
+{
+    u8 i;
+    for (i = 0; i < FIELD_EFFECT_COUNT; i++)
+    {
+        if (sFieldEffectActiveList[i] == fldeff)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+u8 CreateTrainerSprite(u8 trainerSpriteID, s16 x, s16 y, u8 subpriority, u8 *buffer)
+{
+    struct SpriteTemplate spriteTemplate;
+    LoadCompressedSpritePaletteOverrideBuffer(&gTrainerFrontPicPaletteTable[trainerSpriteID], buffer);
+    LoadCompressedSpriteSheetOverrideBuffer(&gTrainerFrontPicTable[trainerSpriteID], buffer);
+    spriteTemplate.tileTag = gTrainerFrontPicTable[trainerSpriteID].tag;
+    spriteTemplate.paletteTag = gTrainerFrontPicPaletteTable[trainerSpriteID].tag;
+    spriteTemplate.oam = &sNewGameOakOamAttributes;
+    spriteTemplate.anims = gDummySpriteAnimTable;
+    spriteTemplate.images = NULL;
+    spriteTemplate.affineAnims = gDummySpriteAffineAnimTable;
+    spriteTemplate.callback = SpriteCallbackDummy;
+    return CreateSprite(&spriteTemplate, x, y, subpriority);
+}
+
+static void LoadTrainerGfx_TrainerCard(u8 gender, u16 palOffset, u8 *dest)
+{
+    LZDecompressVram(gTrainerFrontPicTable[gender].data, dest);
+    LoadCompressedPalette(gTrainerFrontPicPaletteTable[gender].data, palOffset, 0x20);
+}
+
+static u8 AddNewGameBirchObject(s16 x, s16 y, u8 subpriority)
+{
+    LoadSpritePalette(&sNewGameOakObjectPaletteInfo);
+    return CreateSprite(&sNewGameOakObjectTemplate, x, y, subpriority);
+}
+
+u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority)
+{
+    u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, 0, 0x8000, TRUE, x, y, 0, gMonPaletteTable[species].tag);
+    PreservePaletteInWeather(IndexOfSpritePaletteTag(gMonPaletteTable[species].tag) + 0x10);
+    if (spriteId == 0xFFFF)
+        return MAX_SPRITES;
+    else
+        return spriteId;
+}
+
+static u8 CreateMonSprite_FieldMove(u16 species, u32 otId, u32 personality, s16 x, s16 y, u8 subpriority)
+{
+    const struct CompressedSpritePalette * spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, otId, personality);
+    u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, otId, personality, 1, x, y, 0, spritePalette->tag);
+    PreservePaletteInWeather(IndexOfSpritePaletteTag(spritePalette->tag) + 0x10);
+    if (spriteId == 0xFFFF)
+        return MAX_SPRITES;
+    else
+        return spriteId;
+}
+
+void FreeResourcesAndDestroySprite(struct Sprite * sprite, u8 spriteId)
+{
+    ResetPreservedPalettesInWeather();
+    if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF)
+    {
+        FreeOamMatrix(sprite->oam.matrixNum);
+    }
+    FreeAndDestroyMonPicSprite(spriteId);
+}
+
+// r, g, b are between 0 and 16
+void MultiplyInvertedPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b)
+{
+    int curRed;
+    int curGreen;
+    int curBlue;
+    u16 outPal;
+
+    outPal = gPlttBufferUnfaded[i];
+    curRed = outPal & 0x1f;
+    curGreen = (outPal & (0x1f << 5)) >> 5;
+    curBlue = (outPal & (0x1f << 10)) >> 10;
+    curRed += (((0x1f - curRed) * r) >> 4);
+    curGreen += (((0x1f - curGreen) * g) >> 4);
+    curBlue += (((0x1f - curBlue) * b) >> 4);
+    outPal = curRed;
+    outPal |= curGreen << 5;
+    outPal |= curBlue << 10;
+    gPlttBufferFaded[i] = outPal;
+}
+
+// r, g, b are between 0 and 16
+static void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b)
+{
+    int curRed;
+    int curGreen;
+    int curBlue;
+    u16 outPal;
+
+    outPal = gPlttBufferUnfaded[i];
+    curRed = outPal & 0x1f;
+    curGreen = (outPal & (0x1f << 5)) >> 5;
+    curBlue = (outPal & (0x1f << 10)) >> 10;
+    curRed -= ((curRed * r) >> 4);
+    curGreen -= ((curGreen * g) >> 4);
+    curBlue -= ((curBlue * b) >> 4);
+    outPal = curRed;
+    outPal |= curGreen << 5;
+    outPal |= curBlue << 10;
+    gPlttBufferFaded[i] = outPal;
+}
+
+static void PokecenterHealEffect_0(struct Task * task);
+static void PokecenterHealEffect_1(struct Task * task);
+static void PokecenterHealEffect_2(struct Task * task);
+static void PokecenterHealEffect_3(struct Task * task);
+static void HallOfFameRecordEffect_0(struct Task * task);
+static void HallOfFameRecordEffect_1(struct Task * task);
+static void HallOfFameRecordEffect_2(struct Task * task);
+static void HallOfFameRecordEffect_3(struct Task * task);
+static void Task_HallOfFameRecord(u8 taskId);
+static u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare);
+static void SpriteCB_PokeballGlowEffect(struct Sprite * sprite);
+static void PokeballGlowEffect_0(struct Sprite * sprite);
+static void PokeballGlowEffect_1(struct Sprite * sprite);
+static void PokeballGlowEffect_2(struct Sprite * sprite);
+static void PokeballGlowEffect_3(struct Sprite * sprite);
+static void PokeballGlowEffect_4(struct Sprite * sprite);
+static void PokeballGlowEffect_5(struct Sprite * sprite);
+static void PokeballGlowEffect_6(struct Sprite * sprite);
+static void PokeballGlowEffect_7(struct Sprite * sprite);
+static u8 PokecenterHealEffectHelper(s32 x, s32 y);
+static void HallOfFameRecordEffectHelper(s32 x, s32 y);
+
+static void (*const sPokecenterHealTaskCBTable[])(struct Task * ) = {
+    PokecenterHealEffect_0,
+    PokecenterHealEffect_1,
+    PokecenterHealEffect_2,
+    PokecenterHealEffect_3
+};
+
+static void (*const sHallOfFameRecordTaskCBTable[])(struct Task * ) = {
+    HallOfFameRecordEffect_0,
+    HallOfFameRecordEffect_1,
+    HallOfFameRecordEffect_2,
+    HallOfFameRecordEffect_3
+};
+
+static void (*const sPokeballGlowSpriteCBTable[])(struct Sprite * ) = {
+    PokeballGlowEffect_0,
+    PokeballGlowEffect_1,
+    PokeballGlowEffect_2,
+    PokeballGlowEffect_3,
+    PokeballGlowEffect_4,
+    PokeballGlowEffect_5,
+    PokeballGlowEffect_6,
+    PokeballGlowEffect_7
+};
+
+bool8 FldEff_PokecenterHeal(void)
+{
+    u8 nPokemon;
+    struct Task * task;
+
+    nPokemon = CalculatePlayerPartyCount();
+    task = &gTasks[CreateTask(Task_PokecenterHeal, 0xff)];
+    task->data[1] = nPokemon;
+    task->data[2] = 0x5d;
+    task->data[3] = 0x24;
+    task->data[4] = 0x80;
+    task->data[5] = 0x18;
+    return FALSE;
+}
+
+static void Task_PokecenterHeal(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    sPokecenterHealTaskCBTable[task->data[0]](task);
+}
+
+static void PokecenterHealEffect_0(struct Task * task)
+{
+    task->data[0]++;
+    task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], TRUE);
+    task->data[7] = PokecenterHealEffectHelper(task->data[4], task->data[5]);
+}
+
+static void PokecenterHealEffect_1(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 1)
+    {
+        gSprites[task->data[7]].data[0]++;
+        task->data[0]++;
+    }
+}
+
+static void PokecenterHealEffect_2(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 4)
+    {
+        task->data[0]++;
+    }
+}
+
+static void PokecenterHealEffect_3(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 6)
+    {
+        DestroySprite(&gSprites[task->data[6]]);
+        FieldEffectActiveListRemove(FLDEFF_POKECENTER_HEAL);
+        DestroyTask(FindTaskIdByFunc(Task_PokecenterHeal));
+    }
+}
+
+bool8 FldEff_HallOfFameRecord(void)
+{
+    u8 nPokemon;
+    struct Task * task;
+
+    nPokemon = CalculatePlayerPartyCount();
+    task = &gTasks[CreateTask(Task_HallOfFameRecord, 0xff)];
+    task->data[1] = nPokemon;
+    task->data[2] = 0x75;
+    task->data[3] = 0x3C;
+    return FALSE;
+}
+
+static void Task_HallOfFameRecord(u8 taskId)
+{
+    struct Task * task;
+    task = &gTasks[taskId];
+    sHallOfFameRecordTaskCBTable[task->data[0]](task);
+}
+
+static void HallOfFameRecordEffect_0(struct Task * task)
+{
+    u8 taskId;
+    task->data[0]++;
+    task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], FALSE);
+}
+
+static void HallOfFameRecordEffect_1(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 1)
+    {
+        HallOfFameRecordEffectHelper(0x78, 0x19);
+        task->data[15]++; // was this ever initialized? is this ever used?
+        task->data[0]++;
+    }
+}
+
+static void HallOfFameRecordEffect_2(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 4)
+    {
+        task->data[0]++;
+    }
+}
+
+static void HallOfFameRecordEffect_3(struct Task * task)
+{
+    if (gSprites[task->data[6]].data[0] > 6)
+    {
+        DestroySprite(&gSprites[task->data[6]]);
+        FieldEffectActiveListRemove(FLDEFF_HALL_OF_FAME_RECORD);
+        DestroyTask(FindTaskIdByFunc(Task_HallOfFameRecord));
+    }
+}
+
+static u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+    spriteId = CreateInvisibleSprite(SpriteCB_PokeballGlowEffect);
+    sprite = &gSprites[spriteId];
+    sprite->pos2.x = x;
+    sprite->pos2.y = y;
+    sprite->subpriority = 0xFF;
+    sprite->data[5] = fanfare;
+    sprite->data[6] = duration;
+    sprite->data[7] = spriteId;
+    return spriteId;
+}
+
+static void SpriteCB_PokeballGlowEffect(struct Sprite * sprite)
+{
+    sPokeballGlowSpriteCBTable[sprite->data[0]](sprite);
+}
+
+static const struct Coords16 sUnknown_83CC010[] = {
+    {0, 0},
+    {6, 0},
+    {0, 4},
+    {6, 4},
+    {0, 8},
+    {6, 8}
+};
+
+static const u8 sUnknown_83CC028[] = {16, 12,  8,  0};
+static const u8 sUnknown_83CC02C[] = {16, 12,  8,  0};
+static const u8 sUnknown_83CC030[] = { 0,  0,  0,  0};
+
+static void PokeballGlowEffect_0(struct Sprite * sprite)
+{
+    u8 endSpriteId;
+    if (sprite->data[1] == 0 || (--sprite->data[1]) == 0)
+    {
+        sprite->data[1] = 25;
+        endSpriteId = CreateSpriteAtEnd(&sUnknown_83CBF88, sUnknown_83CC010[sprite->data[2]].x + sprite->pos2.x, sUnknown_83CC010[sprite->data[2]].y + sprite->pos2.y, 0xFF);
+        gSprites[endSpriteId].oam.priority = 2;
+        gSprites[endSpriteId].data[0] = sprite->data[7];
+        sprite->data[2]++;
+        sprite->data[6]--;
+        PlaySE(SE_BOWA);
+    }
+    if (sprite->data[6] == 0)
+    {
+        sprite->data[1] = 32;
+        sprite->data[0]++;
+    }
+}
+
+static void PokeballGlowEffect_1(struct Sprite * sprite)
+{
+    if ((--sprite->data[1]) == 0)
+    {
+        sprite->data[0]++;
+        sprite->data[1] = 8;
+        sprite->data[2] = 0;
+        sprite->data[3] = 0;
+        if (sprite->data[5])
+        {
+            PlayFanfare(MUS_ME_ASA);
+        }
+    }
+}
+
+static void PokeballGlowEffect_2(struct Sprite * sprite)
+{
+    u8 phase;
+    if ((--sprite->data[1]) == 0)
+    {
+        sprite->data[1] = 8;
+        sprite->data[2]++;
+        sprite->data[2] &= 3;
+        if (sprite->data[2] == 0)
+        {
+            sprite->data[3]++;
+        }
+    }
+    phase = (sprite->data[2] + 3) & 3;
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    phase = (sprite->data[2] + 2) & 3;
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    phase = (sprite->data[2] + 1) & 3;
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    phase = sprite->data[2];
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    if (sprite->data[3] > 2)
+    {
+        sprite->data[0]++;
+        sprite->data[1] = 8;
+        sprite->data[2] = 0;
+    }
+}
+
+static void PokeballGlowEffect_3(struct Sprite * sprite)
+{
+    u8 phase;
+    if ((--sprite->data[1]) == 0)
+    {
+        sprite->data[1] = 8;
+        sprite->data[2]++;
+        sprite->data[2] &= 3;
+        if (sprite->data[2] == 3)
+        {
+            sprite->data[0]++;
+            sprite->data[1] = 30;
+        }
+    }
+    phase = sprite->data[2];
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+    MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]);
+}
+
+static void PokeballGlowEffect_4(struct Sprite * sprite)
+{
+    if ((--sprite->data[1]) == 0)
+    {
+        sprite->data[0]++;
+    }
+}
+
+static void PokeballGlowEffect_5(struct Sprite * sprite)
+{
+    sprite->data[0]++;
+}
+
+static void PokeballGlowEffect_6(struct Sprite * sprite)
+{
+    if (sprite->data[5] == 0 || IsFanfareTaskInactive())
+    {
+        sprite->data[0]++;
+    }
+}
+
+static void PokeballGlowEffect_7(struct Sprite * sprite)
+{
+}
+
+static void SpriteCB_PokeballGlow(struct Sprite * sprite)
+{
+    if (gSprites[sprite->data[0]].data[0] > 4)
+        FieldEffectFreeGraphicsResources(sprite);
+}
+
+static u8 PokecenterHealEffectHelper(s32 x, s32 y)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+    spriteId = CreateSpriteAtEnd(&sUnknown_83CBFA0, x, y, 0);
+    sprite = &gSprites[spriteId];
+    sprite->oam.priority = 2;
+    sprite->invisible = TRUE;
+    return spriteId;
+}
+
+static void SpriteCB_PokecenterMonitor(struct Sprite * sprite)
+{
+    if (sprite->data[0] != 0)
+    {
+        sprite->data[0] = 0;
+        sprite->invisible = FALSE;
+        StartSpriteAnim(sprite, 1);
+    }
+    if (sprite->animEnded)
+        FieldEffectFreeGraphicsResources(sprite);
+}
+
+static void HallOfFameRecordEffectHelper(s32 x, s32 y)
+{
+    CreateSpriteAtEnd(&sUnknown_83CBFB8, x, y, 0);
+}
+
+static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+        FieldEffectFreeGraphicsResources(sprite);
+}
+
+static void FieldCallback_Fly(void);
+static void Task_FlyOut(u8 taskId);
+static void FieldCallback_FlyArrive(void);
+static void Task_FlyIn(u8 taskId);
+
+void ReturnToFieldFromFlyMapSelect(void)
+{
+    SetMainCallback2(CB2_ReturnToField);
+    gFieldCallback = FieldCallback_Fly;
+}
+
+static void FieldCallback_Fly(void)
+{
+    FadeInFromBlack();
+    CreateTask(Task_FlyOut, 0);
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gFieldCallback = NULL;
+}
+
+static void Task_FlyOut(u8 taskId)
+{
+    struct Task * task;
+    task = &gTasks[taskId];
+    if (task->data[0] == 0)
+    {
+        if (!IsWeatherNotFadingIn())
+            return;
+        gFieldEffectArguments[0] = GetCursorSelectionMonId();
+        if ((int)gFieldEffectArguments[0] >= PARTY_SIZE)
+            gFieldEffectArguments[0] = 0;
+        FieldEffectStart(FLDEFF_USE_FLY);
+        task->data[0]++;
+    }
+    if (!FieldEffectActiveListContains(FLDEFF_USE_FLY))
+    {
+        Overworld_ResetStateAfterFly();
+        WarpIntoMap();
+        SetMainCallback2(CB2_LoadMap);
+        gFieldCallback = FieldCallback_FlyArrive;
+        DestroyTask(taskId);
+    }
+}
+
+static void FieldCallback_FlyArrive(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    FadeInFromBlack();
+    CreateTask(Task_FlyIn, 0);
+    gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE;
+    if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+    {
+        ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], DIR_WEST);
+    }
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gFieldCallback = NULL;
+}
+
+static void Task_FlyIn(u8 taskId)
+{
+    struct Task * task;
+    task = &gTasks[taskId];
+    if (task->data[0] == 0)
+    {
+        if (gPaletteFade.active)
+        {
+            return;
+        }
+        FieldEffectStart(FLDEFF_FLY_IN);
+        task->data[0]++;
+    }
+    if (!FieldEffectActiveListContains(FLDEFF_FLY_IN))
+    {
+        ScriptContext2_Disable();
+        UnfreezeObjectEvents();
+        DestroyTask(taskId);
+    }
+}
+
+static void Task_FallWarpFieldEffect(u8 taskId);
+static bool8 FallWarpEffect_1(struct Task * task);
+static bool8 FallWarpEffect_2(struct Task * task);
+static bool8 FallWarpEffect_3(struct Task * task);
+static bool8 FallWarpEffect_4(struct Task * task);
+static bool8 FallWarpEffect_5(struct Task * task);
+static bool8 FallWarpEffect_6(struct Task * task);
+static bool8 FallWarpEffect_7(struct Task * task);
+
+static bool8 (*const sFallWarpEffectCBPtrs[])(struct Task * task) = {
+    FallWarpEffect_1,
+    FallWarpEffect_2,
+    FallWarpEffect_3,
+    FallWarpEffect_4,
+    FallWarpEffect_5,
+    FallWarpEffect_6,
+    FallWarpEffect_7
+};
+
+void FieldCB_FallWarpExit(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    WarpFadeInScreen();
+    sub_8111CF0();
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    CreateTask(Task_FallWarpFieldEffect, 0);
+    gFieldCallback = NULL;
+}
+
+static void Task_FallWarpFieldEffect(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    while (sFallWarpEffectCBPtrs[task->data[0]](task))
+        ;
+}
+
+static bool8 FallWarpEffect_1(struct Task * task)
+{
+    struct ObjectEvent * playerObject;
+    struct Sprite * playerSprite;
+    playerObject = &gObjectEvents[gPlayerAvatar.objectEventId];
+    playerSprite = &gSprites[gPlayerAvatar.spriteId];
+    CameraObjectReset2();
+    gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE;
+    gPlayerAvatar.preventStep = TRUE;
+    ObjectEventSetHeldMovement(playerObject, GetFaceDirectionMovementAction(GetPlayerFacingDirection()));
+    task->data[4] = playerSprite->subspriteMode;
+    playerObject->fixedPriority = TRUE;
+    playerSprite->oam.priority = 1;
+    playerSprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+    task->data[0]++;
+    return TRUE;
+}
+
+static bool8 FallWarpEffect_2(struct Task * task)
+{
+    if (IsWeatherNotFadingIn())
+    {
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 FallWarpEffect_3(struct Task * task)
+{
+    struct Sprite * sprite;
+    s16 centerToCornerVecY;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    centerToCornerVecY = -(sprite->centerToCornerVecY << 1);
+    sprite->pos2.y = -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY);
+    task->data[1] = 1;
+    task->data[2] = 0;
+    gObjectEvents[gPlayerAvatar.objectEventId].invisible = FALSE;
+    PlaySE(SE_RU_HYUU);
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 FallWarpEffect_4(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    struct Sprite * sprite;
+
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.y += task->data[1];
+    if (task->data[1] < 8)
+    {
+        task->data[2] += task->data[1];
+        if (task->data[2] & 0xf)
+        {
+            task->data[1] <<= 1;
+        }
+    }
+    if (task->data[3] == 0 && sprite->pos2.y >= -16)
+    {
+        task->data[3]++;
+        objectEvent->fixedPriority = FALSE;
+        sprite->subspriteMode = task->data[4];
+        objectEvent->triggerGroundEffectsOnMove = TRUE;
+    }
+    if (sprite->pos2.y >= 0)
+    {
+        PlaySE(SE_W070);
+        objectEvent->triggerGroundEffectsOnStop = TRUE;
+        objectEvent->landingJump = TRUE;
+        sprite->pos2.y = 0;
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 FallWarpEffect_5(struct Task * task)
+{
+    task->data[0]++;
+    task->data[1] = 4;
+    task->data[2] = 0;
+    SetCameraPanningCallback(NULL);
+    return TRUE;
+}
+
+static bool8 FallWarpEffect_6(struct Task * task)
+{
+    SetCameraPanning(0, task->data[1]);
+    task->data[1] = -task->data[1];
+    task->data[2]++;
+    if ((task->data[2] & 3) == 0)
+    {
+        task->data[1] >>= 1;
+    }
+    if (task->data[1] == 0)
+    {
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 FallWarpEffect_7(struct Task * task)
+{
+    s16 x, y;
+    gPlayerAvatar.preventStep = FALSE;
+    ScriptContext2_Disable();
+    CameraObjectReset1();
+    UnfreezeObjectEvents();
+    InstallCameraPanAheadCallback();
+    PlayerGetDestCoords(&x, &y);
+    // Seafoam Islands
+    if (sub_8055B38(MapGridGetMetatileBehaviorAt(x, y)) == TRUE)
+    {
+        VarSet(VAR_TEMP_1, 1);
+        SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_SURFING);
+        SetHelpContext(HELPCONTEXT_SURFING);
+    }
+    DestroyTask(FindTaskIdByFunc(Task_FallWarpFieldEffect));
+    return FALSE;
+}
+
+static void Task_EscalatorWarpFieldEffect(u8 taskId);
+static bool8 EscalatorWarpEffect_1(struct Task * task);
+static bool8 EscalatorWarpEffect_2(struct Task * task);
+static bool8 EscalatorWarpEffect_3(struct Task * task);
+static bool8 EscalatorWarpEffect_4(struct Task * task);
+static bool8 EscalatorWarpEffect_5(struct Task * task);
+static bool8 EscalatorWarpEffect_6(struct Task * task);
+static void Escalator_AnimatePlayerGoingDown(struct Task * task);
+static void Escalator_AnimatePlayerGoingUp(struct Task * task);
+static void Escalator_BeginFadeOutToNewMap(void);
+static void Escalator_TransitionToWarpInEffect(void);
+static void FieldCB_EscalatorWarpIn(void);
+static void Task_EscalatorWarpInFieldEffect(u8 taskId);
+static bool8 EscalatorWarpInEffect_1(struct Task * task);
+static bool8 EscalatorWarpInEffect_2(struct Task * task);
+static bool8 EscalatorWarpInEffect_3(struct Task * task);
+static bool8 EscalatorWarpInEffect_4(struct Task * task);
+static bool8 EscalatorWarpInEffect_5(struct Task * task);
+static bool8 EscalatorWarpInEffect_6(struct Task * task);
+static bool8 EscalatorWarpInEffect_7(struct Task * task);
+
+static bool8 (*const sEscalatorWarpFieldEffectFuncs[])(struct Task * task) = {
+    EscalatorWarpEffect_1,
+    EscalatorWarpEffect_2,
+    EscalatorWarpEffect_3,
+    EscalatorWarpEffect_4,
+    EscalatorWarpEffect_5,
+    EscalatorWarpEffect_6
+};
+
+void StartEscalatorWarp(u8 metatileBehavior, u8 priority)
+{
+    u8 taskId = CreateTask(Task_EscalatorWarpFieldEffect, priority);
+    gTasks[taskId].data[1] = 0;
+    if (metatileBehavior == MB_UP_ESCALATOR)
+        gTasks[taskId].data[1] = 1;
+}
+
+static void Task_EscalatorWarpFieldEffect(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    while (sEscalatorWarpFieldEffectFuncs[task->data[0]](task))
+        ;
+}
+
+static bool8 EscalatorWarpEffect_1(struct Task * task)
+{
+    FreezeObjectEvents();
+    CameraObjectReset2();
+    StartEscalator(task->data[1]);
+    sub_81128BC(1);
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 EscalatorWarpEffect_2(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(GetPlayerFacingDirection()));
+        task->data[0]++;
+        task->data[2] = 0;
+        task->data[3] = 0;
+        if ((u8)task->data[1] == 0)
+        {
+            task->data[0] = 4;
+        }
+        PlaySE(SE_ESUKA);
+    }
+    return FALSE;
+}
+
+static bool8 EscalatorWarpEffect_3(struct Task * task)
+{
+    Escalator_AnimatePlayerGoingDown(task);
+    if (task->data[2] > 3)
+    {
+        Escalator_BeginFadeOutToNewMap();
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 EscalatorWarpEffect_4(struct Task * task)
+{
+    Escalator_AnimatePlayerGoingDown(task);
+    Escalator_TransitionToWarpInEffect();
+    return FALSE;
+}
+
+static bool8 EscalatorWarpEffect_5(struct Task * task)
+{
+    Escalator_AnimatePlayerGoingUp(task);
+    if (task->data[2] > 3)
+    {
+        Escalator_BeginFadeOutToNewMap();
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 EscalatorWarpEffect_6(struct Task * task)
+{
+    Escalator_AnimatePlayerGoingUp(task);
+    Escalator_TransitionToWarpInEffect();
+    return FALSE;
+}
+
+
+static void Escalator_AnimatePlayerGoingDown(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x84, task->data[2]);
+    sprite->pos2.y = Sin(0x94, task->data[2]);
+    task->data[3]++;
+    if (task->data[3] & 1)
+    {
+        task->data[2]++;
+    }
+}
+
+static void Escalator_AnimatePlayerGoingUp(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x7c, task->data[2]);
+    sprite->pos2.y = Sin(0x76, task->data[2]);
+    task->data[3]++;
+    if (task->data[3] & 1)
+    {
+        task->data[2]++;
+    }
+}
+
+static void Escalator_BeginFadeOutToNewMap(void)
+{
+    TryFadeOutOldMapMusic();
+    WarpFadeOutScreen();
+}
+
+static void Escalator_TransitionToWarpInEffect(void)
+{
+    if (!gPaletteFade.active && BGMusicStopped() == TRUE)
+    {
+        StopEscalator();
+        WarpIntoMap();
+        gFieldCallback = FieldCB_EscalatorWarpIn;
+        SetMainCallback2(CB2_LoadMap);
+        DestroyTask(FindTaskIdByFunc(Task_EscalatorWarpFieldEffect));
+    }
+}
+
+static bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = {
+    EscalatorWarpInEffect_1,
+    EscalatorWarpInEffect_2,
+    EscalatorWarpInEffect_3,
+    EscalatorWarpInEffect_4,
+    EscalatorWarpInEffect_5,
+    EscalatorWarpInEffect_6,
+    EscalatorWarpInEffect_7
+};
+
+static void FieldCB_EscalatorWarpIn(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    WarpFadeInScreen();
+    sub_8111CF0();
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    CreateTask(Task_EscalatorWarpInFieldEffect, 0);
+    gFieldCallback = NULL;
+}
+
+static void Task_EscalatorWarpInFieldEffect(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    while (sEscalatorWarpInFieldEffectFuncs[task->data[0]](task))
+        ;
+}
+
+static bool8 EscalatorWarpInEffect_1(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    s16 x;
+    s16 y;
+    u8 behavior;
+    CameraObjectReset2();
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(DIR_EAST));
+    PlayerGetDestCoords(&x, &y);
+    behavior = MapGridGetMetatileBehaviorAt(x, y);
+    task->data[0]++;
+    task->data[1] = 16;
+    if (behavior == MB_DOWN_ESCALATOR)
+    {
+        behavior = 1;
+        task->data[0] = 3;
+    } else
+    {
+        behavior = 0;
+    }
+    StartEscalator(behavior);
+    return TRUE;
+}
+
+static bool8 EscalatorWarpInEffect_2(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x84, task->data[1]);
+    sprite->pos2.y = Sin(0x94, task->data[1]);
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 EscalatorWarpInEffect_3(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x84, task->data[1]);
+    sprite->pos2.y = Sin(0x94, task->data[1]);
+    task->data[2]++;
+    if (task->data[2] & 1)
+    {
+        task->data[1]--;
+    }
+    if (task->data[1] == 0)
+    {
+        sprite->pos2.x = 0;
+        sprite->pos2.y = 0;
+        task->data[0] = 5;
+    }
+    return FALSE;
+}
+
+
+static bool8 EscalatorWarpInEffect_4(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x7c, task->data[1]);
+    sprite->pos2.y = Sin(0x76, task->data[1]);
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 EscalatorWarpInEffect_5(struct Task * task)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.x = Cos(0x7c, task->data[1]);
+    sprite->pos2.y = Sin(0x76, task->data[1]);
+    task->data[2]++;
+    if (task->data[2] & 1)
+    {
+        task->data[1]--;
+    }
+    if (task->data[1] == 0)
+    {
+        sprite->pos2.x = 0;
+        sprite->pos2.y = 0;
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 EscalatorWarpInEffect_6(struct Task * task)
+{
+    if (IsEscalatorMoving())
+    {
+        return FALSE;
+    }
+    StopEscalator();
+    task->data[0]++;
+    return TRUE;
+}
+
+static bool8 EscalatorWarpInEffect_7(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        CameraObjectReset1();
+        ScriptContext2_Disable();
+        UnfreezeObjectEvents();
+        ObjectEventSetHeldMovement(objectEvent, GetWalkNormalMovementAction(DIR_EAST));
+        DestroyTask(FindTaskIdByFunc(Task_EscalatorWarpInFieldEffect));
+        sub_81128BC(2);
+    }
+    return FALSE;
+}
+
+static void Task_UseWaterfall(u8 taskId);
+
+static bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj);
+static bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj);
+static bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj);
+static bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj);
+static bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj);
+
+static bool8 (*const sUseWaterfallFieldEffectFuncs[])(struct Task * task, struct ObjectEvent * playerObj) = {
+    waterfall_0_setup,
+    waterfall_1_do_anim_probably,
+    waterfall_2_wait_anim_finish_probably,
+    waterfall_3_move_player_probably,
+    waterfall_4_wait_player_move_probably
+};
+
+u32 FldEff_UseWaterfall(void)
+{
+    u8 taskId = CreateTask(Task_UseWaterfall, 0xFF);
+    gTasks[taskId].data[1] = gFieldEffectArguments[0];
+    Task_UseWaterfall(taskId);
+    return 0;
+}
+
+static void Task_UseWaterfall(u8 taskId)
+{
+    while (sUseWaterfallFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId]))
+        ;
+}
+
+static bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj)
+{
+    ScriptContext2_Enable();
+    gPlayerAvatar.preventStep = TRUE;
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj)
+{
+    ScriptContext2_Enable();
+    if (!ObjectEventIsMovementOverridden(playerObj))
+    {
+        ObjectEventClearHeldMovementIfFinished(playerObj);
+        gFieldEffectArguments[0] = task->data[1];
+        FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj)
+{
+    if (FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON))
+        return FALSE;
+    task->data[0]++;
+    return TRUE;
+}
+
+static bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj)
+{
+    ObjectEventSetHeldMovement(playerObj, sub_8063F2C(DIR_NORTH));
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj)
+{
+    if (!ObjectEventClearHeldMovementIfFinished(playerObj))
+        return FALSE;
+    if (MetatileBehavior_IsWaterfall(playerObj->currentMetatileBehavior))
+    {
+        task->data[0] = 3;
+        return TRUE;
+    }
+    ScriptContext2_Disable();
+    gPlayerAvatar.preventStep = FALSE;
+    DestroyTask(FindTaskIdByFunc(Task_UseWaterfall));
+    FieldEffectActiveListRemove(FLDEFF_USE_WATERFALL);
+    return FALSE;
+}
+
+static void Task_Dive(u8 taskId);
+static bool8 dive_1_lock(struct Task * task);
+static bool8 dive_2_unknown(struct Task * task);
+static bool8 dive_3_unknown(struct Task * task);
+
+static bool8 (*const sDiveFieldEffectFuncPtrs[])(struct Task * task) = {
+    dive_1_lock,
+    dive_2_unknown,
+    dive_3_unknown
+};
+
+u32 FldEff_UseDive(void)
+{
+    u8 taskId = CreateTask(Task_Dive, 0xFF);
+    gTasks[taskId].data[15] = gFieldEffectArguments[0];
+    gTasks[taskId].data[14] = gFieldEffectArguments[1];
+    Task_Dive(taskId);
+    return 0;
+}
+
+static void Task_Dive(u8 taskId)
+{
+    while (sDiveFieldEffectFuncPtrs[gTasks[taskId].data[0]](&gTasks[taskId]))
+        ;
+}
+
+static bool8 dive_1_lock(struct Task * task)
+{
+    gPlayerAvatar.preventStep = TRUE;
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 dive_2_unknown(struct Task * task)
+{
+    ScriptContext2_Enable();
+    gFieldEffectArguments[0] = task->data[15];
+    FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 dive_3_unknown(struct Task * task)
+{
+    struct MapPosition pos;
+    PlayerGetDestCoords(&pos.x, &pos.y);
+    if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON))
+    {
+        dive_warp(&pos, gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior);
+        DestroyTask(FindTaskIdByFunc(Task_Dive));
+        FieldEffectActiveListRemove(FLDEFF_USE_DIVE);
+    }
+    return FALSE;
+}
+
+static void Task_LavaridgeGymB1FWarp(u8 taskId);
+static bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static void FieldCB_LavaridgeGymB1FWarpExit(void);
+static void Task_LavaridgeGymB1FWarpExit(u8 taskId);
+static bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+
+static bool8 (*const sLavaridgeGymB1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = {
+    LavaridgeGymB1FWarpEffect_1,
+    LavaridgeGymB1FWarpEffect_2,
+    LavaridgeGymB1FWarpEffect_3,
+    LavaridgeGymB1FWarpEffect_4,
+    LavaridgeGymB1FWarpEffect_5,
+    LavaridgeGymB1FWarpEffect_6
+};
+
+void StartLavaridgeGymB1FWarp(u8 priority)
+{
+    CreateTask(Task_LavaridgeGymB1FWarp, priority);
+}
+
+static void Task_LavaridgeGymB1FWarp(u8 taskId)
+{
+    while (sLavaridgeGymB1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId]));
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    FreezeObjectEvents();
+    CameraObjectReset2();
+    SetCameraPanningCallback(NULL);
+    gPlayerAvatar.preventStep = TRUE;
+    objectEvent->fixedPriority = TRUE;
+    task->data[1] = 1;
+    task->data[0]++;
+    return TRUE;
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    SetCameraPanning(0, task->data[1]);
+    task->data[1] = -task->data[1];
+    task->data[2]++;
+    if (task->data[2] > 7)
+    {
+        task->data[2] = 0;
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    sprite->pos2.y = 0;
+    task->data[3] = 1;
+    gFieldEffectArguments[0] = objectEvent->currentCoords.x;
+    gFieldEffectArguments[1] = objectEvent->currentCoords.y;
+    gFieldEffectArguments[2] = sprite->subpriority - 1;
+    gFieldEffectArguments[3] = sprite->oam.priority;
+    FieldEffectStart(FLDEFF_LAVARIDGE_GYM_WARP);
+    PlaySE(SE_W153);
+    task->data[0]++;
+    return TRUE;
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    s16 centerToCornerVecY;
+    SetCameraPanning(0, task->data[1]);
+    if (task->data[1] = -task->data[1], ++task->data[2] <= 17)
+    {
+        if (!(task->data[2] & 1) && (task->data[1] <= 3))
+        {
+            task->data[1] <<= 1;
+        }
+    } else if (!(task->data[2] & 4) && (task->data[1] > 0))
+    {
+        task->data[1] >>= 1;
+    }
+    if (task->data[2] > 6)
+    {
+        centerToCornerVecY = -(sprite->centerToCornerVecY << 1);
+        if (sprite->pos2.y > -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY))
+        {
+            sprite->pos2.y -= task->data[3];
+            if (task->data[3] <= 7)
+            {
+                task->data[3]++;
+            }
+        } else
+        {
+            task->data[4] = 1;
+        }
+    }
+    if (task->data[5] == 0 && sprite->pos2.y < -0x10)
+    {
+        task->data[5]++;
+        objectEvent->fixedPriority = TRUE;
+        sprite->oam.priority = 1;
+        sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+    }
+    if (task->data[1] == 0 && task->data[4] != 0)
+    {
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    TryFadeOutOldMapMusic();
+    WarpFadeOutScreen();
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (!gPaletteFade.active && BGMusicStopped() == TRUE)
+    {
+        WarpIntoMap();
+        gFieldCallback = FieldCB_LavaridgeGymB1FWarpExit;
+        SetMainCallback2(CB2_LoadMap);
+        DestroyTask(FindTaskIdByFunc(Task_LavaridgeGymB1FWarp));
+    }
+    return FALSE;
+}
+
+static bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = {
+    LavaridgeGymB1FWarpExitEffect_1,
+    LavaridgeGymB1FWarpExitEffect_2,
+    LavaridgeGymB1FWarpExitEffect_3,
+    LavaridgeGymB1FWarpExitEffect_4
+};
+
+static void FieldCB_LavaridgeGymB1FWarpExit(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    WarpFadeInScreen();
+    sub_8111CF0();
+    ScriptContext2_Enable();
+    gFieldCallback = NULL;
+    CreateTask(Task_LavaridgeGymB1FWarpExit, 0);
+}
+
+static void Task_LavaridgeGymB1FWarpExit(u8 taskId)
+{
+    while (sLavaridgeGymB1FWarpExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId]));
+}
+
+static bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    CameraObjectReset2();
+    FreezeObjectEvents();
+    gPlayerAvatar.preventStep = TRUE;
+    objectEvent->invisible = TRUE;
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (IsWeatherNotFadingIn())
+    {
+        gFieldEffectArguments[0] = objectEvent->currentCoords.x;
+        gFieldEffectArguments[1] = objectEvent->currentCoords.y;
+        gFieldEffectArguments[2] = sprite->subpriority - 1;
+        gFieldEffectArguments[3] = sprite->oam.priority;
+        task->data[1] = FieldEffectStart(FLDEFF_POP_OUT_OF_ASH);
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    sprite = &gSprites[task->data[1]];
+    if (sprite->animCmdIndex > 1)
+    {
+        task->data[0]++;
+        objectEvent->invisible = FALSE;
+        CameraObjectReset1();
+        PlaySE(SE_W091);
+        ObjectEventSetHeldMovement(objectEvent, GetJumpMovementAction(DIR_EAST));
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        gPlayerAvatar.preventStep = FALSE;
+        ScriptContext2_Disable();
+        UnfreezeObjectEvents();
+        DestroyTask(FindTaskIdByFunc(Task_LavaridgeGymB1FWarpExit));
+    }
+    return FALSE;
+}
+
+static void Task_LavaridgeGym1FWarp(u8 taskId);
+static bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite);
+
+static bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = {
+    LavaridgeGym1FWarpEffect_1,
+    LavaridgeGym1FWarpEffect_2,
+    LavaridgeGym1FWarpEffect_3,
+    LavaridgeGym1FWarpEffect_4,
+    LavaridgeGym1FWarpEffect_5
+};
+
+// For the ash puff effect when warping off the B1F ash tiles
+u8 FldEff_LavaridgeGymWarp(void)
+{
+    u8 spriteId;
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[33], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    gSprites[spriteId].oam.priority = gFieldEffectArguments[3];
+    gSprites[spriteId].coordOffsetEnabled = TRUE;
+    return spriteId;
+}
+
+void SpriteCB_LavaridgeGymWarp(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+    {
+        FieldEffectStop(sprite, FLDEFF_LAVARIDGE_GYM_WARP);
+    }
+}
+
+void StartLavaridgeGym1FWarp(u8 priority)
+{
+    CreateTask(Task_LavaridgeGym1FWarp, priority);
+}
+
+static void Task_LavaridgeGym1FWarp(u8 taskId)
+{
+    while(sLavaridgeGym1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId]));
+}
+
+static bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    FreezeObjectEvents();
+    CameraObjectReset2();
+    gPlayerAvatar.preventStep = TRUE;
+    objectEvent->fixedPriority = TRUE;
+    task->data[0]++;
+    return FALSE;
+}
+
+static bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        if (task->data[1] > 3)
+        {
+            gFieldEffectArguments[0] = objectEvent->currentCoords.x;
+            gFieldEffectArguments[1] = objectEvent->currentCoords.y;
+            gFieldEffectArguments[2] = sprite->subpriority - 1;
+            gFieldEffectArguments[3] = sprite->oam.priority;
+            task->data[1] = FieldEffectStart(FLDEFF_POP_OUT_OF_ASH);
+            task->data[0]++;
+        } else
+        {
+            task->data[1]++;
+            ObjectEventSetHeldMovement(objectEvent, GetWalkInPlaceFastMovementAction(objectEvent->facingDirection));
+            PlaySE(SE_FU_ZUZUZU);
+        }
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (gSprites[task->data[1]].animCmdIndex == 2)
+    {
+        objectEvent->invisible = TRUE;
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (!FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH))
+    {
+        TryFadeOutOldMapMusic();
+        WarpFadeOutScreen();
+        task->data[0]++;
+    }
+    return FALSE;
+}
+
+static bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    if (!gPaletteFade.active && BGMusicStopped() == TRUE)
+    {
+        WarpIntoMap();
+        gFieldCallback = FieldCB_FallWarpExit;
+        SetMainCallback2(CB2_LoadMap);
+        DestroyTask(FindTaskIdByFunc(Task_LavaridgeGym1FWarp));
+    }
+    return FALSE;
+}
+
+u8 FldEff_PopOutOfAsh(void)
+{
+    u8 spriteId;
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[32], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    gSprites[spriteId].oam.priority = gFieldEffectArguments[3];
+    gSprites[spriteId].coordOffsetEnabled = TRUE;
+    return spriteId;
+}
+
+void SpriteCB_PopOutOfAsh(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+    {
+        FieldEffectStop(sprite, FLDEFF_POP_OUT_OF_ASH);
+    }
+}
+
+static void Task_DoEscapeRopeFieldEffect(u8 taskId);
+static void EscapeRopeFieldEffect_Step0(struct Task * task);
+static void EscapeRopeFieldEffect_Step1(struct Task * task);
+static u8 sub_808576C(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p);
+static bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p);
+static void FieldCallback_EscapeRopeExit(void);
+static void Task_DoEscapeRopeExitFieldEffect(u8 taskId);
+static void EscapeRopeExitFieldEffect_Step0(struct Task * task);
+static void EscapeRopeExitFieldEffect_Step1(struct Task * task);
+
+static void (*const gEscapeRopeFieldEffectFuncs[])(struct Task * task) = {
+    EscapeRopeFieldEffect_Step0,
+    EscapeRopeFieldEffect_Step1
+};
+
+void StartEscapeRopeFieldEffect(void)
+{
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    CreateTask(Task_DoEscapeRopeFieldEffect, 80);
+}
+
+static void Task_DoEscapeRopeFieldEffect(u8 taskId)
+{
+    gEscapeRopeFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void EscapeRopeFieldEffect_Step0(struct Task * task)
+{
+    task->data[0]++;
+    task->data[13] = 64;
+    task->data[14] = GetPlayerFacingDirection();
+    task->data[15] = 0;
+}
+
+static void EscapeRopeFieldEffect_Step1(struct Task * task)
+{
+    struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    s16 *data = task->data;
+    sub_808576C(playerObj, &task->data[1], &task->data[2]);
+    if (data[3] < 60)
+    {
+        data[3]++;
+        if (data[3] == 20)
+        {
+            PlaySE(SE_TK_WARPIN);
+        }
+    }
+    else if (data[4] == 0 && !sub_80857F0(playerObj, &task->data[5], &task->data[6]))
+    {
+        TryFadeOutOldMapMusic();
+        WarpFadeOutScreen();
+        data[4] = 1;
+    }
+    if (data[4] == 1 && !gPaletteFade.active && BGMusicStopped() == TRUE)
+    {
+        SetObjectEventDirection(playerObj, task->data[15]);
+        sub_80555E0();
+        WarpIntoMap();
+        gFieldCallback = FieldCallback_EscapeRopeExit;
+        SetMainCallback2(CB2_LoadMap);
+        DestroyTask(FindTaskIdByFunc(Task_DoEscapeRopeFieldEffect));
+    }
+}
+
+static const u8 sUnknown_83CC0E8[] = {
+    [DIR_NONE]  = DIR_SOUTH,
+    [DIR_SOUTH] = DIR_WEST,
+    [DIR_WEST]  = DIR_NORTH,
+    [DIR_NORTH] = DIR_EAST,
+    [DIR_EAST]  = DIR_SOUTH,
+};
+
+static u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p)
+{
+    if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj))
+    {
+        if (*delay_p != 0 && --(*delay_p) != 0)
+            return playerObj->facingDirection;
+        ObjectEventSetHeldMovement(playerObj, GetFaceDirectionMovementAction(sUnknown_83CC0E8[playerObj->facingDirection]));
+        if (*stage_p < 12)
+            (*stage_p)++;
+        *delay_p = 12 >> (*stage_p); // 12 >> 4 = 0
+        return sUnknown_83CC0E8[playerObj->facingDirection];
+    }
+    return playerObj->facingDirection;
+}
+
+static bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p)
+{
+    struct Sprite * sprite = &gSprites[playerObj->spriteId];
+    switch (*state_p)
+    {
+    case 0:
+        CameraObjectReset2();
+        (*state_p)++;
+        // fallthrough
+    case 1:
+        sprite->pos2.y -= 8;
+        (*y_p) -= 8;
+        if (*y_p <= -16)
+        {
+            playerObj->fixedPriority = TRUE;
+            sprite->oam.priority = 1;
+            sprite->subpriority = 0;
+            sprite->subspriteMode = SUBSPRITES_OFF;
+            (*state_p)++;
+        }
+        break;
+    case 2:
+        sprite->pos2.y -= 8;
+        (*y_p) -= 8;
+        if (*y_p <= -88)
+        {
+            (*state_p)++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = {
+    EscapeRopeExitFieldEffect_Step0,
+    EscapeRopeExitFieldEffect_Step1
+};
+
+static bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 *priority_p, s16 *subpriority_p, s16 *subspriteMode_p)
+{
+    struct Sprite * sprite = &gSprites[playerObj->spriteId];
+    switch (*state_p)
+    {
+    case 0:
+        CameraObjectReset2();
+        *y_p = -88;
+        sprite->pos2.y -= 88;
+        *priority_p = sprite->oam.priority;
+        *subpriority_p = sprite->subpriority;
+        *subspriteMode_p = sprite->subspriteMode;
+        playerObj->fixedPriority = TRUE;
+        sprite->oam.priority = 1;
+        sprite->subpriority = 0;
+        sprite->subspriteMode = SUBSPRITES_OFF;
+        (*state_p)++;
+        // fallthrough
+    case 1:
+        sprite->pos2.y += 4;
+        (*y_p) += 4;
+        if (*y_p >= -16)
+        {
+            sprite->oam.priority = *priority_p;
+            sprite->subpriority = *subpriority_p;
+            sprite->subspriteMode = *subspriteMode_p;
+            (*state_p)++;
+        }
+        break;
+    case 2:
+        sprite->pos2.y += 4;
+        (*y_p) += 4;
+        if (*y_p >= 0)
+        {
+            PlaySE(SE_TK_KASYA);
+            CameraObjectReset1();
+            (*state_p)++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static void FieldCallback_EscapeRopeExit(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    WarpFadeInScreen();
+    sub_8111CF0();
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gFieldCallback = NULL;
+    gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE;
+    CreateTask(Task_DoEscapeRopeExitFieldEffect, 0);
+}
+
+static void Task_DoEscapeRopeExitFieldEffect(u8 taskId)
+{
+    sEscapeRopeExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void EscapeRopeExitFieldEffect_Step0(struct Task * task)
+{
+    if (IsWeatherNotFadingIn())
+    {
+        PlaySE(SE_TK_WARPOUT);
+        task->data[15] = GetPlayerFacingDirection();
+        task->data[0]++;
+    }
+}
+
+static void EscapeRopeExitFieldEffect_Step1(struct Task * task)
+{
+    s16 *data = task->data;
+    struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    bool32 finished = sub_80858A4(playerObj, &data[1], &data[2], &data[3], &data[4], &data[5]);
+    playerObj->invisible = FALSE;
+    if (data[6] < 8)
+        data[6]++;
+    else if (data[7] == 0)
+    {
+        data[6]++;
+        data[8] = sub_808576C(playerObj, &data[9], &data[10]);
+        if (data[6] >= 50 && data[8] == data[15])
+            data[7] = 1;
+    }
+    if (!finished && data[8] == data[15] && ObjectEventCheckHeldMovementStatus(playerObj) == TRUE)
+    {
+        playerObj->invisible = FALSE;
+        playerObj->fixedPriority = FALSE;
+        ScriptContext2_Disable();
+        UnfreezeObjectEvents();
+        DestroyTask(FindTaskIdByFunc(Task_DoEscapeRopeExitFieldEffect));
+    }
+}
+
+static void Task_DoTeleportFieldEffect(u8 taskId);
+static void TeleportFieldEffectTask1(struct Task * task);
+static void TeleportFieldEffectTask2(struct Task * task);
+static void TeleportFieldEffectTask3(struct Task * task);
+static void TeleportFieldEffectTask4(struct Task * task);
+static void FieldCallback_TeleportIn(void);
+static void Task_DoTeleportInFieldEffect(u8 taskId);
+static void TeleportInFieldEffectTask1(struct Task * task);
+static void TeleportInFieldEffectTask2(struct Task * task);
+static void TeleportInFieldEffectTask3(struct Task * task);
+
+static void (*const sTeleportEffectFuncs[])(struct Task * ) = {
+    TeleportFieldEffectTask1,
+    TeleportFieldEffectTask2,
+    TeleportFieldEffectTask3,
+    TeleportFieldEffectTask4
+};
+
+void CreateTeleportFieldEffectTask(void)
+{
+    CreateTask(Task_DoTeleportFieldEffect, 0);
+}
+
+static void Task_DoTeleportFieldEffect(u8 taskId)
+{
+    sTeleportEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void TeleportFieldEffectTask1(struct Task * task)
+{
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    CameraObjectReset2();
+    task->data[15] = GetPlayerFacingDirection();
+    task->data[0]++;
+}
+
+static void TeleportFieldEffectTask2(struct Task * task)
+{
+    u8 spinDirections[5] = {
+        [DIR_NONE]  = DIR_SOUTH,
+        [DIR_SOUTH] = DIR_WEST,
+        [DIR_WEST]  = DIR_NORTH,
+        [DIR_NORTH] = DIR_EAST,
+        [DIR_EAST]  = DIR_SOUTH
+    };
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (task->data[1] == 0 || (--task->data[1]) == 0)
+    {
+        ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]);
+        task->data[1] = 8;
+        task->data[2]++;
+    }
+    if (task->data[2] > 7 && task->data[15] == objectEvent->facingDirection)
+    {
+        task->data[0]++;
+        task->data[1] = 4;
+        task->data[2] = 8;
+        task->data[3] = 1;
+        PlaySE(SE_TK_WARPIN);
+    }
+}
+
+static void TeleportFieldEffectTask3(struct Task * task)
+{
+    u8 spinDirections[5] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH};
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId];
+    if ((--task->data[1]) <= 0)
+    {
+        task->data[1] = 4;
+        ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]);
+    }
+    sprite->pos1.y -= task->data[3];
+    task->data[4] += task->data[3];
+    if ((--task->data[2]) <= 0 && (task->data[2] = 4, task->data[3] < 8))
+    {
+        task->data[3] <<= 1;
+    }
+    if (task->data[4] > 8 && (sprite->oam.priority = 1, sprite->subspriteMode != SUBSPRITES_OFF))
+    {
+        sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+    }
+    if (task->data[4] >= 0xa8)
+    {
+        task->data[0]++;
+        TryFadeOutOldMapMusic();
+        WarpFadeOutScreen();
+    }
+}
+
+static void TeleportFieldEffectTask4(struct Task * task)
+{
+    if (!gPaletteFade.active)
+    {
+        if (BGMusicStopped() == TRUE)
+        {
+            copy_saved_warp3_bank_and_enter_x_to_warp1();
+            WarpIntoMap();
+            SetMainCallback2(CB2_LoadMap);
+            gFieldCallback = FieldCallback_TeleportIn;
+            DestroyTask(FindTaskIdByFunc(Task_DoTeleportFieldEffect));
+        }
+    }
+}
+
+static void (*const sTeleportInEffectFuncs[])(struct Task * ) = {
+    TeleportInFieldEffectTask1,
+    TeleportInFieldEffectTask2,
+    TeleportInFieldEffectTask3
+};
+
+static void FieldCallback_TeleportIn(void)
+{
+    Overworld_PlaySpecialMapMusic();
+    WarpFadeInScreen();
+    sub_8111CF0();
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gFieldCallback = NULL;
+    gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE;
+    CameraObjectReset2();
+    CreateTask(Task_DoTeleportInFieldEffect, 0);
+}
+
+static void Task_DoTeleportInFieldEffect(u8 taskId)
+{
+    sTeleportInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void TeleportInFieldEffectTask1(struct Task * task)
+{
+    struct Sprite * sprite;
+    s16 centerToCornerVecY;
+    if (IsWeatherNotFadingIn())
+    {
+        sprite = &gSprites[gPlayerAvatar.spriteId];
+        centerToCornerVecY = -(sprite->centerToCornerVecY << 1);
+        sprite->pos2.y = -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY);
+        gObjectEvents[gPlayerAvatar.objectEventId].invisible = FALSE;
+        task->data[0]++;
+        task->data[1] = 8;
+        task->data[2] = 1;
+        task->data[14] = sprite->subspriteMode;
+        task->data[15] = GetPlayerFacingDirection();
+        PlaySE(SE_TK_WARPIN);
+    }
+}
+
+static void TeleportInFieldEffectTask2(struct Task * task)
+{
+    u8 spinDirections[5] = {1, 3, 4, 2, 1};
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId];
+    if ((sprite->pos2.y += task->data[1]) >= -8)
+    {
+        if (task->data[13] == 0)
+        {
+            task->data[13]++;
+            objectEvent->triggerGroundEffectsOnMove = TRUE;
+            sprite->subspriteMode = task->data[14];
+        }
+    } else
+    {
+        sprite->oam.priority = 1;
+        if (sprite->subspriteMode != SUBSPRITES_OFF)
+        {
+            sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+        }
+    }
+    if (sprite->pos2.y >= -0x30 && task->data[1] > 1 && !(sprite->pos2.y & 1))
+    {
+        task->data[1]--;
+    }
+    if ((--task->data[2]) == 0)
+    {
+        task->data[2] = 4;
+        ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]);
+    }
+    if (sprite->pos2.y >= 0)
+    {
+        sprite->pos2.y = 0;
+        task->data[0]++;
+        task->data[1] = 1;
+        task->data[2] = 0;
+    }
+}
+
+static void TeleportInFieldEffectTask3(struct Task * task)
+{
+    u8 spinDirections[5] = {1, 3, 4, 2, 1};
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if ((--task->data[1]) == 0)
+    {
+        ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]);
+        task->data[1] = 8;
+        if ((++task->data[2]) > 4 && task->data[14] == objectEvent->facingDirection)
+        {
+            ScriptContext2_Disable();
+            CameraObjectReset1();
+            UnfreezeObjectEvents();
+            DestroyTask(FindTaskIdByFunc(Task_DoTeleportInFieldEffect));
+        }
+    }
+}
+
+static void Task_ShowMon_Outdoors(u8 taskId);
+static void ShowMonEffect_Outdoors_1(struct Task * task);
+static void ShowMonEffect_Outdoors_2(struct Task * task);
+static void ShowMonEffect_Outdoors_3(struct Task * task);
+static void ShowMonEffect_Outdoors_4(struct Task * task);
+static void ShowMonEffect_Outdoors_5(struct Task * task);
+static void ShowMonEffect_Outdoors_6(struct Task * task);
+static void ShowMonEffect_Outdoors_7(struct Task * task);
+static void VBlankCB_ShowMonEffect_Outdoors(void);
+static void LoadFieldMoveStreaksTilemapToVram(u16 screenbase);
+static void Task_ShowMon_Indoors(u8 taskId);
+static void ShowMonEffect_Indoors_1(struct Task * task);
+static void ShowMonEffect_Indoors_2(struct Task * task);
+static void ShowMonEffect_Indoors_3(struct Task * task);
+static void ShowMonEffect_Indoors_4(struct Task * task);
+static void ShowMonEffect_Indoors_5(struct Task * task);
+static void ShowMonEffect_Indoors_6(struct Task * task);
+static void ShowMonEffect_Indoors_7(struct Task * task);
+static void VBlankCB_ShowMonEffect_Indoors(void);
+static void sub_8086728(struct Task * task);
+static bool8 sub_8086738(struct Task * task);
+static bool8 sub_80867F0(struct Task * task);
+static u8 sub_8086860(u32 species, u32 otId, u32 personality);
+static void sub_80868C0(struct Sprite * sprite);
+static void sub_8086904(struct Sprite * sprite);
+static void sub_8086920(struct Sprite * sprite);
+
+static void (*const sShowMonOutdoorsEffectFuncs[])(struct Task * task) = {
+    ShowMonEffect_Outdoors_1,
+    ShowMonEffect_Outdoors_2,
+    ShowMonEffect_Outdoors_3,
+    ShowMonEffect_Outdoors_4,
+    ShowMonEffect_Outdoors_5,
+    ShowMonEffect_Outdoors_6,
+    ShowMonEffect_Outdoors_7
+};
+
+u32 FldEff_FieldMoveShowMon(void)
+{
+    u8 taskId;
+    if (IsMapTypeOutdoors(GetCurrentMapType()) == TRUE)
+        taskId = CreateTask(Task_ShowMon_Outdoors, 0xFF);
+    else
+        taskId = CreateTask(Task_ShowMon_Indoors, 0xFF);
+    gTasks[taskId].data[15] = sub_8086860(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    return 0;
+}
+
+u32 FldEff_FieldMoveShowMonInit(void)
+{
+    u32 r6 = gFieldEffectArguments[0] & 0x80000000;
+    u8 partyIdx = gFieldEffectArguments[0];
+    gFieldEffectArguments[0] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES);
+    gFieldEffectArguments[1] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_OT_ID);
+    gFieldEffectArguments[2] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_PERSONALITY);
+    gFieldEffectArguments[0] |= r6;
+    FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON);
+    FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
+    return 0;
+}
+
+static void Task_ShowMon_Outdoors(u8 taskId)
+{
+    sShowMonOutdoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void ShowMonEffect_Outdoors_1(struct Task * task)
+{
+    task->data[11] = GetGpuReg(REG_OFFSET_WININ);
+    task->data[12] = GetGpuReg(REG_OFFSET_WINOUT);
+    StoreWordInTwoHalfwords((u16*)&task->data[13], (u32)gMain.vblankCallback);
+    task->data[1] = WIN_RANGE(0xF0, 0xF1);
+    task->data[2] = WIN_RANGE(0x50, 0x51);
+    task->data[3] = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR;
+    task->data[4] = WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR;
+    SetGpuReg(REG_OFFSET_WIN0H, task->data[1]);
+    SetGpuReg(REG_OFFSET_WIN0V, task->data[2]);
+    SetGpuReg(REG_OFFSET_WININ, task->data[3]);
+    SetGpuReg(REG_OFFSET_WINOUT, task->data[4]);
+    SetVBlankCallback(VBlankCB_ShowMonEffect_Outdoors);
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Outdoors_2(struct Task * task)
+{
+    u16 charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14);
+    u16 screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11);
+    CpuCopy16(sFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x200);
+    CpuFill32(0, (void *)(VRAM + screenbase), 0x800);
+    LoadPalette(sFieldMoveStreaksPalette, 0xf0, 0x20);
+    LoadFieldMoveStreaksTilemapToVram(screenbase);
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Outdoors_3(struct Task * task)
+{
+    s16 win0h_lo;
+    s16 win0v_lo;
+    s16 win0v_hi;
+    task->data[5] -= 16;
+    win0h_lo = ((u16)task->data[1] >> 8);
+    win0v_lo = ((u16)task->data[2] >> 8);
+    win0v_hi = ((u16)task->data[2] & 0xff);
+    win0h_lo -= 16;
+    win0v_lo -= 2;
+    win0v_hi += 2;
+    if (win0h_lo < 0)
+    {
+        win0h_lo = 0;
+    }
+    if (win0v_lo < 0x28)
+    {
+        win0v_lo = 0x28;
+    }
+    if (win0v_hi > 0x78)
+    {
+        win0v_hi = 0x78;
+    }
+    task->data[1] = WIN_RANGE(win0h_lo, task->data[1] & 0xff);
+    task->data[2] = WIN_RANGE(win0v_lo, win0v_hi);
+    if (win0h_lo == 0 && win0v_lo == 0x28 && win0v_hi == 0x78)
+    {
+        gSprites[task->data[15]].callback = sub_80868C0;
+        task->data[0]++;
+    }
+}
+
+static void ShowMonEffect_Outdoors_4(struct Task * task)
+{
+    task->data[5] -= 16;
+    if (gSprites[task->data[15]].data[7])
+    {
+        task->data[0]++;
+    }
+}
+
+static void ShowMonEffect_Outdoors_5(struct Task * task)
+{
+    s16 win0v_lo;
+    s16 win0v_hi;
+    task->data[5] -= 16;
+    win0v_lo = (task->data[2] >> 8);
+    win0v_hi = (task->data[2] & 0xff);
+    win0v_lo += 6;
+    win0v_hi -= 6;
+    if (win0v_lo > 0x50)
+    {
+        win0v_lo = 0x50;
+    }
+    if (win0v_hi < 0x51)
+    {
+        win0v_hi = 0x51;
+    }
+    task->data[2] = WIN_RANGE(win0v_lo, win0v_hi);
+    if (win0v_lo == 0x50 && win0v_hi == 0x51)
+    {
+        task->data[0]++;
+    }
+}
+
+static void ShowMonEffect_Outdoors_6(struct Task * task)
+{
+    u16 bg0cnt = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11;
+    CpuFill32(0, (void *)VRAM + bg0cnt, 0x800);
+    task->data[1] = WIN_RANGE(0x00, 0xf1);
+    task->data[2] = WIN_RANGE(0x00, 0xa1);
+    task->data[3] = task->data[11];
+    task->data[4] = task->data[12];
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Outdoors_7(struct Task * task)
+{
+    IntrCallback callback;
+    LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&callback);
+    SetVBlankCallback(callback);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    Menu_LoadStdPal();
+    FreeResourcesAndDestroySprite(&gSprites[task->data[15]], task->data[15]);
+    FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON);
+    DestroyTask(FindTaskIdByFunc(Task_ShowMon_Outdoors));
+}
+
+static void VBlankCB_ShowMonEffect_Outdoors(void)
+{
+    IntrCallback callback;
+    struct Task * task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Outdoors)];
+    LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&callback);
+    callback();
+    SetGpuReg(REG_OFFSET_WIN0H, task->data[1]);
+    SetGpuReg(REG_OFFSET_WIN0V, task->data[2]);
+    SetGpuReg(REG_OFFSET_WININ, task->data[3]);
+    SetGpuReg(REG_OFFSET_WINOUT, task->data[4]);
+    SetGpuReg(REG_OFFSET_BG0HOFS, task->data[5]);
+    SetGpuReg(REG_OFFSET_BG0VOFS, task->data[6]);
+}
+
+static void LoadFieldMoveStreaksTilemapToVram(u16 screenbase)
+{
+    u16 i;
+    u16 *dest;
+    dest = (u16 *)(VRAM + (10 * 32) + screenbase);
+    for (i = 0; i < (10 * 32); i++, dest++)
+    {
+        *dest = sFieldMoveStreaksTilemap[i] | METATILE_ELEVATION_MASK;
+    }
+}
+
+static void (*const sShowMonIndoorsEffectFuncs[])(struct Task * ) = {
+    ShowMonEffect_Indoors_1,
+    ShowMonEffect_Indoors_2,
+    ShowMonEffect_Indoors_3,
+    ShowMonEffect_Indoors_4,
+    ShowMonEffect_Indoors_5,
+    ShowMonEffect_Indoors_6,
+    ShowMonEffect_Indoors_7
+};
+
+static void Task_ShowMon_Indoors(u8 taskId)
+{
+    sShowMonIndoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void ShowMonEffect_Indoors_1(struct Task * task)
+{
+    SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]);
+    SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]);
+    StoreWordInTwoHalfwords((u16 *)&task->data[13], (u32)gMain.vblankCallback);
+    SetVBlankCallback(VBlankCB_ShowMonEffect_Indoors);
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Indoors_2(struct Task * task)
+{
+    u16 charbase;
+    u16 screenbase;
+    charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14);
+    screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11);
+    task->data[12] = screenbase;
+    CpuCopy16(sDarknessFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x80);
+    CpuFill32(0, (void *)(VRAM + screenbase), 0x800);
+    LoadPalette(sDarknessFieldMoveStreaksPalette, 0xf0, 0x20);
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Indoors_3(struct Task * task)
+{
+    if (sub_8086738(task))
+    {
+        task->data[5] = GetGpuReg(REG_OFFSET_WININ);
+        SetGpuReg(REG_OFFSET_WININ, (task->data[5] & 0xFF) | WININ_WIN1_BG0 | WININ_WIN1_OBJ);
+        SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(0x00, 0xf0));
+        SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(0x28, 0x78));
+        gSprites[task->data[15]].callback = sub_80868C0;
+        task->data[0]++;
+    }
+    sub_8086728(task);
+}
+
+static void ShowMonEffect_Indoors_4(struct Task * task)
+{
+    sub_8086728(task);
+    if (gSprites[task->data[15]].data[7])
+    {
+        task->data[0]++;
+    }
+}
+
+static void ShowMonEffect_Indoors_5(struct Task * task)
+{
+    sub_8086728(task);
+    task->data[3] = task->data[1] & 7;
+    task->data[4] = 0;
+    SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(0xff, 0xff));
+    SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(0xff, 0xff));
+    SetGpuReg(REG_OFFSET_WININ, task->data[5]);
+    task->data[0]++;
+}
+
+static void ShowMonEffect_Indoors_6(struct Task * task)
+{
+    sub_8086728(task);
+    if (sub_80867F0(task))
+    {
+        task->data[0]++;
+    }
+}
+
+static void ShowMonEffect_Indoors_7(struct Task * task)
+{
+    IntrCallback intrCallback;
+    u16 charbase;
+    charbase = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11;
+    CpuFill32(0, (void *)VRAM + charbase, 0x800);
+    LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&intrCallback);
+    SetVBlankCallback(intrCallback);
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    Menu_LoadStdPal();
+    FreeResourcesAndDestroySprite(&gSprites[task->data[15]], task->data[15]);
+    FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON);
+    DestroyTask(FindTaskIdByFunc(Task_ShowMon_Indoors));
+}
+
+static void VBlankCB_ShowMonEffect_Indoors(void)
+{
+    IntrCallback intrCallback;
+    struct Task * task;
+    task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Indoors)];
+    LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&intrCallback);
+    intrCallback();
+    SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]);
+    SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]);
+}
+
+static void sub_8086728(struct Task * task)
+{
+    task->data[1] -= 16;
+    task->data[3] += 16;
+}
+
+static bool8 sub_8086738(struct Task * task)
+{
+    u16 i;
+    u16 srcOffs;
+    u16 dstOffs;
+    u16 *dest;
+    if (task->data[4] >= 32)
+    {
+        return TRUE;
+    }
+    dstOffs = (task->data[3] >> 3) & 0x1f;
+    if (dstOffs >= task->data[4])
+    {
+        dstOffs = (32 - dstOffs) & 0x1f;
+        srcOffs = (32 - task->data[4]) & 0x1f;
+        dest = (u16 *)(VRAM + 0x140 + (u16)task->data[12]);
+        for (i = 0; i < 10; i++)
+        {
+            dest[dstOffs + i * 32] = sDarknessFieldMoveStreaksTilemap[srcOffs + i * 32];
+            dest[dstOffs + i * 32] |= 0xf000;
+
+            dest[((dstOffs + 1) & 0x1f) + i * 32] = sDarknessFieldMoveStreaksTilemap[((srcOffs + 1) & 0x1f) + i * 32] | 0xf000;
+            dest[((dstOffs + 1) & 0x1f) + i * 32] |= 0xf000;
+        }
+        task->data[4] += 2;
+    }
+    return FALSE;
+}
+
+static bool8 sub_80867F0(struct Task * task)
+{
+    u16 i;
+    u16 dstOffs;
+    u16 *dest;
+    if (task->data[4] >= 32)
+    {
+        return TRUE;
+    }
+    dstOffs = task->data[3] >> 3;
+    if (dstOffs >= task->data[4])
+    {
+        dstOffs = (task->data[1] >> 3) & 0x1f;
+        dest = (u16 *)(VRAM + 0x140 + (u16)task->data[12]);
+        for (i = 0; i < 10; i++)
+        {
+            dest[dstOffs + i * 32] = 0xf000;
+            dest[((dstOffs + 1) & 0x1f) + i * 32] = 0xf000;
+        }
+        task->data[4] += 2;
+    }
+    return FALSE;
+}
+
+static u8 sub_8086860(u32 species, u32 otId, u32 personality)
+{
+    bool16 playCry;
+    u8 monSprite;
+    struct Sprite * sprite;
+    playCry = (species & 0x80000000) >> 16;
+    species &= 0x7fffffff;
+    monSprite = CreateMonSprite_FieldMove(species, otId, personality, 0x140, 0x50, 0);
+    sprite = &gSprites[monSprite];
+    sprite->callback = SpriteCallbackDummy;
+    sprite->oam.priority = 0;
+    sprite->data[0] = species;
+    sprite->data[6] = playCry;
+    return monSprite;
+}
+
+static void sub_80868C0(struct Sprite * sprite)
+{
+    if ((sprite->pos1.x -= 20) <= 0x78)
+    {
+        sprite->pos1.x = 0x78;
+        sprite->data[1] = 30;
+        sprite->callback = sub_8086904;
+        if (sprite->data[6])
+        {
+            PlayCry2(sprite->data[0], 0, 0x7d, 0xa);
+        }
+        else
+        {
+            PlayCry1(sprite->data[0], 0);
+        }
+    }
+}
+
+static void sub_8086904(struct Sprite * sprite)
+{
+    if ((--sprite->data[1]) == 0)
+    {
+        sprite->callback = sub_8086920;
+    }
+}
+
+static void sub_8086920(struct Sprite * sprite)
+{
+    if (sprite->pos1.x < -0x40)
+    {
+        sprite->data[7] = 1;
+    }
+    else
+    {
+        sprite->pos1.x -= 20;
+    }
+}
+
+static void Task_FldEffUseSurf(u8 taskId);
+static void UseSurfEffect_1(struct Task * task);
+static void UseSurfEffect_2(struct Task * task);
+static void UseSurfEffect_3(struct Task * task);
+static void UseSurfEffect_4(struct Task * task);
+static void UseSurfEffect_5(struct Task * task);
+
+static void (*const sUseSurfEffectFuncs[])(struct Task * ) = {
+    UseSurfEffect_1,
+    UseSurfEffect_2,
+    UseSurfEffect_3,
+    UseSurfEffect_4,
+    UseSurfEffect_5,
+};
+
+u8 FldEff_UseSurf(void)
+{
+    u8 taskId = CreateTask(Task_FldEffUseSurf, 0xff);
+    gTasks[taskId].data[15] = gFieldEffectArguments[0];
+    sav1_reset_battle_music_maybe();
+    if (sub_8056124(MUS_NAMINORI))
+        Overworld_ChangeMusicTo(MUS_NAMINORI);
+    return FALSE;
+}
+
+static void Task_FldEffUseSurf(u8 taskId)
+{
+    sUseSurfEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void UseSurfEffect_1(struct Task * task)
+{
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gPlayerAvatar.preventStep = TRUE;
+    SetPlayerAvatarStateMask(8);
+    PlayerGetDestCoords(&task->data[1], &task->data[2]);
+    MoveCoords(gObjectEvents[gPlayerAvatar.objectEventId].movementDirection, &task->data[1], &task->data[2]);
+    task->data[0]++;
+}
+
+static void UseSurfEffect_2(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        sub_805CB70();
+        ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION);
+        task->data[0]++;
+    }
+}
+
+static void UseSurfEffect_3(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventCheckHeldMovementStatus(objectEvent))
+    {
+        gFieldEffectArguments[0] = task->data[15] | 0x80000000;
+        FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
+        task->data[0]++;
+    }
+}
+
+static void UseSurfEffect_4(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON))
+    {
+        objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2));
+        ObjectEventClearHeldMovementIfFinished(objectEvent);
+        ObjectEventSetHeldMovement(objectEvent, sub_80641C0(objectEvent->movementDirection));
+        gFieldEffectArguments[0] = task->data[1];
+        gFieldEffectArguments[1] = task->data[2];
+        gFieldEffectArguments[2] = gPlayerAvatar.objectEventId;
+        objectEvent->fieldEffectSpriteId = FieldEffectStart(FLDEFF_SURF_BLOB);
+        task->data[0]++;
+    }
+}
+
+static void UseSurfEffect_5(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        gPlayerAvatar.preventStep = FALSE;
+        gPlayerAvatar.flags &= 0xdf;
+        ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(objectEvent->movementDirection));
+        sub_80DC44C(objectEvent->fieldEffectSpriteId, 1);
+        UnfreezeObjectEvents();
+        ScriptContext2_Disable();
+        FieldEffectActiveListRemove(FLDEFF_USE_SURF);
+        DestroyTask(FindTaskIdByFunc(Task_FldEffUseSurf));
+        SetHelpContext(HELPCONTEXT_SURFING);
+    }
+}
+
+static void Task_FldEffUseVsSeeker(u8 taskId);
+static void UseVsSeekerEffect_1(struct Task * task);
+static void UseVsSeekerEffect_2(struct Task * task);
+static void UseVsSeekerEffect_3(struct Task * task);
+static void UseVsSeekerEffect_4(struct Task * task);
+
+static void (*const sUseVsSeekerEffectFuncs[])(struct Task * task) = {
+    UseVsSeekerEffect_1,
+    UseVsSeekerEffect_2,
+    UseVsSeekerEffect_3,
+    UseVsSeekerEffect_4
+};
+
+u32 FldEff_UseVsSeeker(void)
+{
+    if (gQuestLogState == QL_STATE_1)
+        sub_811278C(8, 89);
+    CreateTask(Task_FldEffUseVsSeeker, 0xFF);
+    return 0;
+}
+
+static void Task_FldEffUseVsSeeker(u8 taskId)
+{
+    sUseVsSeekerEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void UseVsSeekerEffect_1(struct Task * task)
+{
+    ScriptContext2_Enable();
+    FreezeObjectEvents();
+    gPlayerAvatar.preventStep = TRUE;
+    task->data[0]++;
+}
+
+static void UseVsSeekerEffect_2(struct Task * task)
+{
+    struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj))
+    {
+        sub_805CBE8();
+        ObjectEventSetHeldMovement(playerObj, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION);
+        task->data[0]++;
+    }
+}
+
+static void UseVsSeekerEffect_3(struct Task * task)
+{
+    struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventClearHeldMovementIfFinished(playerObj))
+    {
+        if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_ACRO_BIKE | PLAYER_AVATAR_FLAG_MACH_BIKE))
+            ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(1));
+        else if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+            ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(2));
+        else
+            ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(0));
+        ObjectEventForceSetHeldMovement(playerObj, GetFaceDirectionMovementAction(playerObj->facingDirection));
+        task->data[0]++;
+    }
+}
+
+static void UseVsSeekerEffect_4(struct Task * task)
+{
+    struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventClearHeldMovementIfFinished(playerObj))
+    {
+        gPlayerAvatar.preventStep = FALSE;
+        FieldEffectActiveListRemove(FLDEFF_USE_VS_SEEKER);
+        DestroyTask(FindTaskIdByFunc(Task_FldEffUseVsSeeker));
+    }
+}
+
+static void sub_8086D94(struct Sprite * sprite);
+
+u8 FldEff_NpcFlyOut(void)
+{
+    u8 spriteId = CreateSprite(gFieldEffectObjectTemplatePointers[26], 0x78, 0, 1);
+    struct Sprite * sprite = &gSprites[spriteId];
+
+    sprite->oam.paletteNum = 0;
+    sprite->oam.priority = 1;
+    sprite->callback = sub_8086D94;
+    sprite->data[1] = gFieldEffectArguments[0];
+    PlaySE(SE_W019);
+    return spriteId;
+}
+
+static void sub_8086D94(struct Sprite * sprite)
+{
+    struct Sprite * npcSprite;
+
+    sprite->pos2.x = Cos(sprite->data[2], 0x8c);
+    sprite->pos2.y = Sin(sprite->data[2], 0x48);
+    sprite->data[2] = (sprite->data[2] + 4) & 0xff;
+    if (sprite->data[0])
+    {
+        npcSprite = &gSprites[sprite->data[1]];
+        npcSprite->coordOffsetEnabled = FALSE;
+        npcSprite->pos1.x = sprite->pos1.x + sprite->pos2.x;
+        npcSprite->pos1.y = sprite->pos1.y + sprite->pos2.y - 8;
+        npcSprite->pos2.x = 0;
+        npcSprite->pos2.y = 0;
+    }
+    if (sprite->data[2] >= 0x80)
+    {
+        FieldEffectStop(sprite, FLDEFF_NPCFLY_OUT);
+    }
+}
+
+static void Task_UseFly(u8 taskId);
+static void UseFlyEffect_1(struct Task * task);
+static void UseFlyEffect_2(struct Task * task);
+static void UseFlyEffect_3(struct Task * task);
+static void UseFlyEffect_4(struct Task * task);
+static void UseFlyEffect_5(struct Task * task);
+static void UseFlyEffect_6(struct Task * task);
+static void UseFlyEffect_7(struct Task * task);
+static void UseFlyEffect_8(struct Task * task);
+static void UseFlyEffect_9(struct Task * task);
+static u8 sub_8087168(void);
+static bool8 sub_80871AC(u8 flyBlobSpriteId);
+static void sub_80871C8(u8 flyBlobSpriteId);
+static void sub_8087204(u8 flyBlobSpriteId, u8 playerSpriteId);
+static void sub_8087220(struct Sprite * sprite);
+static void sub_80872F0(struct Sprite * sprite);
+static void sub_80877FC(struct Sprite * sprite, u8 affineAnimId);
+static void sub_8087828(struct Sprite * sprite);
+
+static void (*const sUseFlyEffectFuncs[])(struct Task * ) = {
+    UseFlyEffect_1,
+    UseFlyEffect_2,
+    UseFlyEffect_3,
+    UseFlyEffect_4,
+    UseFlyEffect_5,
+    UseFlyEffect_6,
+    UseFlyEffect_7,
+    UseFlyEffect_8,
+    UseFlyEffect_9
+};
+
+u8 FldEff_UseFly(void)
+{
+    u8 taskId = CreateTask(Task_UseFly, 0xfe);
+    gTasks[taskId].data[1] = gFieldEffectArguments[0];
+    return 0;
+}
+
+static void Task_UseFly(u8 taskId)
+{
+    sUseFlyEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void UseFlyEffect_1(struct Task * task)
+{
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        task->data[15] = gPlayerAvatar.flags;
+        gPlayerAvatar.preventStep = TRUE;
+        SetPlayerAvatarStateMask(1);
+        sub_805CB70();
+        ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION);
+        task->data[0]++;
+    }
+}
+
+static void UseFlyEffect_2(struct Task * task)
+{
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        task->data[0]++;
+        gFieldEffectArguments[0] = task->data[1];
+        FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
+    }
+}
+
+static void UseFlyEffect_3(struct Task * task)
+{
+    if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON))
+    {
+        struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        if (task->data[15] & 0x08)
+        {
+            sub_80DC44C(objectEvent->fieldEffectSpriteId, 2);
+            sub_80DC478(objectEvent->fieldEffectSpriteId, 0);
+        }
+        task->data[1] = sub_8087168();
+        task->data[0]++;
+    }
+}
+
+static void UseFlyEffect_4(struct Task * task)
+{
+    if (sub_80871AC(task->data[1]))
+    {
+        task->data[0]++;
+        task->data[2] = 16;
+        SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT);
+        ObjectEventSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], MOVEMENT_ACTION_FACE_LEFT);
+    }
+}
+
+static void UseFlyEffect_5(struct Task * task)
+{
+    struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if ((task->data[2] == 0 || (--task->data[2]) == 0) && ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        task->data[0]++;
+        PlaySE(SE_W019);
+        sub_80871C8(task->data[1]);
+    }
+}
+
+static void UseFlyEffect_6(struct Task * task)
+{
+    if ((++task->data[2]) >= 8)
+    {
+        struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2));
+        StartSpriteAnim(&gSprites[objectEvent->spriteId], 0x16);
+        objectEvent->inanimate = TRUE;
+        ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_JUMP_IN_PLACE_LEFT);
+        task->data[0]++;
+        task->data[2] = 0;
+    }
+}
+
+static void UseFlyEffect_7(struct Task * task)
+{
+    if ((++task->data[2]) >= 10)
+    {
+        struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        ObjectEventClearHeldMovementIfActive(objectEvent);
+        objectEvent->inanimate = FALSE;
+        objectEvent->hasShadow = FALSE;
+        sub_8087204(task->data[1], objectEvent->spriteId);
+        StartSpriteAnim(&gSprites[task->data[1]], gSaveBlock2Ptr->playerGender * 2 + 1);
+        sub_80877FC(&gSprites[task->data[1]], 0);
+        gSprites[task->data[1]].callback = sub_8087828;
+        CameraObjectReset2();
+        task->data[0]++;
+    }
+}
+
+static void UseFlyEffect_8(struct Task * task)
+{
+    if (sub_80871AC(task->data[1]))
+    {
+        WarpFadeOutScreen();
+        task->data[0]++;
+    }
+}
+
+static void UseFlyEffect_9(struct Task * task)
+{
+    if (!gPaletteFade.active)
+    {
+        FieldEffectActiveListRemove(FLDEFF_USE_FLY);
+        DestroyTask(FindTaskIdByFunc(Task_UseFly));
+    }
+}
+
+static u8 sub_8087168(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+    spriteId = CreateSprite(gFieldEffectObjectTemplatePointers[26], 0xff, 0xb4, 0x1);
+    sprite = &gSprites[spriteId];
+    sprite->oam.paletteNum = 0;
+    sprite->oam.priority = 1;
+    sprite->callback = sub_8087220;
+    return spriteId;
+}
+
+static u8 sub_80871AC(u8 spriteId)
+{
+    return gSprites[spriteId].data[7];
+}
+
+static void sub_80871C8(u8 spriteId)
+{
+    struct Sprite * sprite;
+    sprite = &gSprites[spriteId];
+    sprite->callback = sub_80872F0;
+    sprite->pos1.x = 0x78;
+    sprite->pos1.y = 0x00;
+    sprite->pos2.x = 0;
+    sprite->pos2.y = 0;
+    memset(&sprite->data[0], 0, 8 * sizeof(u16) /* zero all data cells */);
+    sprite->data[6] = 0x40;
+}
+
+static void sub_8087204(u8 a0, u8 a1)
+{
+    gSprites[a0].data[6] = a1;
+}
+
+static const union AffineAnimCmd sUnknown_83CC19C[] = {
+    AFFINEANIMCMD_FRAME( 8,  8, 226,  0),
+    AFFINEANIMCMD_FRAME(28, 28,   0, 30),
+    AFFINEANIMCMD_END
+};
+
+static const union AffineAnimCmd sUnknown_83CC1B4[] = {
+    AFFINEANIMCMD_FRAME(256, 256, 64,  0),
+    AFFINEANIMCMD_FRAME(-10, -10,  0, 22),
+    AFFINEANIMCMD_END
+};
+
+static const union AffineAnimCmd *const sUnknown_83CC1CC[] = {
+    sUnknown_83CC19C,
+    sUnknown_83CC1B4
+};
+
+static void sub_8087220(struct Sprite * sprite)
+{
+    if (sprite->data[7] == 0)
+    {
+        if (sprite->data[0] == 0)
+        {
+            sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE;
+            sprite->affineAnims = sUnknown_83CC1CC;
+            InitSpriteAffineAnim(sprite);
+            StartSpriteAffineAnim(sprite, 0);
+            if (gSaveBlock2Ptr->playerGender == MALE)
+                sprite->pos1.x = 0x80;
+            else
+                sprite->pos1.x = 0x76;
+            sprite->pos1.y = -0x30;
+            sprite->data[0]++;
+            sprite->data[1] = 0x40;
+            sprite->data[2] = 0x100;
+        }
+        sprite->data[1] += (sprite->data[2] >> 8);
+        sprite->pos2.x = Cos(sprite->data[1], 0x78);
+        sprite->pos2.y = Sin(sprite->data[1], 0x78);
+        if (sprite->data[2] < 0x800)
+        {
+            sprite->data[2] += 0x60;
+        }
+        if (sprite->data[1] > 0x81)
+        {
+            sprite->data[7]++;
+            sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
+            FreeOamMatrix(sprite->oam.matrixNum);
+            CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF);
+        }
+    }
+}
+
+static void sub_80872F0(struct Sprite * sprite)
+{
+    sprite->pos2.x = Cos(sprite->data[2], 0x8c);
+    sprite->pos2.y = Sin(sprite->data[2], 0x48);
+    sprite->data[2] = (sprite->data[2] + 4) & 0xff;
+    if (sprite->data[6] != MAX_SPRITES)
+    {
+        struct Sprite * sprite1 = &gSprites[sprite->data[6]];
+        sprite1->coordOffsetEnabled = FALSE;
+        sprite1->pos1.x = sprite->pos1.x + sprite->pos2.x;
+        sprite1->pos1.y = sprite->pos1.y + sprite->pos2.y - 8;
+        sprite1->pos2.x = 0;
+        sprite1->pos2.y = 0;
+    }
+    if (sprite->data[2] >= 0x80)
+    {
+        sprite->data[7] = 1;
+    }
+}
+
+static void sub_8087364(struct Sprite * sprite)
+{
+    if (sprite->data[7] == 0)
+    {
+        if (sprite->data[0] == 0)
+        {
+            sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE;
+            sprite->affineAnims = sUnknown_83CC1CC;
+            InitSpriteAffineAnim(sprite);
+            StartSpriteAffineAnim(sprite, 1);
+            if (gSaveBlock2Ptr->playerGender == MALE)
+                sprite->pos1.x = 0x70;
+            else
+                sprite->pos1.x = 0x64;
+            sprite->pos1.y = -0x20;
+            sprite->data[0]++;
+            sprite->data[1] = 0xf0;
+            sprite->data[2] = 0x800;
+            sprite->data[4] = 0x80;
+        }
+        sprite->data[1] += sprite->data[2] >> 8;
+        sprite->data[3] += sprite->data[2] >> 8;
+        sprite->data[1] &= 0xff;
+        sprite->pos2.x = Cos(sprite->data[1], 0x20);
+        sprite->pos2.y = Sin(sprite->data[1], 0x78);
+        if (sprite->data[2] > 0x100)
+        {
+            sprite->data[2] -= sprite->data[4];
+        }
+        if (sprite->data[4] < 0x100)
+        {
+            sprite->data[4] += 24;
+        }
+        if (sprite->data[2] < 0x100)
+        {
+            sprite->data[2] = 0x100;
+        }
+        if (sprite->data[3] >= 60)
+        {
+            sprite->data[7]++;
+            sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
+            FreeOamMatrix(sprite->oam.matrixNum);
+            sprite->invisible = TRUE;
+        }
+    }
+}
+
+static void sub_8087458(u8 spriteId)
+{
+    sub_80871C8(spriteId);
+    gSprites[spriteId].callback = sub_8087364;
+}
+
+static void Task_FldEffFlyIn(u8 taskId);
+static void FlyInEffect_1(struct Task * task);
+static void FlyInEffect_2(struct Task * task);
+static void FlyInEffect_3(struct Task * task);
+static void FlyInEffect_4(struct Task * task);
+static void FlyInEffect_5(struct Task * task);
+static void FlyInEffect_6(struct Task * task);
+static void FlyInEffect_7(struct Task * task);
+static void sub_80878C0(struct Sprite * sprite);
+
+static void (*const sFlyInEffectFuncs[])(struct Task * task) = {
+    FlyInEffect_1,
+    FlyInEffect_2,
+    FlyInEffect_3,
+    FlyInEffect_4,
+    FlyInEffect_5,
+    FlyInEffect_6,
+    FlyInEffect_7
+};
+
+u32 FldEff_FlyIn(void)
+{
+    CreateTask(Task_FldEffFlyIn, 0xfe);
+    return 0;
+}
+
+static void Task_FldEffFlyIn(u8 taskId)
+{
+    sFlyInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]);
+}
+
+static void FlyInEffect_1(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent))
+    {
+        task->data[0]++;
+        task->data[2] = 33;
+        task->data[15] = gPlayerAvatar.flags;
+        gPlayerAvatar.preventStep = TRUE;
+        SetPlayerAvatarStateMask(0x01);
+        if (task->data[15] & 0x08)
+        {
+            sub_80DC44C(objectEvent->fieldEffectSpriteId, 0);
+        }
+        ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2));
+        CameraObjectReset2();
+        ObjectEventTurn(objectEvent, DIR_WEST);
+        StartSpriteAnim(&gSprites[objectEvent->spriteId], 0x16);
+        objectEvent->invisible = FALSE;
+        task->data[1] = sub_8087168();
+        sub_80871C8(task->data[1]);
+        sub_8087204(task->data[1], objectEvent->spriteId);
+        StartSpriteAnim(&gSprites[task->data[1]], gSaveBlock2Ptr->playerGender * 2 + 2);
+        sub_80877FC(&gSprites[task->data[1]], 1);
+        gSprites[task->data[1]].callback = sub_8087828;
+    }
+}
+
+static void FlyInEffect_2(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    struct Sprite * sprite;
+    sub_80878C0(&gSprites[task->data[1]]);
+    if (task->data[2] == 0 || (--task->data[2]) == 0)
+    {
+        objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        sprite = &gSprites[objectEvent->spriteId];
+        sub_8087204(task->data[1], 0x40);
+        sprite->pos1.x += sprite->pos2.x;
+        sprite->pos1.y += sprite->pos2.y;
+        sprite->pos2.x = 0;
+        sprite->pos2.y = 0;
+        task->data[0]++;
+        task->data[2] = 0;
+    }
+}
+
+static void FlyInEffect_3(struct Task * task)
+{
+    s16 gUnknown_83CC1F0[18] = {
+        -2,
+        -4,
+        -5,
+        -6,
+        -7,
+        -8,
+        -8,
+        -8,
+        -7,
+        -7,
+        -6,
+        -5,
+        -3,
+        -2,
+        0,
+        2,
+        4,
+        8
+    };
+    struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId];
+    sprite->pos2.y = gUnknown_83CC1F0[task->data[2]];
+    if ((++task->data[2]) >= 18)
+    {
+        task->data[0]++;
+    }
+}
+
+static void FlyInEffect_4(struct Task * task)
+{
+    struct ObjectEvent * objectEvent;
+    struct Sprite * sprite;
+    if (sub_80871AC(task->data[1]))
+    {
+        objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        sprite = &gSprites[objectEvent->spriteId];
+        objectEvent->inanimate = FALSE;
+        MoveObjectEventToMapCoords(objectEvent, objectEvent->currentCoords.x, objectEvent->currentCoords.y);
+        sprite->pos2.x = 0;
+        sprite->pos2.y = 0;
+        sprite->coordOffsetEnabled = TRUE;
+        sub_805CB70();
+        ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION);
+        task->data[0]++;
+    }
+}
+
+static void FlyInEffect_5(struct Task * task)
+{
+    if (ObjectEventClearHeldMovementIfFinished(&gObjectEvents[gPlayerAvatar.objectEventId]))
+    {
+        task->data[0]++;
+        sub_8087458(task->data[1]);
+    }
+}
+
+static void FlyInEffect_6(struct Task * task)
+{
+    if (sub_80871AC(task->data[1]))
+    {
+        DestroySprite(&gSprites[task->data[1]]);
+        task->data[0]++;
+        task->data[1] = 0x10;
+    }
+}
+
+static void FlyInEffect_7(struct Task * task)
+{
+    u8 state;
+    struct ObjectEvent * objectEvent;
+    if ((--task->data[1]) == 0)
+    {
+        objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
+        state = 0;
+        if (task->data[15] & 0x08)
+        {
+            state = 2;
+            sub_80DC44C(objectEvent->fieldEffectSpriteId, 1);
+        }
+        ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(state));
+        ObjectEventTurn(objectEvent, DIR_SOUTH);
+        gPlayerAvatar.flags = task->data[15];
+        gPlayerAvatar.preventStep = FALSE;
+        FieldEffectActiveListRemove(FLDEFF_FLY_IN);
+        DestroyTask(FindTaskIdByFunc(Task_FldEffFlyIn));
+    }
+}
+
+static const union AffineAnimCmd sUnknown_83CC214[] = {
+    AFFINEANIMCMD_FRAME(24, 24, 0, 1),
+    AFFINEANIMCMD_JUMP(0)
+};
+
+static const union AffineAnimCmd sUnknown_83CC224[] = {
+    AFFINEANIMCMD_FRAME(512, 512, 0, 1),
+    AFFINEANIMCMD_FRAME(-16, -16, 0, 1),
+    AFFINEANIMCMD_JUMP(1)
+};
+
+static const union AffineAnimCmd *const sUnknown_83CC23C[] = {
+    sUnknown_83CC214,
+    sUnknown_83CC224
+};
+
+static void sub_80877FC(struct Sprite * sprite, u8 affineAnimId)
+{
+    sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE;
+    sprite->affineAnims = sUnknown_83CC23C;
+    InitSpriteAffineAnim(sprite);
+    StartSpriteAffineAnim(sprite, affineAnimId);
+}
+
+static void sub_8087828(struct Sprite * sprite)
+{
+    struct Sprite * sprite2;
+    sprite->pos2.x = Cos(sprite->data[2], 0xB4);
+    sprite->pos2.y = Sin(sprite->data[2], 0x48);
+    sprite->data[2] += 2;
+    sprite->data[2] &= 0xFF;
+    if (sprite->data[6] != MAX_SPRITES)
+    {
+        sprite2 = &gSprites[sprite->data[6]];
+        sprite2->coordOffsetEnabled = FALSE;
+        sprite2->pos1.x = sprite->pos1.x + sprite->pos2.x;
+        sprite2->pos1.y = sprite->pos1.y + sprite->pos2.y - 8;
+        sprite2->pos2.x = 0;
+        sprite2->pos2.y = 0;
+    }
+    if (sprite->data[2] >= 0x80)
+    {
+        sprite->data[7] = 1;
+        sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
+        FreeOamMatrix(sprite->oam.matrixNum);
+        CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF);
+    }
+}
+
+static void sub_80878C0(struct Sprite * sprite)
+{
+    if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF)
+    {
+        if (gOamMatrices[sprite->oam.matrixNum].a == 0x100 || gOamMatrices[sprite->oam.matrixNum].d == 0x100)
+        {
+            sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
+            FreeOamMatrix(sprite->oam.matrixNum);
+            CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF);
+            StartSpriteAnim(sprite, 0);
+            sprite->callback = sub_80872F0;
+        }
+    }
+}
+
+static void Task_MoveDeoxysRock_Step(u8 taskId);
+
+u32 FldEff_MoveDeoxysRock(void)
+{
+    u8 taskId;
+    u8 objectEventIdBuffer;
+    s32 x;
+    s32 y;
+    struct ObjectEvent * objectEvent;
+    if (!TryGetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &objectEventIdBuffer))
+    {
+        objectEvent = &gObjectEvents[objectEventIdBuffer];
+        x = objectEvent->currentCoords.x - 7;
+        y = objectEvent->currentCoords.y - 7;
+        x = (gFieldEffectArguments[3] - x) * 16;
+        y = (gFieldEffectArguments[4] - y) * 16;
+        ShiftObjectEventCoords(objectEvent, gFieldEffectArguments[3] + 7, gFieldEffectArguments[4] + 7);
+        taskId = CreateTask(Task_MoveDeoxysRock_Step, 0x50);
+        gTasks[taskId].data[1] = objectEvent->spriteId;
+        gTasks[taskId].data[2] = gSprites[objectEvent->spriteId].pos1.x + x;
+        gTasks[taskId].data[3] = gSprites[objectEvent->spriteId].pos1.y + y;
+        gTasks[taskId].data[8] = gFieldEffectArguments[5];
+        gTasks[taskId].data[9] = objectEventIdBuffer;
+    }
+    return FALSE;
+}
+
+static void Task_MoveDeoxysRock_Step(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    struct Sprite * sprite = &gSprites[data[1]];
+    struct ObjectEvent * objectEvent;
+    switch (data[0])
+    {
+    case 0:
+        data[4] = sprite->pos1.x << 4;
+        data[5] = sprite->pos1.y << 4;
+        data[6] = ((data[2] << 4) - data[4]) / data[8];
+        data[7] = ((data[3] << 4) - data[5]) / data[8];
+        data[0]++;
+        // fallthrough
+    case 1:
+        if (data[8] != 0)
+        {
+            data[8]--;
+            data[4] += data[6];
+            data[5] += data[7];
+            sprite->pos1.x = data[4] >> 4;
+            sprite->pos1.y = data[5] >> 4;
+        }
+        else
+        {
+            objectEvent = &gObjectEvents[data[9]];
+            sprite->pos1.x = data[2];
+            sprite->pos1.y = data[3];
+            ShiftStillObjectEventCoords(objectEvent);
+            objectEvent->triggerGroundEffectsOnStop = TRUE;
+            FieldEffectActiveListRemove(FLDEFF_MOVE_DEOXYS_ROCK);
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+static void Task_FldEffUnk44(u8 taskId);
+static void Unk44Effect_0(s16 *data, u8 taskId);
+static void Unk44Effect_1(s16 *data, u8 taskId);
+static void Unk44Effect_2(s16 *data, u8 taskId);
+static void sub_8087CFC(struct Sprite * sprite);
+static void SpriteCB_FldEffUnk44(struct Sprite * sprite);
+
+static void (*const sUnk44EffectFuncs[])(s16 *data, u8 taskId) = {
+    Unk44Effect_0,
+    Unk44Effect_1,
+    Unk44Effect_2
+};
+
+static const struct SpriteFrameImage sImages_FldEffUnk44[] = {
+    {sFldEffUnk44_Tiles + 0x00, 0x20},
+    {sFldEffUnk44_Tiles + 0x10, 0x20},
+    {sFldEffUnk44_Tiles + 0x20, 0x20},
+    {sFldEffUnk44_Tiles + 0x30, 0x20}
+};
+
+static const union AnimCmd sAnimCmd_FldEffUnk44_0[] = {
+    ANIMCMD_FRAME(0, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_FldEffUnk44_1[] = {
+    ANIMCMD_FRAME(1, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_FldEffUnk44_2[] = {
+    ANIMCMD_FRAME(2, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnimCmd_FldEffUnk44_3[] = {
+    ANIMCMD_FRAME(3, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sAnimCmdTable_FldEffUnk44[] = {
+    sAnimCmd_FldEffUnk44_0,
+    sAnimCmd_FldEffUnk44_1,
+    sAnimCmd_FldEffUnk44_2,
+    sAnimCmd_FldEffUnk44_3
+};
+
+static const struct SpriteTemplate sUnknown_83CC2A0 = {
+    .tileTag = SPRITE_INVALID_TAG,
+    .paletteTag = 4371,
+    .oam = &sOamData_8x8,
+    .anims = sAnimCmdTable_FldEffUnk44,
+    .images = sImages_FldEffUnk44,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_FldEffUnk44
+};
+
+u32 FldEff_Unk44(void)
+{
+    u8 taskId;
+    u8 objectEventIdBuffer;
+    if (!TryGetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &objectEventIdBuffer))
+    {
+        taskId = CreateTask(Task_FldEffUnk44, 0x50);
+        gTasks[taskId].data[2] = objectEventIdBuffer;
+        gTasks[taskId].data[6] = gFieldEffectArguments[0];
+        gTasks[taskId].data[7] = gFieldEffectArguments[1];
+        gTasks[taskId].data[8] = gFieldEffectArguments[2];
+    }
+    else
+    {
+        FieldEffectActiveListRemove(FLDEFF_UNK_44);
+    }
+    return FALSE;
+}
+
+static void sub_8087B14(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[7] != 0)
+    {
+        if (++data[6] > 20)
+        {
+            data[6] = 0;
+            if (data[5] != 0)
+                data[5]--;
+        }
+    }
+    else
+    {
+        data[5] = 4;
+    }
+
+    if (++data[0] > 1)
+    {
+        data[0] = 0;
+        if (++data[1] & 1)
+        {
+            SetCameraPanning(0, -data[5]);
+        }
+        else
+        {
+            SetCameraPanning(0, data[5]);
+        }
+    }
+    UpdateCameraPanning();
+    if (data[5] == 0)
+        DestroyTask(taskId);
+}
+
+static void sub_8087BA8(u8 taskId)
+{
+    gTasks[taskId].data[7] = 1;
+}
+
+static void Task_FldEffUnk44(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    InstallCameraPanAheadCallback();
+    SetCameraPanningCallback(NULL);
+    sUnk44EffectFuncs[data[1]](data, taskId);
+}
+
+static void Unk44Effect_0(s16 *data, u8 taskId)
+{
+    u8 newTaskId = CreateTask(sub_8087B14, 90);
+    PlaySE(SE_T_KAMI2);
+    data[5] = newTaskId;
+    data[1]++;
+}
+
+static void Unk44Effect_1(s16 *data, u8 taskId)
+{
+    if (++data[3] > 0x78)
+    {
+        struct Sprite * sprite = &gSprites[gObjectEvents[data[2]].spriteId];
+        gObjectEvents[data[2]].invisible = TRUE;
+        BlendPalettes(0x0000FFFF, 0x10, RGB_WHITE);
+        BeginNormalPaletteFade(0x0000FFFF, 0, 0x10, 0, RGB_WHITE);
+        sub_8087CFC(sprite);
+        PlaySE(SE_T_KAMI);
+        sub_8087BA8(data[5]);
+        data[3] = 0;
+        data[1]++;
+    }
+}
+
+static void Unk44Effect_2(s16 *data, u8 taskId)
+{
+    if (!gPaletteFade.active && !FuncIsActiveTask(sub_8087B14))
+    {
+        InstallCameraPanAheadCallback();
+        RemoveObjectEventByLocalIdAndMap(data[6], data[7], data[8]);
+        FieldEffectActiveListRemove(FLDEFF_UNK_44);
+        DestroyTask(taskId);
+    }
+}
+
+static void sub_8087CFC(struct Sprite* sprite)
+{
+    int i;
+    int xPos = (s16)gTotalCameraPixelOffsetX + sprite->pos1.x + sprite->pos2.x;
+    int yPos = (s16)gTotalCameraPixelOffsetY + sprite->pos1.y + sprite->pos2.y - 4;
+
+    for (i = 0; i < 4; i++)
+    {
+        u8 spriteId = CreateSprite(&sUnknown_83CC2A0, xPos, yPos, 0);
+        if (spriteId != MAX_SPRITES)
+        {
+            StartSpriteAnim(&gSprites[spriteId], i);
+            gSprites[spriteId].data[0] = i;
+            gSprites[spriteId].oam.paletteNum = sprite->oam.paletteNum;
+        }
+    }
+}
+
+static void SpriteCB_FldEffUnk44(struct Sprite* sprite)
+{
+    switch (sprite->data[0])
+    {
+    case 0:
+        sprite->pos1.x -= 16;
+        sprite->pos1.y -= 12;
+        break;
+    case 1:
+        sprite->pos1.x += 16;
+        sprite->pos1.y -= 12;
+        break;
+    case 2:
+        sprite->pos1.x -= 16;
+        sprite->pos1.y += 12;
+        break;
+    case 3:
+        sprite->pos1.x += 16;
+        sprite->pos1.y += 12;
+        break;
+    }
+    if (sprite->pos1.x < -4 || sprite->pos1.x > 0xF4 || sprite->pos1.y < -4 || sprite->pos1.y > 0xA4)
+        DestroySprite(sprite);
+}
+
+static void Task_FldEffUnk45(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        FieldEffectActiveListRemove(FLDEFF_UNK_45);
+        DestroyTask(taskId);
+    }
+}
+
+// Bug: Return value should be u32, not void
+void FldEff_Unk45(void)
+{
+    BlendPalettes(0xFFFFFFFF, 0x10, RGB_WHITE);
+    BeginNormalPaletteFade(0xFFFFFFFF, -1, 0x0F, 0x00, RGB_WHITE);
+    CreateTask(Task_FldEffUnk45, 90);
+}
diff --git a/src/field_effect_helpers.c b/src/field_effect_helpers.c
new file mode 100644
index 000000000..06d48fce0
--- /dev/null
+++ b/src/field_effect_helpers.c
@@ -0,0 +1,1411 @@
+#include "global.h"
+#include "event_object_movement.h"
+#include "field_camera.h"
+#include "field_effect.h"
+#include "field_weather.h"
+#include "fieldmap.h"
+#include "metatile_behavior.h"
+#include "sound.h"
+#include "sprite.h"
+#include "constants/field_effects.h"
+#include "constants/songs.h"
+
+#define OBJ_EVENT_PAL_TAG_NONE 0x11FF // duplicate of define in event_object_movement.c
+
+static void UpdateObjectReflectionSprite(struct Sprite * sprite);
+static void LoadObjectReflectionPalette(struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static void LoadObjectHighBridgeReflectionPalette(struct ObjectEvent * objectEvent, u8 paletteNum);
+static void LoadObjectRegularReflectionPalette(struct ObjectEvent * objectEvent, u8 paletteNum);
+static void sub_80DCD48(struct Sprite * sprite, u8 z, u8 offset);
+static void FadeFootprintsTireTracks_Step0(struct Sprite * sprite);
+static void FadeFootprintsTireTracks_Step1(struct Sprite * sprite);
+static void UpdateFeetInFlowingWaterFieldEffect(struct Sprite * sprite);
+static void UpdateAshFieldEffect_Step0(struct Sprite * sprite);
+static void UpdateAshFieldEffect_Step1(struct Sprite * sprite);
+static void UpdateAshFieldEffect_Step2(struct Sprite * sprite);
+static void SynchroniseSurfAnim(struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static void sub_80DC588(struct ObjectEvent * objectEvent, struct Sprite * sprite);
+static void CreateBobbingEffect(struct ObjectEvent * objectEvent, struct Sprite * linkedSprite, struct Sprite * sprite);
+static void sub_80DC700(struct Sprite * sprite);
+static u32 ShowDisguiseFieldEffect(u8 fldEff, u8 templateIdx, u8 paletteNum);
+
+void SetUpReflection(struct ObjectEvent * objectEvent, struct Sprite * sprite, bool8 stillReflection)
+{
+    struct Sprite * reflectionSprite;
+
+    reflectionSprite = &gSprites[CreateCopySpriteAt(sprite, sprite->pos1.x, sprite->pos1.y, 0x98)];
+    reflectionSprite->callback = UpdateObjectReflectionSprite;
+    reflectionSprite->oam.priority = 3;
+    reflectionSprite->oam.paletteNum = gReflectionEffectPaletteMap[reflectionSprite->oam.paletteNum];
+    reflectionSprite->usingSheet = TRUE;
+    reflectionSprite->anims = gDummySpriteAnimTable;
+    StartSpriteAnim(reflectionSprite, 0);
+    reflectionSprite->affineAnims = gDummySpriteAffineAnimTable;
+    reflectionSprite->affineAnimBeginning = TRUE;
+    reflectionSprite->subspriteMode = SUBSPRITES_OFF;
+    reflectionSprite->data[0] = sprite->data[0];
+    reflectionSprite->data[1] = objectEvent->localId;
+    reflectionSprite->data[7] = stillReflection;
+    LoadObjectReflectionPalette(objectEvent, reflectionSprite);
+
+    if (!stillReflection)
+        reflectionSprite->oam.affineMode = ST_OAM_AFFINE_NORMAL;
+}
+
+static s16 GetReflectionVerticalOffset(struct ObjectEvent * objectEvent)
+{
+    return GetObjectEventGraphicsInfo(objectEvent->graphicsId)->height - 2;
+}
+
+static void LoadObjectReflectionPalette(struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    u8 bridgeType;
+    u16 bridgeReflectionVerticalOffsets[] = { 12, 28, 44 };
+    sprite->data[2] = 0;
+    if (!GetObjectEventGraphicsInfo(objectEvent->graphicsId)->disableReflectionPaletteLoad && ((bridgeType = MetatileBehavior_GetBridgeType(objectEvent->previousMetatileBehavior)) || (bridgeType = MetatileBehavior_GetBridgeType(objectEvent->currentMetatileBehavior))))
+    {
+        sprite->data[2] = bridgeReflectionVerticalOffsets[bridgeType - 1];
+        LoadObjectHighBridgeReflectionPalette(objectEvent, sprite->oam.paletteNum);
+    }
+    else
+    {
+        LoadObjectRegularReflectionPalette(objectEvent, sprite->oam.paletteNum);
+    }
+}
+
+static void LoadObjectRegularReflectionPalette(struct ObjectEvent * objectEvent, u8 paletteIndex)
+{
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+
+    graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+    if (graphicsInfo->paletteTag2 != OBJ_EVENT_PAL_TAG_NONE)
+    {
+        if (graphicsInfo->paletteSlot == 0)
+        {
+            LoadPlayerObjectReflectionPalette(graphicsInfo->paletteTag1, paletteIndex);
+        }
+        else if (graphicsInfo->paletteSlot == 10)
+        {
+            LoadSpecialObjectReflectionPalette(graphicsInfo->paletteTag1, paletteIndex);
+        }
+        else
+        {
+            PatchObjectPalette(GetObjectPaletteTag(paletteIndex), paletteIndex);
+        }
+        UpdateSpritePaletteWithWeather(paletteIndex);
+    }
+}
+
+// When walking on a bridge high above water (Route 120), the reflection is a solid dark blue color.
+// This is so the sprite blends in with the dark water metatile underneath the bridge.
+static void LoadObjectHighBridgeReflectionPalette(struct ObjectEvent * objectEvent, u8 paletteNum)
+{
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+
+    graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+    if (graphicsInfo->paletteTag2 != OBJ_EVENT_PAL_TAG_NONE)
+    {
+        PatchObjectPalette(graphicsInfo->paletteTag2, paletteNum);
+        UpdateSpritePaletteWithWeather(paletteNum);
+    }
+}
+
+static void UpdateObjectReflectionSprite(struct Sprite * reflectionSprite)
+{
+    struct ObjectEvent * objectEvent;
+    struct Sprite * mainSprite;
+
+    objectEvent = &gObjectEvents[reflectionSprite->data[0]];
+    mainSprite = &gSprites[objectEvent->spriteId];
+    if (!objectEvent->active || !objectEvent->hasReflection || objectEvent->localId != reflectionSprite->data[1])
+    {
+        reflectionSprite->inUse = FALSE;
+    }
+    else
+    {
+        reflectionSprite->oam.paletteNum = gReflectionEffectPaletteMap[mainSprite->oam.paletteNum];
+        reflectionSprite->oam.shape = mainSprite->oam.shape;
+        reflectionSprite->oam.size = mainSprite->oam.size;
+        reflectionSprite->oam.matrixNum = mainSprite->oam.matrixNum | ST_OAM_VFLIP;
+        reflectionSprite->oam.tileNum = mainSprite->oam.tileNum;
+        reflectionSprite->subspriteTables = mainSprite->subspriteTables;
+        reflectionSprite->subspriteTableNum = mainSprite->subspriteTableNum;
+        reflectionSprite->invisible = mainSprite->invisible;
+        reflectionSprite->pos1.x = mainSprite->pos1.x;
+        // reflectionSprite->data[2] holds an additional vertical offset, used by the high bridges on Route 120
+        reflectionSprite->pos1.y = mainSprite->pos1.y + GetReflectionVerticalOffset(objectEvent) + reflectionSprite->data[2];
+        reflectionSprite->centerToCornerVecX = mainSprite->centerToCornerVecX;
+        reflectionSprite->centerToCornerVecY = mainSprite->centerToCornerVecY;
+        reflectionSprite->pos2.x = mainSprite->pos2.x;
+        reflectionSprite->pos2.y = -mainSprite->pos2.y;
+        reflectionSprite->coordOffsetEnabled = mainSprite->coordOffsetEnabled;
+
+/*
+        if (objectEvent->hideReflection == TRUE)
+            reflectionSprite->invisible = TRUE;
+*/
+
+        // Check if the reflection is not still.
+        if (reflectionSprite->data[7] == FALSE)
+        {
+            // Sets the reflection sprite's rot/scale matrix to the appropriate
+            // matrix based on whether or not the main sprite is horizontally flipped.
+            // If the sprite is facing to the east, then it is flipped, and its matrixNum is 8.
+            reflectionSprite->oam.matrixNum = 0;
+            if (mainSprite->oam.matrixNum & ST_OAM_HFLIP)
+                reflectionSprite->oam.matrixNum = 1;
+        }
+    }
+}
+
+extern const struct SpriteTemplate * const gFieldEffectObjectTemplatePointers[];
+
+u8 CreateWarpArrowSprite(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[8], 0, 0, 0x52);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->oam.priority = 1;
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->invisible = TRUE;
+    }
+    return spriteId;
+}
+
+void SetSpriteInvisible(u8 spriteId)
+{
+    gSprites[spriteId].invisible = TRUE;
+}
+
+void ShowWarpArrowSprite(u8 spriteId, u8 direction, s16 x, s16 y)
+{
+    s16 x2;
+    s16 y2;
+    struct Sprite * sprite;
+
+    sprite = &gSprites[spriteId];
+    if (sprite->invisible || sprite->data[0] != x || sprite->data[1] != y)
+    {
+        SetSpritePosToMapCoords(x, y, &x2, &y2);
+        sprite = &gSprites[spriteId];
+        sprite->pos1.x = x2 + 8;
+        sprite->pos1.y = y2 + 8;
+        sprite->invisible = FALSE;
+        sprite->data[0] = x;
+        sprite->data[1] = y;
+        StartSpriteAnim(sprite, direction - 1);
+    }
+}
+
+const u8 gShadowEffectTemplateIds[] = {
+    0,
+    1,
+    2,
+    3
+};
+
+const u16 gShadowVerticalOffsets[] = {
+    4,
+    4,
+    4,
+    16
+};
+
+u32 FldEff_Shadow(void)
+{
+    u8 objectEventId;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+    u8 spriteId;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    graphicsInfo = GetObjectEventGraphicsInfo(gObjectEvents[objectEventId].graphicsId);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[gShadowEffectTemplateIds[graphicsInfo->shadowSize]], 0, 0, 0x94);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].coordOffsetEnabled = TRUE;
+        gSprites[spriteId].data[0] = gFieldEffectArguments[0];
+        gSprites[spriteId].data[1] = gFieldEffectArguments[1];
+        gSprites[spriteId].data[2] = gFieldEffectArguments[2];
+        gSprites[spriteId].data[3] = (graphicsInfo->height >> 1) - gShadowVerticalOffsets[graphicsInfo->shadowSize];
+    }
+    return 0;
+}
+
+void UpdateShadowFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    struct Sprite * linkedSprite;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId))
+    {
+        FieldEffectStop(sprite, FLDEFF_SHADOW);
+    }
+    else
+    {
+        objectEvent = &gObjectEvents[objectEventId];
+        linkedSprite = &gSprites[objectEvent->spriteId];
+        sprite->oam.priority = linkedSprite->oam.priority;
+        sprite->pos1.x = linkedSprite->pos1.x;
+        sprite->pos1.y = linkedSprite->pos1.y + sprite->data[3];
+        if (!objectEvent->active || !objectEvent->hasShadow
+         || MetatileBehavior_IsPokeGrass(objectEvent->currentMetatileBehavior)
+         || MetatileBehavior_IsSurfable(objectEvent->currentMetatileBehavior)
+         || MetatileBehavior_IsSurfable(objectEvent->previousMetatileBehavior)
+         || MetatileBehavior_IsReflective(objectEvent->currentMetatileBehavior)
+         || MetatileBehavior_IsReflective(objectEvent->previousMetatileBehavior))
+        {
+            FieldEffectStop(sprite, FLDEFF_SHADOW);
+        }
+    }
+}
+
+u32 FldEff_TallGrass(void)
+{
+    s16 x;
+    s16 y;
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    x = gFieldEffectArguments[0];
+    y = gFieldEffectArguments[1];
+    sub_8063BC4(&x, &y, 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[4], x, y, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = gFieldEffectArguments[0];
+        sprite->data[2] = gFieldEffectArguments[1];
+        sprite->data[3] = gFieldEffectArguments[4];
+        sprite->data[4] = gFieldEffectArguments[5];
+        sprite->data[5] = gFieldEffectArguments[6];
+        if (gFieldEffectArguments[7])
+        {
+            SeekSpriteAnim(sprite, 4);
+        }
+    }
+    return 0;
+}
+
+void UpdateTallGrassFieldEffect(struct Sprite * sprite)
+{
+    u8 mapNum;
+    u8 mapGroup;
+    u8 metatileBehavior;
+    u8 localId;
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+
+    mapNum = sprite->data[5] >> 8;
+    mapGroup = sprite->data[5];
+    if (gCamera.active && (gSaveBlock1Ptr->location.mapNum != mapNum || gSaveBlock1Ptr->location.mapGroup != mapGroup))
+    {
+        sprite->data[1] -= gCamera.x;
+        sprite->data[2] -= gCamera.y;
+        sprite->data[5] = ((u8)gSaveBlock1Ptr->location.mapNum << 8) | (u8)gSaveBlock1Ptr->location.mapGroup;
+    }
+    localId = sprite->data[3] >> 8;
+    mapNum = sprite->data[3];
+    mapGroup = sprite->data[4];
+    metatileBehavior = MapGridGetMetatileBehaviorAt(sprite->data[1], sprite->data[2]);
+    if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId) || !MetatileBehavior_IsTallGrass_2(metatileBehavior) || (sprite->data[7] && sprite->animEnded))
+    {
+        FieldEffectStop(sprite, FLDEFF_TALL_GRASS);
+    }
+    else
+    {
+        objectEvent = &gObjectEvents[objectEventId];
+        if ((objectEvent->currentCoords.x != sprite->data[1] || objectEvent->currentCoords.y != sprite->data[2]) && (objectEvent->previousCoords.x != sprite->data[1] || objectEvent->previousCoords.y != sprite->data[2]))
+            sprite->data[7] = TRUE;
+
+        // This variable is misused.
+        metatileBehavior = 0;
+        if (sprite->animCmdIndex == 0)
+            metatileBehavior = 4;
+
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+        sub_80DCD48(sprite, sprite->data[0], metatileBehavior);
+    }
+}
+
+u32 FldEff_JumpTallGrass(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[10], gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = 12;
+    }
+    return 0;
+}
+
+u8 FindTallGrassFieldEffectSpriteId(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y)
+{
+    struct Sprite * sprite;
+    u8 i;
+
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        if (gSprites[i].inUse)
+        {
+            sprite = &gSprites[i];
+            if (sprite->callback == UpdateTallGrassFieldEffect && (x == sprite->data[1] && y == sprite->data[2]) && (localId == (sprite->data[3] >> 8) && mapNum == (sprite->data[3] & 0xFF) && mapGroup == sprite->data[4]))
+                return i;
+        }
+    }
+
+    return MAX_SPRITES;
+}
+
+u32 FldEff_LongGrass(void)
+{
+    s16 x;
+    s16 y;
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    x = gFieldEffectArguments[0];
+    y = gFieldEffectArguments[1];
+    sub_8063BC4(&x, &y, 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[15], x, y, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = ZCoordToPriority(gFieldEffectArguments[2]);
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = gFieldEffectArguments[0];
+        sprite->data[2] = gFieldEffectArguments[1];
+        sprite->data[3] = gFieldEffectArguments[4];
+        sprite->data[4] = gFieldEffectArguments[5];
+        sprite->data[5] = gFieldEffectArguments[6];
+        if (gFieldEffectArguments[7])
+        {
+            SeekSpriteAnim(sprite, 6);
+        }
+    }
+    return 0;
+}
+
+void UpdateLongGrassFieldEffect(struct Sprite * sprite)
+{
+    u8 mapNum;
+    u8 mapGroup;
+    u8 metatileBehavior;
+    u8 localId;
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+
+    mapNum = sprite->data[5] >> 8;
+    mapGroup = sprite->data[5];
+    if (gCamera.active && (gSaveBlock1Ptr->location.mapNum != mapNum || gSaveBlock1Ptr->location.mapGroup != mapGroup))
+    {
+        sprite->data[1] -= gCamera.x;
+        sprite->data[2] -= gCamera.y;
+        sprite->data[5] = ((u8)gSaveBlock1Ptr->location.mapNum << 8) | (u8)gSaveBlock1Ptr->location.mapGroup;
+    }
+    localId = sprite->data[3] >> 8;
+    mapNum = sprite->data[3];
+    mapGroup = sprite->data[4];
+    metatileBehavior = MapGridGetMetatileBehaviorAt(sprite->data[1], sprite->data[2]);
+    if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId) || !MetatileBehavior_IsLongGrass(metatileBehavior) || (sprite->data[7] && sprite->animEnded))
+    {
+        FieldEffectStop(sprite, FLDEFF_LONG_GRASS);
+    }
+    else
+    {
+        objectEvent = &gObjectEvents[objectEventId];
+        if ((objectEvent->currentCoords.x != sprite->data[1] || objectEvent->currentCoords.y != sprite->data[2]) && (objectEvent->previousCoords.x != sprite->data[1] || objectEvent->previousCoords.y != sprite->data[2]))
+        {
+            sprite->data[7] = TRUE;
+        }
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+        sub_80DCD48(sprite, sprite->data[0], 0);
+    }
+}
+
+u32 FldEff_JumpLongGrass(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[16], gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = 18;
+    }
+    return 0;
+}
+
+u32 FldEff_ShortGrass(void)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    objectEvent = &gObjectEvents[objectEventId];
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[30], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &(gSprites[spriteId]);
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gSprites[objectEvent->spriteId].oam.priority;
+        sprite->data[0] = gFieldEffectArguments[0];
+        sprite->data[1] = gFieldEffectArguments[1];
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->data[3] = gSprites[objectEvent->spriteId].pos1.x;
+        sprite->data[4] = gSprites[objectEvent->spriteId].pos1.y;
+    }
+    return 0;
+}
+
+void UpdateShortGrassFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    s16 x;
+    s16 y;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+    struct Sprite * linkedSprite;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId) || !gObjectEvents[objectEventId].inShortGrass)
+    {
+        FieldEffectStop(sprite, FLDEFF_SHORT_GRASS);
+    }
+    else
+    {
+        graphicsInfo = GetObjectEventGraphicsInfo(gObjectEvents[objectEventId].graphicsId);
+        linkedSprite = &gSprites[gObjectEvents[objectEventId].spriteId];
+        y = linkedSprite->pos1.y;
+        x = linkedSprite->pos1.x;
+        if (x != sprite->data[3] || y != sprite->data[4])
+        {
+            sprite->data[3] = x;
+            sprite->data[4] = y;
+            if (sprite->animEnded)
+            {
+                StartSpriteAnim(sprite, 0);
+            }
+        }
+        sprite->pos1.x = x;
+        sprite->pos1.y = y;
+        sprite->pos2.y = (graphicsInfo->height >> 1) - 8;
+        sprite->subpriority = linkedSprite->subpriority - 1;
+        sprite->oam.priority = linkedSprite->oam.priority;
+        UpdateObjectEventSpriteVisibility(sprite, linkedSprite->invisible);
+    }
+}
+
+u32 FldEff_SandFootprints(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[11], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[7] = FLDEFF_SAND_FOOTPRINTS;
+        StartSpriteAnim(sprite, gFieldEffectArguments[4]);
+    }
+    return 0;
+}
+
+u32 FldEff_DeepSandFootprints(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[23], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[7] = FLDEFF_DEEP_SAND_FOOTPRINTS;
+        StartSpriteAnim(sprite, gFieldEffectArguments[4]);
+    }
+    return spriteId;
+}
+
+u32 FldEff_BikeTireTracks(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[27], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[7] = FLDEFF_BIKE_TIRE_TRACKS;
+        StartSpriteAnim(sprite, gFieldEffectArguments[4]);
+    }
+    return spriteId;
+}
+
+void (*const gFadeFootprintsTireTracksFuncs[])(struct Sprite * sprite) = {
+    FadeFootprintsTireTracks_Step0,
+    FadeFootprintsTireTracks_Step1
+};
+
+void UpdateFootprintsTireTracksFieldEffect(struct Sprite * sprite)
+{
+    gFadeFootprintsTireTracksFuncs[sprite->data[0]](sprite);
+}
+
+static void FadeFootprintsTireTracks_Step0(struct Sprite * sprite)
+{
+    // Wait 40 frames before the flickering starts.
+    if (++sprite->data[1] > 40)
+        sprite->data[0] = 1;
+
+    UpdateObjectEventSpriteVisibility(sprite, FALSE);
+}
+
+static void FadeFootprintsTireTracks_Step1(struct Sprite * sprite)
+{
+    sprite->invisible ^= 1;
+    sprite->data[1]++;
+    UpdateObjectEventSpriteVisibility(sprite, sprite->invisible);
+    if (sprite->data[1] > 56)
+    {
+        FieldEffectStop(sprite, sprite->data[7]);
+    }
+}
+
+u32 FldEff_Splash(void)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    u8 spriteId;
+    struct Sprite * sprite;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+    struct Sprite * linkedSprite;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    objectEvent = &gObjectEvents[objectEventId];
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[13], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        linkedSprite = &gSprites[objectEvent->spriteId];
+        sprite->oam.priority = linkedSprite->oam.priority;
+        sprite->data[0] = gFieldEffectArguments[0];
+        sprite->data[1] = gFieldEffectArguments[1];
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->pos2.y = (graphicsInfo->height >> 1) - 4;
+        PlaySE(SE_MIZU);
+    }
+    return 0;
+}
+
+void UpdateSplashFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+
+    if (sprite->animEnded || TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId))
+    {
+        FieldEffectStop(sprite, FLDEFF_SPLASH);
+    }
+    else
+    {
+        sprite->pos1.x = gSprites[gObjectEvents[objectEventId].spriteId].pos1.x;
+        sprite->pos1.y = gSprites[gObjectEvents[objectEventId].spriteId].pos1.y;
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+    }
+}
+
+u32 FldEff_JumpSmallSplash(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[14], gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = FLDEFF_JUMP_SMALL_SPLASH;
+    }
+    return 0;
+}
+
+u32 FldEff_JumpBigSplash(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[12], gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = FLDEFF_JUMP_BIG_SPLASH;
+    }
+    return 0;
+}
+
+u32 FldEff_FeetInFlowingWater(void)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    u8 spriteId;
+    struct Sprite * sprite;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    objectEvent = &gObjectEvents[objectEventId];
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[13], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+        sprite = &gSprites[spriteId];
+        sprite->callback = UpdateFeetInFlowingWaterFieldEffect;
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gSprites[objectEvent->spriteId].oam.priority;
+        sprite->data[0] = gFieldEffectArguments[0];
+        sprite->data[1] = gFieldEffectArguments[1];
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->data[3] = -1;
+        sprite->data[4] = -1;
+        sprite->pos2.y = (graphicsInfo->height >> 1) - 4;
+        StartSpriteAnim(sprite, 1);
+    }
+    return 0;
+}
+
+static void UpdateFeetInFlowingWaterFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    struct Sprite * linkedSprite;
+    struct ObjectEvent * objectEvent;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId) || !gObjectEvents[objectEventId].inShallowFlowingWater)
+    {
+        FieldEffectStop(sprite, FLDEFF_FEET_IN_FLOWING_WATER);
+    }
+    else
+    {
+        objectEvent = &gObjectEvents[objectEventId];
+        linkedSprite = &gSprites[objectEvent->spriteId];
+        sprite->pos1.x = linkedSprite->pos1.x;
+        sprite->pos1.y = linkedSprite->pos1.y;
+        sprite->subpriority = linkedSprite->subpriority;
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+        if (objectEvent->currentCoords.x != sprite->data[3] || objectEvent->currentCoords.y != sprite->data[4])
+        {
+            sprite->data[3] = objectEvent->currentCoords.x;
+            sprite->data[4] = objectEvent->currentCoords.y;
+            if (!sprite->invisible)
+            {
+                PlaySE(SE_MIZU);
+            }
+        }
+    }
+}
+
+u32 FldEff_Ripple(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[5], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = FLDEFF_RIPPLE;
+    }
+    return 0;
+}
+
+u32 FldEff_HotSpringsWater(void)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    objectEvent = &gObjectEvents[objectEventId];
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[31], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gSprites[objectEvent->spriteId].oam.priority;
+        sprite->data[0] = gFieldEffectArguments[0];
+        sprite->data[1] = gFieldEffectArguments[1];
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->data[3] = gSprites[objectEvent->spriteId].pos1.x;
+        sprite->data[4] = gSprites[objectEvent->spriteId].pos1.y;
+    }
+    return 0;
+}
+
+void UpdateHotSpringsWaterFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+    struct Sprite * linkedSprite;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId) || !gObjectEvents[objectEventId].inHotSprings)
+    {
+        FieldEffectStop(sprite, FLDEFF_HOT_SPRINGS_WATER);
+    }
+    else
+    {
+        graphicsInfo = GetObjectEventGraphicsInfo(gObjectEvents[objectEventId].graphicsId);
+        linkedSprite = &gSprites[gObjectEvents[objectEventId].spriteId];
+        sprite->pos1.x = linkedSprite->pos1.x;
+        sprite->pos1.y = (graphicsInfo->height >> 1) + linkedSprite->pos1.y - 8;
+        sprite->subpriority = linkedSprite->subpriority - 1;
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+    }
+}
+
+u32 FldEff_Unknown19(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[17], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = FLDEFF_UNKNOWN_19;
+    }
+    return 0;
+}
+
+u32 FldEff_Unknown20(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[18], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = FLDEFF_UNKNOWN_20;
+    }
+    return 0;
+}
+
+u32 FldEff_Unknown21(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[19], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = FLDEFF_UNKNOWN_21;
+    }
+    return 0;
+}
+
+u32 FldEff_Unknown22(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[20], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = FLDEFF_UNKNOWN_22;
+    }
+    return 0;
+}
+
+void StartAshFieldEffect(s16 x, s16 y, u16 metatileId, s16 d)
+{
+    gFieldEffectArguments[0] = x;
+    gFieldEffectArguments[1] = y;
+    gFieldEffectArguments[2] = 0x52;
+    gFieldEffectArguments[3] = 1;
+    gFieldEffectArguments[4] = metatileId;
+    gFieldEffectArguments[5] = d;
+    FieldEffectStart(FLDEFF_ASH);
+}
+
+u32 FldEff_Ash(void)
+{
+    s16 x;
+    s16 y;
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    x = gFieldEffectArguments[0];
+    y = gFieldEffectArguments[1];
+    sub_8063BC4(&x, &y, 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[6], x, y, gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[1] = gFieldEffectArguments[0];
+        sprite->data[2] = gFieldEffectArguments[1];
+        sprite->data[3] = gFieldEffectArguments[4];
+        sprite->data[4] = gFieldEffectArguments[5];
+    }
+    return 0;
+}
+
+void (*const gAshFieldEffectFuncs[])(struct Sprite * sprite) = {
+    UpdateAshFieldEffect_Step0,
+    UpdateAshFieldEffect_Step1,
+    UpdateAshFieldEffect_Step2
+};
+
+void UpdateAshFieldEffect(struct Sprite * sprite)
+{
+    gAshFieldEffectFuncs[sprite->data[0]](sprite);
+}
+
+static void UpdateAshFieldEffect_Step0(struct Sprite * sprite)
+{
+    sprite->invisible = TRUE;
+    sprite->animPaused = TRUE;
+    if (--sprite->data[4] == 0)
+        sprite->data[0] = 1;
+}
+
+static void UpdateAshFieldEffect_Step1(struct Sprite * sprite)
+{
+    sprite->invisible = FALSE;
+    sprite->animPaused = FALSE;
+    MapGridSetMetatileIdAt(sprite->data[1], sprite->data[2], sprite->data[3]);
+    CurrentMapDrawMetatileAt(sprite->data[1], sprite->data[2]);
+    gObjectEvents[gPlayerAvatar.objectEventId].triggerGroundEffectsOnMove = TRUE;
+    sprite->data[0] = 2;
+}
+
+static void UpdateAshFieldEffect_Step2(struct Sprite * sprite)
+{
+    UpdateObjectEventSpriteVisibility(sprite, FALSE);
+    if (sprite->animEnded)
+        FieldEffectStop(sprite, FLDEFF_ASH);
+}
+
+u32 FldEff_SurfBlob(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[7], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x96);
+    if (spriteId !=MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.paletteNum = 0;
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->data[3] = 0;
+        sprite->data[6] = -1;
+        sprite->data[7] = -1;
+    }
+    FieldEffectActiveListRemove(FLDEFF_SURF_BLOB);
+    return spriteId;
+}
+
+void sub_80DC44C(u8 spriteId, u8 value)
+{
+    gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF) | (value & 0xF);
+}
+
+void sub_80DC478(u8 spriteId, u8 value)
+{
+    gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF0) | ((value & 0xF) << 4);
+}
+
+void sub_80DC4A4(u8 spriteId, u8 value, s16 data1)
+{
+    gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF00) | ((value & 0xF) << 8);
+    gSprites[spriteId].data[1] = data1;
+}
+
+static u8 sub_80DC4D8(struct Sprite * sprite)
+{
+    return sprite->data[0] & 0xF;
+}
+
+static u8 sub_80DC4E0(struct Sprite * sprite)
+{
+    return (sprite->data[0] & 0xF0) >> 4;
+}
+
+static u8 sub_80DC4EC(struct Sprite * sprite)
+{
+    return (sprite->data[0] & 0xF00) >> 8;
+}
+
+void UpdateSurfBlobFieldEffect(struct Sprite * sprite)
+{
+    struct ObjectEvent * objectEvent;
+    struct Sprite * linkedSprite;
+
+    objectEvent = &gObjectEvents[sprite->data[2]];
+    linkedSprite = &gSprites[objectEvent->spriteId];
+    SynchroniseSurfAnim(objectEvent, sprite);
+    sub_80DC588(objectEvent, sprite);
+    CreateBobbingEffect(objectEvent, linkedSprite, sprite);
+    sprite->oam.priority = linkedSprite->oam.priority;
+}
+
+static void SynchroniseSurfAnim(struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    u8 surfBlobDirectionAnims[] = {
+        [DIR_NONE] = 0,
+        [DIR_SOUTH] = 0,
+        [DIR_NORTH] = 1,
+        [DIR_WEST] = 2,
+        [DIR_EAST] = 3
+    };
+
+    if (sub_80DC4E0(sprite) == 0)
+        StartSpriteAnimIfDifferent(sprite, surfBlobDirectionAnims[objectEvent->movementDirection]);
+}
+
+void sub_80DC588(struct ObjectEvent * objectEvent, struct Sprite * sprite)
+{
+    u8 i;
+    s16 x = objectEvent->currentCoords.x;
+    s16 y = objectEvent->currentCoords.y;
+    s32 spriteY = sprite->pos2.y;
+
+    if (spriteY == 0 && (x != sprite->data[6] || y != sprite->data[7]))
+    {
+        sprite->data[5] = spriteY;
+        sprite->data[6] = x;
+        sprite->data[7] = y;
+        for (i = DIR_SOUTH; i <= DIR_EAST; i++, x = sprite->data[6], y = sprite->data[7])
+        {
+            MoveCoords(i, &x, &y);
+            if (MapGridGetZCoordAt(x, y) == 3)
+            {
+                sprite->data[5]++;
+                break;
+            }
+        }
+    }
+}
+
+static void CreateBobbingEffect(struct ObjectEvent * objectEvent, struct Sprite * linkedSprite, struct Sprite * sprite)
+{
+    u16 unk_83FECFA[] = {7, 15};
+    u8 v0 = sub_80DC4D8(sprite);
+    if (v0 != 0)
+    {
+        if (((u16)(++ sprite->data[4]) & unk_83FECFA[sprite->data[5]]) == 0)
+        {
+            sprite->pos2.y += sprite->data[3];
+        }
+        if ((sprite->data[4] & 0x1F) == 0)
+        {
+            sprite->data[3] = -sprite->data[3];
+        }
+        if (v0 != 2)
+        {
+            if (sub_80DC4EC(sprite) == 0)
+                linkedSprite->pos2.y = sprite->pos2.y;
+            else
+                linkedSprite->pos2.y = sprite->data[1] + sprite->pos2.y;
+            if (sprite->animCmdIndex != 0)
+                linkedSprite->pos2.y++;
+            sprite->pos1.x = linkedSprite->pos1.x;
+            sprite->pos1.y = linkedSprite->pos1.y + 8;
+        }
+    }
+}
+
+u8 sub_80DC6B0(u8 oldSpriteId)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    spriteId = CreateSpriteAtEnd(&gDummySpriteTemplate, 0, 0, -1);
+    sprite = &gSprites[spriteId];
+    sprite->callback = sub_80DC700;
+    sprite->invisible = TRUE;
+    sprite->data[0] = oldSpriteId;
+    sprite->data[1] = 1;
+    return spriteId;
+}
+
+static void sub_80DC700(struct Sprite * sprite)
+{
+    struct Sprite * oldSprite;
+
+    oldSprite = &gSprites[sprite->data[0]];
+    if (((sprite->data[2]++) & 0x03) == 0)
+    {
+        oldSprite->pos2.y += sprite->data[1];
+    }
+    if ((sprite->data[2] & 0x0F) == 0)
+    {
+        sprite->data[1] = -sprite->data[1];
+    }
+}
+
+u32 FldEff_Dust(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[9], gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->data[0] = gFieldEffectArguments[2];
+        sprite->data[1] = 10;
+    }
+    return 0;
+}
+
+u32 FldEff_SandPile(void)
+{
+    u8 objectEventId;
+    struct ObjectEvent * objectEvent;
+    u8 spriteId;
+    struct Sprite * sprite;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+
+    objectEventId = GetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    objectEvent = &gObjectEvents[objectEventId];
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[29], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gSprites[objectEvent->spriteId].oam.priority;
+        sprite->data[0] = gFieldEffectArguments[0];
+        sprite->data[1] = gFieldEffectArguments[1];
+        sprite->data[2] = gFieldEffectArguments[2];
+        sprite->data[3] = gSprites[objectEvent->spriteId].pos1.x;
+        sprite->data[4] = gSprites[objectEvent->spriteId].pos1.y;
+        sprite->pos2.y = (graphicsInfo->height >> 1) - 2;
+        SeekSpriteAnim(sprite, 2);
+    }
+    return 0;
+}
+
+void UpdateSandPileFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    s16 x;
+    s16 y;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &objectEventId) || !gObjectEvents[objectEventId].inSandPile)
+    {
+        FieldEffectStop(sprite, FLDEFF_SAND_PILE);
+    }
+    else
+    {
+        y = gSprites[gObjectEvents[objectEventId].spriteId].pos1.y;
+        x = gSprites[gObjectEvents[objectEventId].spriteId].pos1.x;
+        if (x != sprite->data[3] || y != sprite->data[4])
+        {
+            sprite->data[3] = x;
+            sprite->data[4] = y;
+            if (sprite->animEnded)
+            {
+                StartSpriteAnim(sprite, 0);
+            }
+        }
+        sprite->pos1.x = x;
+        sprite->pos1.y = y;
+        sprite->subpriority = gSprites[gObjectEvents[objectEventId].spriteId].subpriority;
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+    }
+}
+
+u32 FldEff_Bubbles(void)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 0);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[34], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x52);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = 1;
+    }
+    return 0;
+}
+
+void UpdateBubblesFieldEffect(struct Sprite * sprite)
+{
+    sprite->data[0] += 0x80;
+    sprite->data[0] &= 0x100;
+    sprite->pos1.y -= sprite->data[0] >> 8;
+    UpdateObjectEventSpriteVisibility(sprite, FALSE);
+    if (sprite->invisible || sprite->animEnded)
+    {
+        FieldEffectStop(sprite, FLDEFF_BUBBLES);
+    }
+}
+
+u32 FldEff_BerryTreeGrowthSparkle(void)
+{
+    /*u8 spriteId;
+    struct Sprite * sprite;
+
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 4);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[22], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->oam.priority = gFieldEffectArguments[3];
+        sprite->oam.paletteNum = 5;
+        sprite->data[0] = FLDEFF_BERRY_TREE_GROWTH_SPARKLE;
+    }*/
+    return 0;
+}
+
+u32 ShowTreeDisguiseFieldEffect(void)
+{
+    return ShowDisguiseFieldEffect(FLDEFF_TREE_DISGUISE, 24, 4);
+}
+
+u32 ShowMountainDisguiseFieldEffect(void)
+{
+    return ShowDisguiseFieldEffect(FLDEFF_MOUNTAIN_DISGUISE, 25, 3);
+}
+
+u32 ShowSandDisguiseFieldEffect(void)
+{
+    return ShowDisguiseFieldEffect(FLDEFF_SAND_DISGUISE, 28, 2);
+}
+
+static u32 ShowDisguiseFieldEffect(u8 fldEff, u8 templateIdx, u8 paletteNum)
+{
+    u8 spriteId;
+    struct Sprite * sprite;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &spriteId))
+    {
+        FieldEffectActiveListRemove(fldEff);
+        return MAX_SPRITES;
+    }
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[templateIdx], 0, 0, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sprite = &gSprites[spriteId];
+        sprite->coordOffsetEnabled++;
+        sprite->oam.paletteNum = paletteNum;
+        sprite->data[1] = fldEff;
+        sprite->data[2] = gFieldEffectArguments[0];
+        sprite->data[3] = gFieldEffectArguments[1];
+        sprite->data[4] = gFieldEffectArguments[2];
+    }
+    return spriteId;
+}
+
+void UpdateDisguiseFieldEffect(struct Sprite * sprite)
+{
+    u8 objectEventId;
+    const struct ObjectEventGraphicsInfo * graphicsInfo;
+    struct Sprite * linkedSprite;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->data[2], sprite->data[3], sprite->data[4], &objectEventId))
+    {
+        FieldEffectStop(sprite, sprite->data[1]);
+    }
+
+    graphicsInfo = GetObjectEventGraphicsInfo(gObjectEvents[objectEventId].graphicsId);
+    linkedSprite = &gSprites[gObjectEvents[objectEventId].spriteId];
+    sprite->invisible = linkedSprite->invisible;
+    sprite->pos1.x = linkedSprite->pos1.x;
+    sprite->pos1.y = (graphicsInfo->height >> 1) + linkedSprite->pos1.y - 16;
+    sprite->subpriority = linkedSprite->subpriority - 1;
+    if (sprite->data[0] == 1)
+    {
+        sprite->data[0]++;
+        StartSpriteAnim(sprite, 1);
+    }
+    if (sprite->data[0] == 2 && sprite->animEnded)
+    {
+        sprite->data[7] = 1;
+    }
+    if (sprite->data[0] == 3)
+    {
+        FieldEffectStop(sprite, sprite->data[1]);
+    }
+}
+
+void sub_80DCBB8(struct ObjectEvent * objectEvent)
+{
+    if (objectEvent->directionSequenceIndex == 1)
+    {
+        gSprites[objectEvent->fieldEffectSpriteId].data[0]++;
+    }
+}
+
+bool8 sub_80DCBE0(struct ObjectEvent * objectEvent)
+{
+    struct Sprite * sprite;
+
+    if (objectEvent->directionSequenceIndex == 2)
+    {
+        return TRUE;
+    }
+    if (objectEvent->directionSequenceIndex == 0)
+    {
+        return TRUE;
+    }
+    sprite = &gSprites[objectEvent->fieldEffectSpriteId];
+    if (sprite->data[7])
+    {
+        objectEvent->directionSequenceIndex = 2;
+        sprite->data[0]++;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+u32 FldEff_Sparkle(void)
+{
+    u8 spriteId;
+
+    gFieldEffectArguments[0] += 7;
+    gFieldEffectArguments[1] += 7;
+    sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8);
+    spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[35], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x52);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].oam.priority = gFieldEffectArguments[2];
+        gSprites[spriteId].coordOffsetEnabled = TRUE;
+    }
+    return 0;
+}
+
+void UpdateSparkleFieldEffect(struct Sprite * sprite)
+{
+    if (sprite->data[0] == 0)
+    {
+        if (sprite->animEnded)
+        {
+            sprite->invisible = TRUE;
+            sprite->data[0]++;
+        }
+
+        if (sprite->data[0] == 0)
+            return;
+    }
+
+    if (++sprite->data[1] > 34)
+        FieldEffectStop(sprite, FLDEFF_SPARKLE);
+}
+
+void sub_80DCCE0(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+    {
+        FieldEffectStop(sprite, sprite->data[1]);
+    }
+    else
+    {
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+        SetObjectSubpriorityByZCoord(sprite->data[0], sprite, 0);
+    }
+}
+
+void WaitFieldEffectSpriteAnim(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+        FieldEffectStop(sprite, sprite->data[0]);
+    else
+        UpdateObjectEventSpriteVisibility(sprite, FALSE);
+}
+
+static void sub_80DCD48(struct Sprite * sprite, u8 z, u8 offset)
+{
+    u8 i;
+    s16 var, xhi, lyhi, yhi, ylo;
+    const struct ObjectEventGraphicsInfo * graphicsInfo; // Unused Variable
+    struct Sprite * linkedSprite;
+
+    SetObjectSubpriorityByZCoord(z, sprite, offset);
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        struct ObjectEvent * objectEvent = &gObjectEvents[i];
+        if (objectEvent->active)
+        {
+            graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+            linkedSprite = &gSprites[objectEvent->spriteId];
+            xhi = sprite->pos1.x + sprite->centerToCornerVecX;
+            var = sprite->pos1.x - sprite->centerToCornerVecX;
+            if (xhi < linkedSprite->pos1.x && var > linkedSprite->pos1.x)
+            {
+                lyhi = linkedSprite->pos1.y + linkedSprite->centerToCornerVecY;
+                var = linkedSprite->pos1.y;
+                ylo = sprite->pos1.y - sprite->centerToCornerVecY;
+                yhi = ylo + linkedSprite->centerToCornerVecY;
+                if ((lyhi < yhi || lyhi < ylo) && var > yhi && sprite->subpriority <= linkedSprite->subpriority)
+                {
+                    sprite->subpriority = linkedSprite->subpriority + 2;
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c
index 4edefd13a..58f654110 100644
--- a/src/field_fadetransition.c
+++ b/src/field_fadetransition.c
@@ -13,16 +13,17 @@
 #include "metatile_behavior.h"
 #include "quest_log.h"
 #include "link.h"
-#include "event_object_80688E4.h"
+#include "event_object_movement.h"
 #include "sound.h"
 #include "field_door.h"
 #include "field_effect.h"
 #include "field_screen_effect.h"
-#include "event_object_movement.h"
 #include "field_specials.h"
 #include "event_object_lock.h"
 #include "start_menu.h"
 #include "constants/songs.h"
+#include "constants/event_object_movement.h"
+#include "constants/field_weather.h"
 
 static void sub_807DF4C(u8 a0);
 static void sub_807DFBC(u8 taskId);
@@ -50,18 +51,18 @@ void palette_bg_faded_fill_black(void)
     CpuFastFill16(RGB_BLACK, gPlttBufferFaded, 0x400);
 }
 
-void pal_fill_for_maplights(void)
+void WarpFadeInScreen(void)
 {
-    switch (sub_80C9DCC(get_map_light_from_warp0(), GetCurrentMapType()))
+    switch (MapTransitionIsExit(GetLastUsedWarpMapType(), GetCurrentMapType()))
     {
     case 0:
         palette_bg_faded_fill_black();
-        FadeScreen(0, 0);
+        FadeScreen(FADE_FROM_BLACK, 0);
         palette_bg_faded_fill_black();
         break;
     case 1:
         palette_bg_faded_fill_white();
-        FadeScreen(2, 0);
+        FadeScreen(FADE_FROM_WHITE, 0);
         palette_bg_faded_fill_white();
         break;
     }
@@ -69,42 +70,42 @@ void pal_fill_for_maplights(void)
 
 static void sub_807DBAC(void)
 {
-    switch (sub_80C9DCC(get_map_light_from_warp0(), GetCurrentMapType()))
+    switch (MapTransitionIsExit(GetLastUsedWarpMapType(), GetCurrentMapType()))
     {
     case 0:
         palette_bg_faded_fill_black();
-        FadeScreen(0, 3);
+        FadeScreen(FADE_FROM_BLACK, 3);
         palette_bg_faded_fill_black();
         break;
     case 1:
         palette_bg_faded_fill_white();
-        FadeScreen(2, 3);
+        FadeScreen(FADE_FROM_WHITE, 3);
         palette_bg_faded_fill_white();
         break;
     }
 }
 
-void sub_807DC00(void)
+void FadeInFromBlack(void)
 {
     palette_bg_faded_fill_black();
-    FadeScreen(0, 0);
+    FadeScreen(FADE_FROM_BLACK, 0);
     palette_bg_faded_fill_black();
 }
 
-void sub_807DC18(void)
+void WarpFadeOutScreen(void)
 {
     const struct MapHeader *header = warp1_get_mapheader();
-    if (header->regionMapSectionId != gMapHeader.regionMapSectionId && sub_80F8110(header->regionMapSectionId, FALSE))
-        FadeScreen(1, 0);
+    if (header->regionMapSectionId != gMapHeader.regionMapSectionId && MapHasPreviewScreen(header->regionMapSectionId, MPS_TYPE_CAVE))
+        FadeScreen(FADE_TO_BLACK, 0);
     else
     {
-        switch (sub_80C9D7C(GetCurrentMapType(), header->mapType))
+        switch (MapTransitionIsEnter(GetCurrentMapType(), header->mapType))
         {
-        case 0:
-            FadeScreen(1, 0);
+        case FALSE:
+            FadeScreen(FADE_TO_BLACK, 0);
             break;
-        case 1:
-            FadeScreen(3, 0);
+        case TRUE:
+            FadeScreen(FADE_TO_WHITE, 0);
             break;
         }
     }
@@ -112,13 +113,13 @@ void sub_807DC18(void)
 
 static void sub_807DC70(void)
 {
-    switch (sub_80C9D7C(GetCurrentMapType(), warp1_get_mapheader()->mapType))
+    switch (MapTransitionIsEnter(GetCurrentMapType(), warp1_get_mapheader()->mapType))
     {
-    case 0:
-        FadeScreen(1, 3);
+    case FALSE:
+        FadeScreen(FADE_TO_BLACK, 3);
         break;
-    case 1:
-        FadeScreen(3, 3);
+    case TRUE:
+        FadeScreen(FADE_TO_WHITE, 3);
         break;
     }
 }
@@ -138,7 +139,7 @@ void sub_807DCE4(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(task0A_nop_for_a_while, 10);
 }
 
@@ -155,14 +156,14 @@ void FieldCallback_ReturnToEventScript2(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(task0A_asap_script_env_2_enable_and_set_ctx_running, 10);
 }
 
 void sub_807DD44(void)
 {
     ScriptContext2_Enable();
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(task0A_asap_script_env_2_enable_and_set_ctx_running, 10);
 }
 
@@ -172,13 +173,13 @@ static void task_mpl_807DD60(u8 taskId)
     switch (task->data[0])
     {
     case 0:
-        task->data[1] = sub_8081150();
+        task->data[1] = CreateTask_ReestablishLinkInCableClubRoom();
         task->data[0]++;
         break;
     case 1:
         if (gTasks[task->data[1]].isActive != TRUE)
         {
-            pal_fill_for_maplights();
+            WarpFadeInScreen();
             task->data[0]++;
         }
         break;
@@ -192,7 +193,7 @@ static void task_mpl_807DD60(u8 taskId)
     }
 }
 
-void sub_807DDD0(void)
+void FieldCB_ReturnToFieldWiredLink(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
@@ -206,13 +207,13 @@ static void sub_807DDF0(u8 taskId)
     switch (task->data[0])
     {
     case 0:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         task->data[0]++;
         break;
     case 1:
         if (IsLinkTaskFinished())
         {
-            pal_fill_for_maplights();
+            WarpFadeInScreen();
             task->data[0]++;
         }
         break;
@@ -227,7 +228,7 @@ static void sub_807DDF0(u8 taskId)
     }
 }
 
-void sub_807DE58(void)
+void FieldCB_ReturnToFieldWirelessLink(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
@@ -246,7 +247,7 @@ static void sub_807DE78(bool8 a0)
     if (MetatileBehavior_IsWarpDoor_2(behavior) == TRUE)
     {
         func = sub_807DFBC;
-        switch (sub_80C9DCC(get_map_light_from_warp0(), GetCurrentMapType()))
+        switch (MapTransitionIsExit(GetLastUsedWarpMapType(), GetCurrentMapType()))
         {
         case 0:
             palette_bg_faded_fill_black();
@@ -278,9 +279,9 @@ static void sub_807DE78(bool8 a0)
 static void sub_807DF4C(bool8 a0)
 {
     if (!a0)
-        pal_fill_for_maplights();
+        WarpFadeInScreen();
     else
-        sub_807DC00();
+        FadeInFromBlack();
 }
 
 void sub_807DF64(void)
@@ -302,7 +303,7 @@ void sub_807DF7C(void)
 static void sub_807DF94(void)
 {
     Overworld_PlaySpecialMapMusic();
-    pal_fill_for_maplights();
+    WarpFadeInScreen();
     sub_8111CF0();
     PlaySE(SE_TK_WARPOUT);
     CreateTask(sub_807E31C, 10);
@@ -349,7 +350,7 @@ static void sub_807DFBC(u8 taskId)
         {
             PlayerGetDestCoords(&task->data[12], &task->data[13]);
             sub_807DCB0(TRUE);
-            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], 16);
+            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], MOVEMENT_ACTION_WALK_NORMAL_DOWN);
             task->data[0] = 8;
         }
         break;
@@ -373,7 +374,7 @@ static void sub_807DFBC(u8 taskId)
         if (sub_807E418())
         {
             sub_807DCB0(TRUE);
-            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], 16);
+            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], MOVEMENT_ACTION_WALK_NORMAL_DOWN);
             task->data[0] = 2;
         }
         break;
@@ -485,7 +486,7 @@ static void Task_WaitFadeAndCreateStartMenuTask(u8 taskId)
 
 void FadeTransition_FadeInOnReturnToStartMenu(void)
 {
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(Task_WaitFadeAndCreateStartMenuTask, 80);
     ScriptContext2_Enable();
 }
@@ -510,7 +511,7 @@ void sub_807E3EC(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(task_mpl_807E3C8, 10);
 }
 
@@ -521,7 +522,7 @@ static bool32 sub_807E40C(void)
 
 bool32 sub_807E418(void)
 {
-    if (IsWeatherNotFadingIn() == TRUE && sub_80F83B0())
+    if (IsWeatherNotFadingIn() == TRUE && ForestMapPreviewScreenIsRunning())
         return TRUE;
     else
         return FALSE;
@@ -530,8 +531,8 @@ bool32 sub_807E418(void)
 void DoWarp(void)
 {
     ScriptContext2_Enable();
-    sub_8055F88();
-    sub_807DC18();
+    TryFadeOutOldMapMusic();
+    WarpFadeOutScreen();
     PlayRainStoppingSoundEffect();
     PlaySE(SE_KAIDAN);
     gFieldCallback = sub_807DF64;
@@ -541,8 +542,8 @@ void DoWarp(void)
 void DoDiveWarp(void)
 {
     ScriptContext2_Enable();
-    sub_8055F88();
-    sub_807DC18();
+    TryFadeOutOldMapMusic();
+    WarpFadeOutScreen();
     PlayRainStoppingSoundEffect();
     gFieldCallback = sub_807DF64;
     CreateTask(sub_807E718, 10);
@@ -580,31 +581,31 @@ void sub_807E524(void)
 void DoFallWarp(void)
 {
     DoDiveWarp();
-    gFieldCallback = sub_8084454;
+    gFieldCallback = FieldCB_FallWarpExit;
 }
 
 void sub_807E560(u8 a0)
 {
     ScriptContext2_Enable();
-    sub_8084784(a0, 10);
+    StartEscalatorWarp(a0, 10);
 }
 
 void sub_807E57C(void)
 {
     ScriptContext2_Enable();
-    sub_8084F2C(10);
+    StartLavaridgeGymB1FWarp(10);
 }
 
 void sub_807E58C(void)
 {
     ScriptContext2_Enable();
-    sub_80853CC(10);
+    StartLavaridgeGym1FWarp(10);
 }
 
 void sub_807E59C(void)
 {
     ScriptContext2_Enable();
-    sub_8055F88();
+    TryFadeOutOldMapMusic();
     CreateTask(sub_807E784, 10);
     gFieldCallback = sub_807DF94;
 }
@@ -612,7 +613,7 @@ void sub_807E59C(void)
 void sub_807E5C4(void)
 {
     ScriptContext2_Enable();
-    sub_807DC18();
+    WarpFadeOutScreen();
     CreateTask(sub_807E718, 10);
     gFieldCallback = nullsub_60;
 }
@@ -632,7 +633,7 @@ static void sub_807E5EC(u8 taskId)
         break;
     case 2:
         WarpIntoMap();
-        SetMainCallback2(sub_8056788);
+        SetMainCallback2(CB2_ReturnToFieldCableClub);
         DestroyTask(taskId);
         break;
     }
@@ -641,8 +642,8 @@ static void sub_807E5EC(u8 taskId)
 void DoCableClubWarp(void)
 {
     ScriptContext2_Enable();
-    sub_8055F88();
-    sub_807DC18();
+    TryFadeOutOldMapMusic();
+    WarpFadeOutScreen();
     PlaySE(SE_KAIDAN);
     CreateTask(sub_807E5EC, 10);
 }
@@ -654,15 +655,15 @@ static void sub_807E678(u8 taskId)
     {
     case 0:
         ClearLinkCallback_2();
-        FadeScreen(1, 0);
-        sub_8055F88();
+        FadeScreen(FADE_TO_BLACK, 0);
+        TryFadeOutOldMapMusic();
         PlaySE(SE_KAIDAN);
         data[0]++;
         break;
     case 1:
         if (!sub_807E40C() && BGMusicStopped())
         {
-            sub_800AAC0();
+            Link_TryStartSend5FFF();
             data[0]++;
         }
         break;
@@ -719,7 +720,7 @@ static void sub_807E784(u8 taskId)
     case 1:
         if (!sub_805DAD0())
         {
-            sub_807DC18();
+            WarpFadeOutScreen();
             task->data[0]++;
         }
         break;
@@ -753,7 +754,7 @@ static void sub_807E80C(u8 taskId)
         if (task->data[1] < 0 || gTasks[task->data[1]].isActive != TRUE)
         {
             ObjectEventClearHeldMovementIfActive(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)]);
-            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], 17);
+            ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], MOVEMENT_ACTION_WALK_NORMAL_UP);
             task->data[0] = 2;
         }
         break;
@@ -773,14 +774,14 @@ static void sub_807E80C(u8 taskId)
         }
         break;
     case 4:
-        sub_8055F88();
-        sub_807DC18();
+        TryFadeOutOldMapMusic();
+        WarpFadeOutScreen();
         PlayRainStoppingSoundEffect();
         task->data[0] = 0;
         task->func = sub_807E718;
         break;
     case 5:
-        sub_8055F88();
+        TryFadeOutOldMapMusic();
         PlayRainStoppingSoundEffect();
         task->data[0] = 0;
         task->func = sub_807E718;
@@ -808,7 +809,7 @@ static void sub_807E980(u8 taskId)
                 data[15]--;
             else
             {
-                sub_8055F88();
+                TryFadeOutOldMapMusic();
                 PlayRainStoppingSoundEffect();
                 playerSpr->oam.priority = 1;
                 sub_807EB64(data[1], &data[2], &data[3]);
@@ -822,7 +823,7 @@ static void sub_807E980(u8 taskId)
         data[15]++;
         if (data[15] >= 12)
         {
-            sub_807DC18();
+            WarpFadeOutScreen();
             data[0]++;
         }
         break;
@@ -906,7 +907,7 @@ static void sub_807EC34(u8 taskId)
         break;
     case 0:
         Overworld_PlaySpecialMapMusic();
-        pal_fill_for_maplights();
+        WarpFadeInScreen();
         ScriptContext2_Enable();
         sub_807ECBC(&data[1], &data[2], &data[3], &data[4], &data[5]);
         data[0]++;
diff --git a/src/field_message_box.c b/src/field_message_box.c
new file mode 100644
index 000000000..1909fd398
--- /dev/null
+++ b/src/field_message_box.c
@@ -0,0 +1,140 @@
+#include "global.h"
+#include "gflib.h"
+#include "new_menu_helpers.h"
+#include "quest_log.h"
+#include "script.h"
+#include "text_window.h"
+
+static EWRAM_DATA u8 sMessageBoxType = 0;
+
+static void textbox_fdecode_auto_and_task_add(const u8 *str);
+static void textbox_auto_and_task_add(void);
+
+void sub_8069348(void)
+{
+    sMessageBoxType = 0;
+    gTextFlags.canABSpeedUpPrint = FALSE;
+    gTextFlags.useAlternateDownArrow = FALSE;
+    gTextFlags.autoScroll = FALSE;
+}
+
+static void Task_RunFieldMessageBoxPrinter(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        if (gQuestLogState == QL_STATE_2)
+        {
+            gTextFlags.autoScroll = TRUE;
+            TextWindow_LoadTilesStdFrame1(0, 0x200);
+        }
+        else if (!IsMsgSignPost())
+        {
+            LoadStdWindowFrameGfx();
+        }
+        else
+        {
+            LoadSignPostWindowFrameGfx();
+        }
+        task->data[0]++;
+        break;
+    case 1:
+        DrawDialogueFrame(0, TRUE);
+        task->data[0]++;
+        break;
+    case 2:
+        if (RunTextPrinters_CheckPrinter0Active() != TRUE)
+        {
+            sMessageBoxType = 0;
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+static void task_add_textbox(void)
+{
+    CreateTask(Task_RunFieldMessageBoxPrinter, 80);
+}
+
+static void task_del_textbox(void)
+{
+    u8 taskId = FindTaskIdByFunc(Task_RunFieldMessageBoxPrinter);
+    if (taskId != 0xFF)
+        DestroyTask(taskId);
+}
+
+bool8 ShowFieldMessage(const u8 *str)
+{
+    if (sMessageBoxType != 0)
+        return FALSE;
+    textbox_fdecode_auto_and_task_add(str);
+    sMessageBoxType = 2;
+    return TRUE;
+}
+
+bool8 ShowFieldAutoScrollMessage(const u8 *str)
+{
+    if (sMessageBoxType != 0)
+        return FALSE;
+    sMessageBoxType = 3;
+    textbox_fdecode_auto_and_task_add(str);
+    return TRUE;
+}
+
+bool8 sub_806948C(const u8 *str)
+{
+    sMessageBoxType = 3;
+    textbox_fdecode_auto_and_task_add(str);
+    return TRUE;
+}
+
+bool8 sub_80694A4(const u8 *str)
+{
+    if (sMessageBoxType != 0)
+        return FALSE;
+    sMessageBoxType = 2;
+    textbox_auto_and_task_add();
+    return TRUE;
+}
+
+static void textbox_fdecode_auto_and_task_add(const u8 *str)
+{
+    StringExpandPlaceholders(gStringVar4, str);
+    AddTextPrinterDiffStyle(TRUE);
+    task_add_textbox();
+}
+
+static void textbox_auto_and_task_add(void)
+{
+    AddTextPrinterDiffStyle(TRUE);
+    task_add_textbox();
+}
+
+void HideFieldMessageBox(void)
+{
+    task_del_textbox();
+    ClearDialogWindowAndFrame(0, TRUE);
+    sMessageBoxType = 0;
+}
+
+u8 textbox_any_visible(void)
+{
+    return sMessageBoxType;
+}
+
+bool8 IsFieldMessageBoxHidden(void)
+{
+    if (sMessageBoxType == 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8069538(void)
+{
+    task_del_textbox();
+    DrawStdWindowFrame(0, TRUE);
+    sMessageBoxType = 0;
+}
diff --git a/src/field_poison.c b/src/field_poison.c
index 07c2b763f..aa77375a5 100644
--- a/src/field_poison.c
+++ b/src/field_poison.c
@@ -48,42 +48,45 @@ static bool32 MonFaintedFromPoison(u8 partyIdx)
     return FALSE;
 }
 
-static void Task_WhiteOut(u8 taskId)
+#define tState   data[0]
+#define tPartyId data[1]
+
+static void Task_TryFieldPoisonWhiteOut(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
-    switch (data[0])
+    switch (tState)
     {
     case 0:
-        for (; data[1] < PARTY_SIZE; data[1]++)
+        for (; tPartyId < PARTY_SIZE; tPartyId++)
         {
-            if (MonFaintedFromPoison(data[1]))
+            if (MonFaintedFromPoison(tPartyId))
             {
-                FaintFromFieldPoison(data[1]);
+                FaintFromFieldPoison(tPartyId);
                 ShowFieldMessage(gText_PkmnFainted3);
                 data[0]++;
                 return;
             }
         }
-        data[0] = 2;
+        tState = 2;
         break;
     case 1:
         if (IsFieldMessageBoxHidden())
-            data[0]--;
+            tState--;
         break;
     case 2:
         if (AllMonsFainted())
-            gSpecialVar_Result = 1;
+            gSpecialVar_Result = TRUE;
         else
-            gSpecialVar_Result = 0;
+            gSpecialVar_Result = FALSE;
         EnableBothScriptContexts();
         DestroyTask(taskId);
         break;
     }
 }
 
-void ExecuteWhiteOut(void)
+void TryFieldPoisonWhiteOut(void)
 {
-    CreateTask(Task_WhiteOut, 80);
+    CreateTask(Task_TryFieldPoisonWhiteOut, 80);
     ScriptContext1_Stop();
 }
 
diff --git a/src/field_screen_effect.c b/src/field_screen_effect.c
index 0a3224cfa..85739ad24 100644
--- a/src/field_screen_effect.c
+++ b/src/field_screen_effect.c
@@ -212,7 +212,7 @@ void WriteFlashScanlineEffectBuffer(u8 flashLevel)
     }
 }
 
-void sub_807F0B0(void)
+void Script_FadeOutMapMusic(void)
 {
     Overworld_FadeOutMapMusic();
     CreateTask(Task_EnableScriptAfterMusicFade, 80);
@@ -430,7 +430,7 @@ static void sub_807F45C(u8 taskId)
         CopyWindowToVram(windowId, 1);
         RemoveWindow(windowId);
         palette_bg_faded_fill_black();
-        sub_807DC00();
+        FadeInFromBlack();
         ++gTasks[taskId].data[0];
         break;
     case 3:
@@ -444,7 +444,7 @@ static void sub_807F45C(u8 taskId)
         if (sub_807E418() == TRUE)
         {
             DestroyTask(taskId);
-            ScriptContext1_SetupScript(EventScript_MomHeal);
+            ScriptContext1_SetupScript(EventScript_AfterWhiteOutMomHeal);
         }
         break;
     }
diff --git a/src/field_special_scene.c b/src/field_special_scene.c
index 4f9446942..327426231 100644
--- a/src/field_special_scene.c
+++ b/src/field_special_scene.c
@@ -21,6 +21,7 @@ void nullsub_60(void)
 {
 }
 
-void nullsub_61(void)
+// From Hoenn's SS Tidal
+void LookThroughPorthole(void)
 {
 }
diff --git a/src/field_specials.c b/src/field_specials.c
index bb320d42a..ea4ed9449 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -41,11 +41,12 @@
 #include "constants/songs.h"
 #include "constants/species.h"
 #include "constants/items.h"
-#include "constants/object_events.h"
 #include "constants/maps.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 #include "constants/moves.h"
 #include "constants/menu.h"
+#include "constants/event_objects.h"
+#include "constants/metatile_labels.h"
 
 static EWRAM_DATA u8 sElevatorCurrentFloorWindowId = 0;
 static EWRAM_DATA u16 sElevatorScroll = 0;
@@ -76,12 +77,12 @@ static void Task_SuspendListMenu(u8 taskId);
 static void Task_RedrawScrollArrowsAndWaitInput(u8 taskId);
 static void Task_CreateMenuRemoveScrollIndicatorArrowPair(u8 taskId);
 static void Task_ListMenuRemoveScrollIndicatorArrowPair(u8 taskId);
-static u16 GetStarterPokemon(u16 starterIdx);
+static u16 GetStarterSpeciesById(u16 starterIdx);
 static void ChangeBoxPokemonNickname_CB(void);
 static void ChangePokemonNickname_CB(void);
 static void Task_RunPokemonLeagueLightingEffect(u8 taskId);
 static void Task_CancelPokemonLeagueLightingEffect(u8 taskId);
-static void Task_DoDeoxysRockInteraction(u8 taskId);
+static void Task_DoDeoxysTriangleInteraction(u8 taskId);
 static void MoveDeoxysObject(u8 num);
 static void Task_WaitDeoxysFieldEffect(u8 taskId);
 static void Task_WingFlapSound(u8 taskId);
@@ -92,14 +93,14 @@ static u8 *const sStringVarPtrs[] = {
     gStringVar3
 };
 
-void Special_ShowDiploma(void)
+void ShowDiploma(void)
 {
     sub_8112364();
     SetMainCallback2(CB2_ShowDiploma);
     ScriptContext2_Enable();
 }
 
-void Special_ForcePlayerOntoBike(void)
+void ForcePlayerOntoBike(void)
 {
     if (gPlayerAvatar.flags & 1)
         SetPlayerAvatarTransitionFlags(2);
@@ -112,7 +113,7 @@ void nullsub_74(void)
 
 }
 
-u8 Special_GetPlayerAvatarBike(void)
+u8 GetPlayerAvatarBike(void)
 {
     if (TestPlayerAvatarFlags(4))
         return 1;
@@ -122,24 +123,24 @@ u8 Special_GetPlayerAvatarBike(void)
         return 0;
 }
 
-void Special_ShowStringVar4AsFieldMessage(void)
+void ShowFieldMessageStringVar4(void)
 {
     ShowFieldMessage(gStringVar4);
 }
 
-void Special_GetPlayerXY(void)
+void GetPlayerXY(void)
 {
     gSpecialVar_0x8004 = gSaveBlock1Ptr->pos.x;
     gSpecialVar_0x8005 = gSaveBlock1Ptr->pos.y;
 }
 
-u8 Special_GetPlayerTrainerIdOnesDigit(void)
+u8 GetPlayerTrainerIdOnesDigit(void)
 {
     u16 playerId = (gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0];
     return playerId % 10;
 }
 
-void Special_BufferBigGuyOrBigGirlString(void)
+void BufferBigGuyOrBigGirlString(void)
 {
     if (gSaveBlock2Ptr->playerGender == MALE)
         StringCopy(gStringVar1, gText_BigGuy);
@@ -147,7 +148,7 @@ void Special_BufferBigGuyOrBigGirlString(void)
         StringCopy(gStringVar1, gText_BigGirl);
 }
 
-void Special_BufferSonOrDaughterString(void)
+void BufferSonOrDaughterString(void)
 {
     if (gSaveBlock2Ptr->playerGender == MALE)
         StringCopy(gStringVar1, gText_Son);
@@ -155,17 +156,17 @@ void Special_BufferSonOrDaughterString(void)
         StringCopy(gStringVar1, gText_Daughter);
 }
 
-u8 Special_GetBattleOutcome(void)
+u8 GetBattleOutcome(void)
 {
     return gBattleOutcome;
 }
 
-void Special_SetHiddenItemFlag(void)
+void SetHiddenItemFlag(void)
 {
     FlagSet(gSpecialVar_0x8004);
 }
 
-u8 Special_GetLeadMonFriendship(void)
+u8 GetLeadMonFriendship(void)
 {
     struct Pokemon * pokemon = &gPlayerParty[GetLeadMonIndex()];
     if (GetMonData(pokemon, MON_DATA_FRIENDSHIP) == 255)
@@ -184,13 +185,13 @@ u8 Special_GetLeadMonFriendship(void)
         return 0;
 }
 
-void Special_TownMap(void)
+void ShowTownMap(void)
 {
     sub_8112364();
     sub_80BFF50(1, CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
-bool8 Special_PlayerHasGrassPokemonInParty(void)
+bool8 PlayerHasGrassPokemonInParty(void)
 {
     u8 i;
     struct Pokemon * pokemon;
@@ -211,34 +212,41 @@ bool8 Special_PlayerHasGrassPokemonInParty(void)
     return FALSE;
 }
 
-void Special_AnimatePcTurnOn(void)
+#define tState data[0]
+#define tTimer data[1]
+
+void AnimatePcTurnOn(void)
 {
     u8 taskId;
 
     if (FuncIsActiveTask(Task_AnimatePcTurnOn) != TRUE)
     {
         taskId = CreateTask(Task_AnimatePcTurnOn, 8);
-        gTasks[taskId].data[0] = 0;
-        gTasks[taskId].data[1] = 0;
+        gTasks[taskId].tState = 0;
+        gTasks[taskId].tTimer = 0;
     }
 }
 
+// PC flickers on and off while turning on
 static void Task_AnimatePcTurnOn(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
-    if (data[1] == 6)
+    if (tTimer == 6)
     {
-        PcTurnOnUpdateMetatileId(data[0] & 1);
+        PcTurnOnUpdateMetatileId(tState & 1);
         DrawWholeMapView();
-        data[1] = 0;
-        data[0]++;
-        if (data[0] == 5)
+        tTimer = 0;
+        tState++;
+        if (tState == 5)
             DestroyTask(taskId);
     }
-    data[1]++;
+    tTimer++;
 }
 
-static void PcTurnOnUpdateMetatileId(bool16 a0)
+#undef tState
+#undef tTimer
+
+static void PcTurnOnUpdateMetatileId(bool16 flickerOff)
 {
     u16 metatileId = 0;
     s8 deltaX = 0;
@@ -260,28 +268,28 @@ static void PcTurnOnUpdateMetatileId(bool16 a0)
         deltaY = -1;
         break;
     }
-    if (a0)
+    if (flickerOff)
     {
         if (gSpecialVar_0x8004 == 0)
-            metatileId = 0x62;
+            metatileId = METATILE_Building_PCOff;
         else if (gSpecialVar_0x8004 == 1)
-            metatileId = 0x28F;
+            metatileId = METATILE_GenericBuilding1_PlayersPCOff;
         else if (gSpecialVar_0x8004 == 2)
-            metatileId = 0x28F;
+            metatileId = METATILE_GenericBuilding1_PlayersPCOff;
     }
     else
     {
         if (gSpecialVar_0x8004 == 0)
-            metatileId = 0x63;
+            metatileId = METATILE_Building_PCOn;
         else if (gSpecialVar_0x8004 == 1)
-            metatileId = 0x28A;
+            metatileId = METATILE_GenericBuilding1_PlayersPCOn;
         else if (gSpecialVar_0x8004 == 2)
-            metatileId = 0x28A;
+            metatileId = METATILE_GenericBuilding1_PlayersPCOn;
     }
-    MapGridSetMetatileIdAt(gSaveBlock1Ptr->pos.x + deltaX + 7, gSaveBlock1Ptr->pos.y + deltaY + 7, metatileId | 0xC00);
+    MapGridSetMetatileIdAt(gSaveBlock1Ptr->pos.x + deltaX + 7, gSaveBlock1Ptr->pos.y + deltaY + 7, metatileId | METATILE_COLLISION_MASK);
 }
 
-void Special_AnimatePcTurnOff()
+void AnimatePcTurnOff()
 {
     u16 metatileId = 0;
     s8 deltaX = 0;
@@ -304,18 +312,19 @@ void Special_AnimatePcTurnOff()
         break;
     }
     if (gSpecialVar_0x8004 == 0)
-        metatileId = 0x62;
+        metatileId = METATILE_Building_PCOff;
     else if (gSpecialVar_0x8004 == 1)
-        metatileId = 0x28F;
+        metatileId = METATILE_GenericBuilding1_PlayersPCOff;
     else if (gSpecialVar_0x8004 == 2)
-        metatileId = 0x28F;
-    MapGridSetMetatileIdAt(gSaveBlock1Ptr->pos.x + deltaX + 7, gSaveBlock1Ptr->pos.y + deltaY + 7, metatileId | 0xC00);
+        metatileId = METATILE_GenericBuilding1_PlayersPCOff;
+    MapGridSetMetatileIdAt(gSaveBlock1Ptr->pos.x + deltaX + 7, gSaveBlock1Ptr->pos.y + deltaY + 7, metatileId | METATILE_COLLISION_MASK);
     DrawWholeMapView();
 }
 
 void SpawnCameraObject(void)
 {
-    u8 objectEventId = SpawnSpecialObjectEventParameterized(OBJECT_EVENT_GFX_YOUNGSTER, 8, 127, gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7, 3);
+
+    u8 objectEventId = SpawnSpecialObjectEventParameterized(OBJ_EVENT_GFX_YOUNGSTER, 8, OBJ_EVENT_ID_CAMERA, gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7, 3);
     gObjectEvents[objectEventId].invisible = TRUE;
     CameraObjectSetFollowedObjectId(gObjectEvents[objectEventId].spriteId);
 }
@@ -326,7 +335,7 @@ void RemoveCameraObject(void)
     RemoveObjectEventByLocalIdAndMap(127, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
 }
 
-void Special_BufferEReaderTrainerName5(void)
+void BufferEReaderTrainerName(void)
 {
     CopyEReaderTrainerName5(gStringVar1);
 }
@@ -381,7 +390,7 @@ static const u8 sSlotMachineIndices[] = {
     5
 };
 
-u8 Special_GetRandomSlotMachine(void)
+u8 GetRandomSlotMachineId(void)
 {
     u16 rval = Random() % NELEMS(sSlotMachineIndices);
     return sSlotMachineIndices[rval];
@@ -404,7 +413,7 @@ void GiveLeadMonEffortRibbon(void)
     SetMonData(&gPlayerParty[leadMonIdx], MON_DATA_EFFORT_RIBBON, &param);
 }
 
-bool8 ScrSpecial_AreLeadMonEVsMaxedOut(void)
+bool8 AreLeadMonEVsMaxedOut(void)
 {
     u8 leadMonIndex = GetLeadMonIndex();
     if (GetMonEVCount(&gPlayerParty[leadMonIndex]) >= 510)
@@ -413,9 +422,9 @@ bool8 ScrSpecial_AreLeadMonEVsMaxedOut(void)
         return FALSE;
 }
 
-bool8 Special_IsStarterFirstStageInParty(void)
+bool8 IsStarterFirstStageInParty(void)
 {
-    u16 species = GetStarterPokemon(VarGet(VAR_STARTER_MON));
+    u16 species = GetStarterSpeciesById(VarGet(VAR_STARTER_MON));
     u8 partyCount = CalculatePlayerPartyCount();
     u8 i;
     for (i = 0; i < partyCount; i++)
@@ -426,7 +435,7 @@ bool8 Special_IsStarterFirstStageInParty(void)
     return FALSE;
 }
 
-bool8 Special_IsThereRoomInAnyBoxForMorePokemon(void)
+bool8 IsThereRoomInAnyBoxForMorePokemon(void)
 {
     u16 i;
     u16 j;
@@ -441,7 +450,7 @@ bool8 Special_IsThereRoomInAnyBoxForMorePokemon(void)
     return FALSE;
 }
 
-bool8 Special_CheckPartyPokerus(void)
+bool8 IsPokerusInParty(void)
 {
     if (!CheckPartyPokerus(gPlayerParty, 0x3F))
         return FALSE;
@@ -455,7 +464,7 @@ bool8 Special_CheckPartyPokerus(void)
 #define tDuration data[3]
 #define tYtrans   data[4]
 
-void Special_ShakeScreen(void)
+void ShakeScreen(void)
 {
     /*
      * 0x8004 = x translation
@@ -518,12 +527,12 @@ u8 GetLeadMonIndex(void)
     return 0;
 }
 
-u16 Special_GetSpeciesOfPartySlot_x8004(void)
+u16 GetPartyMonSpecies(void)
 {
     return GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_SPECIES2, NULL);
 }
 
-bool8 Special_IsMonOTNameNotPlayers(void)
+bool8 IsMonOTNameNotPlayers(void)
 {
     GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_OT_NAME, gStringVar1);
     
@@ -533,7 +542,8 @@ bool8 Special_IsMonOTNameNotPlayers(void)
         return TRUE;
 }
 
-void nullsub_75(void)
+// Used to nop all the unused specials from RS
+void NullFieldSpecial(void)
 {
 
 }
@@ -545,7 +555,7 @@ void sub_80CADC4(void)
     sub_809D424();
 }
 
-void Special_SetVermilionTrashCans(void)
+void SetVermilionTrashCans(void)
 {
     u16 idx = (Random() % 15) + 1;
     gSpecialVar_0x8004 = idx;
@@ -672,10 +682,10 @@ void IncrementResortGorgeousStepCounter(void)
     }
 }
 
-void Special_SampleResortGorgeousMonAndReward(void)
+void SampleResortGorgeousMonAndReward(void)
 {
-    u16 var4036 = VarGet(VAR_RESORT_GORGEOUS_REQUESTED_MON);
-    if (var4036 == SPECIES_NONE || var4036 == 0xFFFF)
+    u16 requestedSpecies = VarGet(VAR_RESORT_GORGEOUS_REQUESTED_MON);
+    if (requestedSpecies == SPECIES_NONE || requestedSpecies == 0xFFFF)
     {
         VarSet(VAR_RESORT_GORGEOUS_REQUESTED_MON, SampleResortGorgeousMon());
         VarSet(VAR_RESORT_GORGEOUS_REWARD, SampleResortGorgeousReward());
@@ -712,7 +722,7 @@ static u16 SampleResortGorgeousReward(void)
         return sResortGorgeousDeluxeRewards[Random() % NELEMS(sResortGorgeousDeluxeRewards)];
 }
 
-bool8 Special_CheckAddCoins(void)
+bool8 CheckAddCoins(void)
 {
     if (gSpecialVar_Result + gSpecialVar_0x8006 > 9999)
         return FALSE;
@@ -769,15 +779,39 @@ static const u8 sUnused_83F5B84[] = {
 };
 
 static const u16 sElevatorWindowMetatilesGoingUp[][3] = {
-    {0x2e8, 0x2e9, 0x2ea},
-    {0x2f0, 0x2f1, 0x2f2},
-    {0x2f8, 0x2f9, 0x2fa}
+    {
+        METATILE_SilphCo_ElevatorWindow_Top0, 
+        METATILE_SilphCo_ElevatorWindow_Top1, 
+        METATILE_SilphCo_ElevatorWindow_Top2
+    },
+    {
+        METATILE_SilphCo_ElevatorWindow_Mid0, 
+        METATILE_SilphCo_ElevatorWindow_Mid1, 
+        METATILE_SilphCo_ElevatorWindow_Mid2
+    },
+    {
+        METATILE_SilphCo_ElevatorWindow_Bottom0, 
+        METATILE_SilphCo_ElevatorWindow_Bottom1, 
+        METATILE_SilphCo_ElevatorWindow_Bottom2
+    }
 };
 
 static const u16 sElevatorWindowMetatilesGoingDown[][3] = {
-    {0x2e8, 0x2ea, 0x2e9},
-    {0x2f0, 0x2f2, 0x2f1},
-    {0x2f8, 0x2fa, 0x2f9}
+    {
+        METATILE_SilphCo_ElevatorWindow_Top0, 
+        METATILE_SilphCo_ElevatorWindow_Top2, 
+        METATILE_SilphCo_ElevatorWindow_Top1
+    },
+    {
+        METATILE_SilphCo_ElevatorWindow_Mid0, 
+        METATILE_SilphCo_ElevatorWindow_Mid2, 
+        METATILE_SilphCo_ElevatorWindow_Mid1
+    },
+    {
+        METATILE_SilphCo_ElevatorWindow_Bottom0, 
+        METATILE_SilphCo_ElevatorWindow_Bottom2, 
+        METATILE_SilphCo_ElevatorWindow_Bottom1
+    }
 };
 
 static const u8 sElevatorAnimationDuration[] = {
@@ -804,7 +838,7 @@ static const u8 sElevatorWindowAnimDuration[] = {
     27
 };
 
-void Special_GetElevatorFloor(void)
+void GetElevatorFloor(void)
 {
     u16 floor = 4;
     if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F))
@@ -876,22 +910,22 @@ void Special_GetElevatorFloor(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_1F))
+    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
     {
         switch (gSaveBlock1Ptr->warp2.mapNum)
         {
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_1F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_2F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_3F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_4F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_5F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_6F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_7F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_8F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_ROOF):
+        case MAP_NUM(TRAINER_TOWER_1F):
+        case MAP_NUM(TRAINER_TOWER_2F):
+        case MAP_NUM(TRAINER_TOWER_3F):
+        case MAP_NUM(TRAINER_TOWER_4F):
+        case MAP_NUM(TRAINER_TOWER_5F):
+        case MAP_NUM(TRAINER_TOWER_6F):
+        case MAP_NUM(TRAINER_TOWER_7F):
+        case MAP_NUM(TRAINER_TOWER_8F):
+        case MAP_NUM(TRAINER_TOWER_ROOF):
             floor = 15;
             break;
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY):
+        case MAP_NUM(TRAINER_TOWER_LOBBY):
             floor = 3;
             break;
         }
@@ -899,7 +933,7 @@ void Special_GetElevatorFloor(void)
     VarSet(VAR_ELEVATOR_FLOOR, floor);
 }
 
-u16 Special_InitElevatorFloorSelectMenuPos(void)
+u16 InitElevatorFloorSelectMenuPos(void)
 {
     sElevatorScroll = 0;
     sElevatorCursorPos = 0;
@@ -992,23 +1026,23 @@ u16 Special_InitElevatorFloorSelectMenuPos(void)
             break;
         }
     }
-    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_1F))
+    if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F))
     {
         switch (gSaveBlock1Ptr->warp2.mapNum)
         {
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_1F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_2F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_3F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_4F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_5F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_6F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_7F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_8F):
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_ROOF):
+        case MAP_NUM(TRAINER_TOWER_1F):
+        case MAP_NUM(TRAINER_TOWER_2F):
+        case MAP_NUM(TRAINER_TOWER_3F):
+        case MAP_NUM(TRAINER_TOWER_4F):
+        case MAP_NUM(TRAINER_TOWER_5F):
+        case MAP_NUM(TRAINER_TOWER_6F):
+        case MAP_NUM(TRAINER_TOWER_7F):
+        case MAP_NUM(TRAINER_TOWER_8F):
+        case MAP_NUM(TRAINER_TOWER_ROOF):
             sElevatorScroll = 0;
             sElevatorCursorPos = 0;
             break;
-        case MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY):
+        case MAP_NUM(TRAINER_TOWER_LOBBY):
             sElevatorScroll = 0;
             sElevatorCursorPos = 1;
             break;
@@ -1017,7 +1051,7 @@ u16 Special_InitElevatorFloorSelectMenuPos(void)
     return sElevatorCursorPos;
 }
 
-void Special_AnimateElevator(void)
+void AnimateElevator(void)
 {
     u16 nfloors;
     s16 *data = gTasks[CreateTask(Task_ElevatorShake, 9)].data;
@@ -1062,7 +1096,7 @@ static void Task_ElevatorShake(u8 taskId)
     }
 }
 
-void Special_DrawElevatorCurrentFloorWindow(void)
+void DrawElevatorCurrentFloorWindow(void)
 {
     const u8 *floorname;
     u32 strwidth;
@@ -1080,7 +1114,7 @@ void Special_DrawElevatorCurrentFloorWindow(void)
     }
 }
 
-void Special_CloseElevatorCurrentFloorWindow(void)
+void CloseElevatorCurrentFloorWindow(void)
 {
     ClearStdWindowAndFrameToTransparent(sElevatorCurrentFloorWindowId, TRUE);
     RemoveWindow(sElevatorCurrentFloorWindowId);
@@ -1113,7 +1147,7 @@ static void Task_AnimateElevatorWindowView(u8 taskId)
             {
                 for (j = 0; j < 3; j++)
                 {
-                    MapGridSetMetatileIdAt(j + 8, i + 7, sElevatorWindowMetatilesGoingUp[i][data[0] % 3] | 0xC00);
+                    MapGridSetMetatileIdAt(j + 8, i + 7, sElevatorWindowMetatilesGoingUp[i][data[0] % 3] | METATILE_COLLISION_MASK);
                 }
             }
         }
@@ -1123,7 +1157,7 @@ static void Task_AnimateElevatorWindowView(u8 taskId)
             {
                 for (j = 0; j < 3; j++)
                 {
-                    MapGridSetMetatileIdAt(j + 8, i + 7, sElevatorWindowMetatilesGoingDown[i][data[0] % 3] | 0xC00);
+                    MapGridSetMetatileIdAt(j + 8, i + 7, sElevatorWindowMetatilesGoingDown[i][data[0] % 3] | METATILE_COLLISION_MASK);
                 }
             }
         }
@@ -1135,7 +1169,7 @@ static void Task_AnimateElevatorWindowView(u8 taskId)
     data[1]++;
 }
 
-void Special_ListMenu(void)
+void ListMenu(void)
 {
     u8 taskId;
     struct Task * task;
@@ -1439,7 +1473,7 @@ static void Task_SuspendListMenu(u8 taskId)
     }
 }
 
-void Special_ReturnToListMenu(void)
+void ReturnToListMenu(void)
 {
     u8 taskId = FindTaskIdByFunc(Task_SuspendListMenu);
     if (taskId == 0xFF)
@@ -1483,31 +1517,31 @@ static void Task_ListMenuRemoveScrollIndicatorArrowPair(u8 taskId)
         RemoveScrollIndicatorArrowPair(task->data[12]);
 }
 
-void Special_ForcePlayerToStartSurfing(void)
+void ForcePlayerToStartSurfing(void)
 {
-    HelpSystem_SetSomeVariable2(22);
+    SetHelpContext(HELPCONTEXT_SURFING);
     SetPlayerAvatarTransitionFlags(8);
 }
 
-static const u16 sStarterMon[] = {
+static const u16 sStarterSpecies[] = {
     SPECIES_BULBASAUR,
     SPECIES_SQUIRTLE,
     SPECIES_CHARMANDER
 };
 
-static u16 GetStarterPokemon(u16 idx)
+static u16 GetStarterSpeciesById(u16 idx)
 {
-    if (idx >= NELEMS(sStarterMon))
+    if (idx >= NELEMS(sStarterSpecies))
         idx = 0;
-    return sStarterMon[idx];
+    return sStarterSpecies[idx];
 }
 
-u16 ScrSpecial_GetStarter(void)
+u16 GetStarterSpecies(void)
 {
-    return GetStarterPokemon(VarGet(VAR_STARTER_MON));
+    return GetStarterSpeciesById(VarGet(VAR_STARTER_MON));
 }
 
-void Special_SetSeenMon(void)
+void SetSeenMon(void)
 {
     GetSetPokedexFlag(SpeciesToNationalPokedexNum(gSpecialVar_0x8004), 2);
 }
@@ -1528,8 +1562,8 @@ u8 ContextNpcGetTextColor(void)
     else
     {
         gfxId = gObjectEvents[gSelectedObjectEvent].graphicsId;
-        if (gfxId >= OBJECT_EVENT_GFX_VAR_0)
-            gfxId = VarGetObjectEventGraphicsId(gfxId - OBJECT_EVENT_GFX_VAR_0);
+        if (gfxId >= OBJ_EVENT_GFX_VAR_0)
+            gfxId = VarGetObjectEventGraphicsId(gfxId - OBJ_EVENT_GFX_VAR_0);
         return GetColorFromTextColorTable(gfxId);
     }
 }
@@ -1548,7 +1582,7 @@ static bool8 HasMonBeenRenamed(u8 idx)
         return FALSE;
 }
 
-bool8 Special_HasLeadMonBeenRenamed(void)
+bool8 HasLeadMonBeenRenamed(void)
 {
     return HasMonBeenRenamed(GetLeadMonIndex());
 }
@@ -1604,7 +1638,7 @@ void ChangeBoxPokemonNickname(void)
     species = GetBoxMonData(pokemon, MON_DATA_SPECIES, NULL);
     gender = GetBoxMonGender(pokemon);
     personality = GetBoxMonData(pokemon, MON_DATA_PERSONALITY, NULL);
-    DoNamingScreen(3, gStringVar2, species, gender, personality, ChangeBoxPokemonNickname_CB);
+    DoNamingScreen(NAMING_SCREEN_NAME_RATER, gStringVar2, species, gender, personality, ChangeBoxPokemonNickname_CB);
 }
 
 static void ChangeBoxPokemonNickname_CB(void)
@@ -1624,7 +1658,7 @@ void ChangePokemonNickname(void)
     species = GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_SPECIES, NULL);
     gender = GetMonGender(&gPlayerParty[gSpecialVar_0x8004]);
     personality = GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_PERSONALITY, NULL);
-    DoNamingScreen(3, gStringVar2, species, gender, personality, ChangePokemonNickname_CB);
+    DoNamingScreen(NAMING_SCREEN_NAME_RATER, gStringVar2, species, gender, personality, ChangePokemonNickname_CB);
 }
 
 static void ChangePokemonNickname_CB(void)
@@ -1633,13 +1667,13 @@ static void ChangePokemonNickname_CB(void)
     CB2_ReturnToFieldContinueScriptPlayMapMusic();
 }
 
-void Special_GetMonNickname(void)
+void BufferMonNickname(void)
 {
     GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_NICKNAME, gStringVar1);
     StringGetEnd10(gStringVar1);
 }
 
-void Special_IsMonOTIDNotPlayers(void)
+void IsMonOTIDNotPlayers(void)
 {
     if (GetPlayerTrainerId() == GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_OT_ID, NULL))
         gSpecialVar_Result = FALSE;
@@ -1672,7 +1706,7 @@ u8 GetUnlockedSeviiAreas(void)
     return result;
 }
 
-void Special_UpdateTrainerCardPhotoIcons(void)
+void UpdateTrainerCardPhotoIcons(void)
 {
     u16 species[PARTY_SIZE];
     u32 personality[PARTY_SIZE];
@@ -1695,7 +1729,7 @@ void Special_UpdateTrainerCardPhotoIcons(void)
     VarSet(VAR_TRAINER_CARD_MON_ICON_TINT_IDX, gSpecialVar_0x8004);
 }
 
-u16 Special_StickerLadyGetBragFlags(void)
+u16 StickerManGetBragFlags(void)
 {
     u16 result = 0;
     u32 numEggs;
@@ -1729,7 +1763,7 @@ u16 GetHiddenItemAttr(u32 hiddenItem, u8 attr)
         return 1;
 }
 
-bool8 Special_PlayerPartyContainsSpecies(void)
+bool8 DoesPlayerPartyContainSpecies(void)
 {
     u8 partyCount = CalculatePlayerPartyCount();
     u8 i;
@@ -1756,7 +1790,7 @@ static const u8 sMartMaps[][3] = {
     {MAP_GROUP(SIX_ISLAND_MART),      MAP_NUM(SIX_ISLAND_MART),      1}
 };
 
-u8 Special_GetMartClerkObjectId(void)
+u8 GetMartClerkObjectId(void)
 {
     u8 i;
     for (i = 0; i < NELEMS(sMartMaps); i++)
@@ -1915,20 +1949,20 @@ void sub_80CC59C(void)
     }
 }
 
-u16 Special_BattleCardAction(void)
+u16 BattleCardAction(void)
 {
     switch (gSpecialVar_Result)
     {
     case 0:
-        return sub_81445C0(3);
+        return MEvent_GetBattleCardCount(3);
     case 1:
-        return sub_81445C0(4);
+        return MEvent_GetBattleCardCount(4);
     case 2:
-        return sub_81445C0(0);
+        return MEvent_GetBattleCardCount(0);
     case 3:
-        return sub_81445C0(1);
+        return MEvent_GetBattleCardCount(1);
     case 4:
-        return sub_81445C0(2);
+        return MEvent_GetBattleCardCount(2);
     default:
         AGB_ASSERT_EX(0, ABSPATH("scr_tool.c"), 3873);
         return 0;
@@ -2016,7 +2050,7 @@ bool8 sub_80CC87C(void)
     return FALSE;
 }
 
-bool8 Special_ItemIsTM_GetMoveName(void)
+bool8 BufferTMHMMoveName(void)
 {
     // 8004 = item ID
     if (gSpecialVar_0x8004 >= ITEM_TM01 && gSpecialVar_0x8004 <= ITEM_HM08)
@@ -2035,7 +2069,7 @@ void RunMassageCooldownStepCounter(void)
         VarSet(VAR_MASSAGE_COOLDOWN_STEP_COUNTER, count + 1);
 }
 
-void Special_DaisyMassageServices(void)
+void DaisyMassageServices(void)
 {
     AdjustFriendship(&gPlayerParty[gSpecialVar_0x8004], 6);
     VarSet(VAR_MASSAGE_COOLDOWN_STEP_COUNTER, 0);
@@ -2093,7 +2127,7 @@ static const u8 sChampionRoomLightingTimers[] = {
      8
 };
 
-void Special_PokemonLeagueLightingEffect(void)
+void DoPokemonLeagueLightingEffect(void)
 {
     u8 taskId = CreateTask(Task_RunPokemonLeagueLightingEffect, 8);
     s16 *data = gTasks[taskId].data;
@@ -2183,36 +2217,36 @@ static const u8 sCapeBrinkCompatibleSpecies[] = {
     SPECIES_BLASTOISE
 };
 
-bool8 Special_CapeBrinkGetMoveToTeachLeadPokemon(void)
+bool8 CapeBrinkGetMoveToTeachLeadPokemon(void)
 {
     // Returns:
     //   8005 = Move tutor index
     //   8006 = Num moves known by lead mon
     //   8007 = Index of lead mon
     //   to specialvar = whether a move can be taught in the first place
-    u8 r7 = 0;
-    u8 r6 = 0;
-    u8 r8 = GetLeadMonIndex();
-    u8 r4;
-    gSpecialVar_0x8007 = r8;
-    for (r4 = 0; r4 < NELEMS(sCapeBrinkCompatibleSpecies); r4++)
-    {
-        if (GetMonData(&gPlayerParty[r8], MON_DATA_SPECIES2, NULL) == sCapeBrinkCompatibleSpecies[r4])
+    u8 tutorMonId = 0;
+    u8 numMovesKnown = 0;
+    u8 leadMonSlot = GetLeadMonIndex();
+    u8 i;
+    gSpecialVar_0x8007 = leadMonSlot;
+    for (i = 0; i < NELEMS(sCapeBrinkCompatibleSpecies); i++)
+    {
+        if (GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_SPECIES2, NULL) == sCapeBrinkCompatibleSpecies[i])
         {
-            r7 = r4;
+            tutorMonId = i;
             break;
         }
     }
-    if (r4 == NELEMS(sCapeBrinkCompatibleSpecies) || GetMonData(&gPlayerParty[r8], MON_DATA_FRIENDSHIP) != 255)
+    if (i == NELEMS(sCapeBrinkCompatibleSpecies) || GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_FRIENDSHIP) != 255)
         return FALSE;
-    if (r7 == 0)
+    if (tutorMonId == 0)
     {
         StringCopy(gStringVar2, gMoveNames[MOVE_FRENZY_PLANT]);
         gSpecialVar_0x8005 = MOVETUTOR_FRENZY_PLANT;
         if (FlagGet(FLAG_TUTOR_FRENZY_PLANT) == TRUE)
             return FALSE;
     }
-    else if (r7 == 1)
+    else if (tutorMonId == 1)
     {
         StringCopy(gStringVar2, gMoveNames[MOVE_BLAST_BURN]);
         gSpecialVar_0x8005 = MOVETUTOR_BLAST_BURN;
@@ -2226,21 +2260,21 @@ bool8 Special_CapeBrinkGetMoveToTeachLeadPokemon(void)
         if (FlagGet(FLAG_TUTOR_HYDRO_CANNON) == TRUE)
             return FALSE;
     }
-    if (GetMonData(&gPlayerParty[r8], MON_DATA_MOVE1) != MOVE_NONE)
-        r6++;
-    if (GetMonData(&gPlayerParty[r8], MON_DATA_MOVE2) != MOVE_NONE)
-        r6++;
-    if (GetMonData(&gPlayerParty[r8], MON_DATA_MOVE3) != MOVE_NONE)
-        r6++;
-    if (GetMonData(&gPlayerParty[r8], MON_DATA_MOVE4) != MOVE_NONE)
-        r6++;
-    gSpecialVar_0x8006 = r6;
+    if (GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_MOVE1) != MOVE_NONE)
+        numMovesKnown++;
+    if (GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_MOVE2) != MOVE_NONE)
+        numMovesKnown++;
+    if (GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_MOVE3) != MOVE_NONE)
+        numMovesKnown++;
+    if (GetMonData(&gPlayerParty[leadMonSlot], MON_DATA_MOVE4) != MOVE_NONE)
+        numMovesKnown++;
+    gSpecialVar_0x8006 = numMovesKnown;
     return TRUE;
 }
 
-bool8 Special_HasLearnedAllMovesFromCapeBrinkTutor(void)
+bool8 HasLearnedAllMovesFromCapeBrinkTutor(void)
 {
-    // 8005 is set by Special_CapeBrinkGetMoveToTeachLeadPokemon
+    // 8005 is set by CapeBrinkGetMoveToTeachLeadPokemon
     u8 r4 = 0;
     if (gSpecialVar_0x8005 == MOVETUTOR_FRENZY_PLANT)
         FlagSet(FLAG_TUTOR_FRENZY_PLANT);
@@ -2276,7 +2310,7 @@ bool8 CutMoveRuinValleyCheck(void)
 
 void CutMoveOpenDottedHoleDoor(void)
 {
-    MapGridSetMetatileIdAt(31, 31, 0x358);
+    MapGridSetMetatileIdAt(31, 31, METATILE_SeviiIslands67_DottedHoleDoor_Open);
     DrawWholeMapView();
     PlaySE(SE_BAN);
     FlagSet(FLAG_USED_CUT_ON_RUIN_VALLEY_BRAILLE);
@@ -2324,12 +2358,12 @@ static const u8 sDeoxysStepCaps[] = {
     3
 };
 
-void DoDeoxysRockInteraction(void)
+void DoDeoxysTriangleInteraction(void)
 {
-    CreateTask(Task_DoDeoxysRockInteraction, 8);
+    CreateTask(Task_DoDeoxysTriangleInteraction, 8);
 }
 
-static void Task_DoDeoxysRockInteraction(u8 taskId)
+static void Task_DoDeoxysTriangleInteraction(u8 taskId)
 {
     u16 r5;
     u16 r6;
@@ -2389,13 +2423,13 @@ static void MoveDeoxysObject(u8 num)
         gFieldEffectArguments[5] = 60;
     else
         gFieldEffectArguments[5] = 5;
-    FieldEffectStart(FLDEFF_UNK_43);
+    FieldEffectStart(FLDEFF_MOVE_DEOXYS_ROCK);
     Overworld_SetMapObjTemplateCoords(1, sDeoxysCoords[num][0], sDeoxysCoords[num][1]);
 }
 
 static void Task_WaitDeoxysFieldEffect(u8 taskId)
 {
-    if (!FieldEffectActiveListContains(FLDEFF_UNK_43))
+    if (!FieldEffectActiveListContains(FLDEFF_MOVE_DEOXYS_ROCK))
     {
         EnableBothScriptContexts();
         DestroyTask(taskId);
@@ -2415,14 +2449,14 @@ void BirthIslandDeoxysStepCounter(void)
     }
 }
 
-void Special_SetDeoxysTriangleObjectPal(void)
+void SetDeoxysTrianglePalette(void)
 {
     u8 num = VarGet(VAR_DEOXYS_INTERACTION_NUM);
     LoadPalette(sDeoxysObjectPals[num], 0x1A0, 0x08);
     sub_8083598(10);
 }
 
-bool8 Special_BadEggInParty(void)
+bool8 IsBadEggInParty(void)
 {
     u8 partyCount = CalculatePlayerPartyCount();
     u8 i;
@@ -2434,15 +2468,15 @@ bool8 Special_BadEggInParty(void)
     return FALSE;
 }
 
-bool8 Special_PlayerIsNotInTrainerTowerLobby(void)
+bool8 IsPlayerNotInTrainerTowerLobby(void)
 {
-    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_LOBBY) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY))
+    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(TRAINER_TOWER_LOBBY) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_LOBBY))
         return FALSE;
     else
         return TRUE;
 }
 
-void Special_BrailleCursorToggle(void)
+void BrailleCursorToggle(void)
 {
     // 8004 = x - 27
     // 8005 = y
@@ -2458,14 +2492,15 @@ void Special_BrailleCursorToggle(void)
     }
 }
 
-bool8 Special_PlayerPartyContainsSpeciesWithPlayerID(void)
+bool8 PlayerPartyContainsSpeciesWithPlayerID(void)
 {
     // 8004 = species
     u8 playerCount = CalculatePlayerPartyCount();
     u8 i;
     for (i = 0; i < playerCount; i++)
     {
-        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2, NULL) == gSpecialVar_0x8004 && GetPlayerTrainerId() == GetMonData(&gPlayerParty[i], MON_DATA_OT_ID, NULL))
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2, NULL) == gSpecialVar_0x8004 
+            && GetPlayerTrainerId() == GetMonData(&gPlayerParty[i], MON_DATA_OT_ID, NULL))
             return TRUE;
     }
     return FALSE;
@@ -2475,7 +2510,7 @@ bool8 Special_PlayerPartyContainsSpeciesWithPlayerID(void)
  * Determines which of Lorelei's doll collection to show
  * based on how many times you've entered the Hall of Fame.
  */
-void Special_ComputeLoreleiDollCollection(void)
+void UpdateLoreleiDollCollection(void)
 {
     u32 numHofClears = GetGameStat(GAME_STAT_ENTERED_HOF);
     if (numHofClears >= 25)
@@ -2498,7 +2533,7 @@ void Special_ComputeLoreleiDollCollection(void)
     }
 }
 
-void Special_LoopWingFlapSound(void)
+void LoopWingFlapSound(void)
 {
     // 8004 = Num flaps
     // 8005 = Frame delay between flaps
diff --git a/src/field_tasks.c b/src/field_tasks.c
index c64fb1924..6bd4b6f46 100644
--- a/src/field_tasks.c
+++ b/src/field_tasks.c
@@ -11,10 +11,14 @@
 #include "script.h"
 #include "sound.h"
 #include "task.h"
+#include "constants/field_tasks.h"
 #include "constants/flags.h"
+#include "constants/metatile_labels.h"
 #include "constants/songs.h"
 #include "constants/vars.h"
 
+// TODO: Metatile IDs in this file
+
 static void DummyPerStepCallback(u8 taskId);
 static void AshGrassPerStepCallback(u8 taskId);
 static void IcefallCaveIcePerStepCallback(u8 taskId);
@@ -22,27 +26,27 @@ static void CrackedFloorPerStepCallback(u8 taskId);
 
 static const TaskFunc sPerStepCallbacks[] =
 {
-    DummyPerStepCallback,
-    AshGrassPerStepCallback,
-    DummyPerStepCallback,
-    DummyPerStepCallback,
-    IcefallCaveIcePerStepCallback,
-    DummyPerStepCallback,
-    DummyPerStepCallback,
-    CrackedFloorPerStepCallback
+    [STEP_CB_DUMMY]             = DummyPerStepCallback,
+    [STEP_CB_ASH]               = AshGrassPerStepCallback,
+    [STEP_CB_FORTREE_BRIDGE]    = DummyPerStepCallback,
+    [STEP_CB_PACIFIDLOG_BRIDGE] = DummyPerStepCallback,
+    [STEP_CB_ICE]               = IcefallCaveIcePerStepCallback,
+    [STEP_CB_TRUCK]             = DummyPerStepCallback,
+    [STEP_CB_SECRET_BASE]       = DummyPerStepCallback,
+    [STEP_CB_CRACKED_FLOOR]     = CrackedFloorPerStepCallback
 };
 
 static const u8 sIcefallCaveIceTileCoords[][2] =
 {
-    { 0x08, 0x03 },
-    { 0x0a, 0x05 },
-    { 0x0f, 0x05 },
-    { 0x08, 0x09 },
-    { 0x09, 0x09 },
-    { 0x10, 0x09 },
-    { 0x08, 0x0a },
-    { 0x09, 0x0a },
-    { 0x08, 0x0e }
+    {  8,  3 },
+    { 10,  5 },
+    { 15,  5 },
+    {  8,  9 },
+    {  9,  9 },
+    { 16,  9 },
+    {  8, 10 },
+    {  9, 10 },
+    {  8, 14 }
 };
 
 static void Task_RunPerStepCallback(u8 taskId)
@@ -134,7 +138,7 @@ static void MarkIcefallCaveCoordVisited(s16 x, s16 y)
     }
 }
 
-void Special_SetIcefallCaveCrackedIceMetatiles(void)
+void SetIcefallCaveCrackedIceMetatiles(void)
 {
     u8 i = 0;
     for (; i < NELEMS(sIcefallCaveIceTileCoords); ++i)
@@ -143,7 +147,7 @@ void Special_SetIcefallCaveCrackedIceMetatiles(void)
         {
             int x = sIcefallCaveIceTileCoords[i][0] + 7;
             int y = sIcefallCaveIceTileCoords[i][1] + 7;
-            MapGridSetMetatileIdAt(x, y, 0x35a);
+            MapGridSetMetatileIdAt(x, y, METATILE_SeafoamIslands_CrackedIce);
         }
     }
 }
@@ -196,7 +200,7 @@ static void IcefallCaveIcePerStepCallback(u8 taskId)
                 x = data[4];
                 y = data[5];
                 PlaySE(SE_RU_BARI);
-                MapGridSetMetatileIdAt(x, y, 0x35a);
+                MapGridSetMetatileIdAt(x, y, METATILE_SeafoamIslands_CrackedIce);
                 CurrentMapDrawMetatileAt(x, y);
                 data[1] = 1;
             }
@@ -211,7 +215,7 @@ static void IcefallCaveIcePerStepCallback(u8 taskId)
                 x = data[4];
                 y = data[5];
                 PlaySE(SE_RU_GASYAN);
-                MapGridSetMetatileIdAt(x, y, 0x35b);
+                MapGridSetMetatileIdAt(x, y, METATILE_SeafoamIslands_IceHole);
                 CurrentMapDrawMetatileAt(x, y);
                 VarSet(VAR_TEMP_1, 1);
                 data[1] = 1;
diff --git a/src/fieldmap.c b/src/fieldmap.c
index d2598c3e6..3e61c6c29 100644
--- a/src/fieldmap.c
+++ b/src/fieldmap.c
@@ -3,7 +3,6 @@
 #include "palette.h"
 #include "overworld.h"
 #include "script.h"
-#include "menu.h"
 #include "new_menu_helpers.h"
 #include "quest_log.h"
 #include "fieldmap.h"
@@ -18,38 +17,39 @@ struct ConnectionFlags
     u8 east:1;
 };
 
-void sub_8058A00(struct MapHeader *mapHeader);
-void map_copy_with_padding(u16 *map, u16 width, u16 height);
-void mapheader_copy_mapdata_of_adjacent_maps(struct MapHeader *mapHeader);
-void fillSouthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
-void fillNorthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
-void fillWestConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
-void fillEastConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
-void LoadSavedMapView(void);
-struct MapConnection *sub_8059600(u8 direction, s32 x, s32 y);
-bool8 sub_8059658(u8 direction, s32 x, s32 y, struct MapConnection *connection);
-bool8 sub_80596BC(s32 x, s32 src_width, s32 dest_width, s32 offset);
+static void InitMapLayoutData(struct MapHeader *mapHeader);
+static void map_copy_with_padding(u16 *map, u16 width, u16 height);
+static void mapheader_copy_mapdata_of_adjacent_maps(struct MapHeader *mapHeader);
+static void fillSouthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
+static void fillNorthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
+static void fillWestConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
+static void fillEastConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset);
+static void LoadSavedMapView(void);
+static struct MapConnection *sub_8059600(u8 direction, s32 x, s32 y);
+static bool8 sub_8059658(u8 direction, s32 x, s32 y, struct MapConnection *connection);
+static bool8 sub_80596BC(s32 x, s32 src_width, s32 dest_width, s32 offset);
 
 struct BackupMapLayout gBackupMapLayout;
 EWRAM_DATA u16 gBackupMapData[VIRTUAL_MAP_SIZE] = {};
 EWRAM_DATA struct MapHeader gMapHeader = {};
 EWRAM_DATA struct Camera gCamera = {};
-EWRAM_DATA struct ConnectionFlags gMapConnectionFlags = {};
+static EWRAM_DATA struct ConnectionFlags gMapConnectionFlags = {};
+EWRAM_DATA u8 gUnknown_2036E28 = 0;
 
-const struct ConnectionFlags sDummyConnectionFlags = {};
+static const struct ConnectionFlags sDummyConnectionFlags = {};
 
-const u32 gUnknown_8352EF0[] = {
-    0x1ff,
-    0x3e00,
-    0x3c000,
-    0xfc0000,
-    0x7000000,
+static const u32 sMetatileAttrMasks[] = {
+    0x000001ff,
+    0x00003e00,
+    0x0003c000,
+    0x00fc0000,
+    0x07000000,
     0x18000000,
     0x60000000,
     0x80000000
 };
 
-const u8 gUnknown_8352F10[] = {
+static const u8 sMetatileAttrShifts[] = {
     0,
     9,
     14,
@@ -65,20 +65,20 @@ const struct MapHeader * mapconnection_get_mapheader(struct MapConnection * conn
     return Overworld_GetMapHeaderByGroupAndId(connection->mapGroup, connection->mapNum);
 }
 
-void not_trainer_hill_battle_pyramid(void)
+void InitMap(void)
 {
-    sub_8058A00(&gMapHeader);
-    mapheader_run_script_with_tag_x1();
+    InitMapLayoutData(&gMapHeader);
+    RunOnLoadMapScript();
 }
 
-void sub_80589E8(void)
+void InitMapFromSavedGame(void)
 {
-    sub_8058A00(&gMapHeader);
+    InitMapLayoutData(&gMapHeader);
     LoadSavedMapView();
-    mapheader_run_script_with_tag_x1();
+    RunOnLoadMapScript();
 }
 
-void sub_8058A00(struct MapHeader * mapHeader)
+static void InitMapLayoutData(struct MapHeader * mapHeader)
 {
     const struct MapLayout * mapLayout = mapHeader->mapLayout;
     CpuFastFill(0x03FF03FF, gBackupMapData, sizeof(gBackupMapData));
@@ -90,7 +90,7 @@ void sub_8058A00(struct MapHeader * mapHeader)
     mapheader_copy_mapdata_of_adjacent_maps(mapHeader);
 }
 
-void map_copy_with_padding(u16 *map, u16 width, u16 height)
+static void map_copy_with_padding(u16 *map, u16 width, u16 height)
 {
     s32 y;
     u16 *dest = gBackupMapLayout.map;
@@ -104,7 +104,7 @@ void map_copy_with_padding(u16 *map, u16 width, u16 height)
     }
 }
 
-void mapheader_copy_mapdata_of_adjacent_maps(struct MapHeader *mapHeader)
+static void mapheader_copy_mapdata_of_adjacent_maps(struct MapHeader *mapHeader)
 {
     s32 count;
     struct MapConnection *connection;
@@ -150,7 +150,7 @@ void mapheader_copy_mapdata_of_adjacent_maps(struct MapHeader *mapHeader)
     }
 }
 
-void sub_8058B54(s32 x, s32 y, const struct MapHeader *connectedMapHeader, s32 x2, s32 y2, s32 width, s32 height)
+static void sub_8058B54(s32 x, s32 y, const struct MapHeader *connectedMapHeader, s32 x2, s32 y2, s32 width, s32 height)
 {
     s32 i;
     u16 *src;
@@ -169,7 +169,7 @@ void sub_8058B54(s32 x, s32 y, const struct MapHeader *connectedMapHeader, s32 x
     }
 }
 
-void fillSouthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
+static void fillSouthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
 {
     s32 x, y;
     s32 x2;
@@ -216,7 +216,7 @@ void fillSouthConnection(struct MapHeader const *mapHeader, struct MapHeader con
     }
 }
 
-void fillNorthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
+static void fillNorthConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
 {
     s32 x;
     s32 x2, y2;
@@ -265,7 +265,7 @@ void fillNorthConnection(struct MapHeader const *mapHeader, struct MapHeader con
     }
 }
 
-void fillWestConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
+static void fillWestConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
 {
     s32 y;
     s32 x2, y2;
@@ -311,7 +311,7 @@ void fillWestConnection(struct MapHeader const *mapHeader, struct MapHeader cons
     }
 }
 
-void fillEastConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
+static void fillEastConnection(struct MapHeader const *mapHeader, struct MapHeader const *connectedMapHeader, s32 offset)
 {
     s32 x, y;
     s32 y2;
@@ -446,28 +446,28 @@ u32 MapGridGetMetatileIdAt(s32 x, s32 y)
     return block & 0x3FF;
 }
 
-u32 sub_8058F1C(u32 original, u8 bit)
+u32 GetMetatileAttributeFromRawMetatileBehavior(u32 original, u8 bit)
 {
     if (bit >= 8)
         return original;
 
-    return (original & gUnknown_8352EF0[bit]) >> gUnknown_8352F10[bit];
+    return (original & sMetatileAttrMasks[bit]) >> sMetatileAttrShifts[bit];
 }
 
-u32 sub_8058F48(s16 x, s16 y, u8 z)
+u32 MapGridGetMetatileAttributeAt(s16 x, s16 y, u8 attr)
 {
     u16 metatileId = MapGridGetMetatileIdAt(x, y);
-    return GetBehaviorByMetatileIdAndMapLayout(gMapHeader.mapLayout, metatileId, z);
+    return GetBehaviorByMetatileIdAndMapLayout(gMapHeader.mapLayout, metatileId, attr);
 }
 
 u32 MapGridGetMetatileBehaviorAt(s32 x, s32 y)
 {
-    return sub_8058F48(x, y, 0);
+    return MapGridGetMetatileAttributeAt(x, y, 0);
 }
 
 u8 MapGridGetMetatileLayerTypeAt(s16 x, s16 y)
 {
-    return sub_8058F48(x, y, 6);
+    return MapGridGetMetatileAttributeAt(x, y, 6);
 }
 
 void MapGridSetMetatileIdAt(s32 x, s32 y, u16 metatile)
@@ -492,7 +492,7 @@ void MapGridSetMetatileEntryAt(s32 x, s32 y, u16 metatile)
     }
 }
 
-void sub_8059024(s32 x, s32 y, bool32 arg2)
+void MapGridSetMetatileImpassabilityAt(s32 x, s32 y, bool32 arg2)
 {
     if (x >= 0 && x < gBackupMapLayout.Xsize
         && y >= 0 && y < gBackupMapLayout.Ysize)
@@ -515,12 +515,12 @@ u32 GetBehaviorByMetatileIdAndMapLayout(struct MapLayout *mapLayout, u16 metatil
     if (metatile < NUM_METATILES_IN_PRIMARY)
     {
         attributes = mapLayout->primaryTileset->metatileAttributes;
-        return sub_8058F1C(attributes[metatile], attr);
+        return GetMetatileAttributeFromRawMetatileBehavior(attributes[metatile], attr);
     }
     else if (metatile < 0x400)
     {
         attributes = mapLayout->secondaryTileset->metatileAttributes;
-        return sub_8058F1C(attributes[metatile - NUM_METATILES_IN_PRIMARY], attr);
+        return GetMetatileAttributeFromRawMetatileBehavior(attributes[metatile - NUM_METATILES_IN_PRIMARY], attr);
     }
     else
     {
@@ -547,7 +547,7 @@ void save_serialize_map(void)
     }
 }
 
-bool32 SavedMapViewIsEmpty(void)
+static bool32 SavedMapViewIsEmpty(void)
 {
     u16 i;
     u32 marker = 0;
@@ -562,12 +562,12 @@ bool32 SavedMapViewIsEmpty(void)
         return FALSE;
 }
 
-void ClearSavedMapView(void)
+static void ClearSavedMapView(void)
 {
     CpuFill16(0, gSaveBlock2Ptr->mapView, sizeof(gSaveBlock2Ptr->mapView));
 }
 
-void LoadSavedMapView(void)
+static void LoadSavedMapView(void)
 {
     s32 i, j;
     s32 x, y;
@@ -591,7 +591,7 @@ void LoadSavedMapView(void)
     }
 }
 
-void sub_8059250(u8 a1)
+static void sub_8059250(u8 a1)
 {
     s32 width;
     u16 *mapView;
@@ -693,7 +693,7 @@ s32 GetMapBorderIdAt(s32 x, s32 y)
     return 0;
 }
 
-s32 GetPostCameraMoveMapBorderId(s32 x, s32 y)
+static s32 GetPostCameraMoveMapBorderId(s32 x, s32 y)
 {
     return GetMapBorderIdAt(7 + gSaveBlock1Ptr->pos.x + x, 7 + gSaveBlock1Ptr->pos.y + y);
 }
@@ -711,7 +711,7 @@ bool32 CanCameraMoveInDirection(s32 direction)
     return TRUE;
 }
 
-void sub_80594AC(struct MapConnection *connection, int direction, s32 x, s32 y)
+static void sub_80594AC(struct MapConnection *connection, int direction, s32 x, s32 y)
 {
     struct MapHeader const *mapHeader;
     mapHeader = mapconnection_get_mapheader(connection);
@@ -782,7 +782,7 @@ struct MapConnection *sub_8059600(u8 direction, s32 x, s32 y)
 
 }
 
-bool8 sub_8059658(u8 direction, s32 x, s32 y, struct MapConnection *connection)
+static bool8 sub_8059658(u8 direction, s32 x, s32 y, struct MapConnection *connection)
 {
     struct MapHeader const *mapHeader;
     mapHeader = mapconnection_get_mapheader(connection);
@@ -798,7 +798,7 @@ bool8 sub_8059658(u8 direction, s32 x, s32 y, struct MapConnection *connection)
     return FALSE;
 }
 
-bool8 sub_80596BC(s32 x, s32 src_width, s32 dest_width, s32 offset)
+static bool8 sub_80596BC(s32 x, s32 src_width, s32 dest_width, s32 offset)
 {
     s32 offset2 = max(offset, 0);
 
@@ -811,7 +811,7 @@ bool8 sub_80596BC(s32 x, s32 src_width, s32 dest_width, s32 offset)
     return FALSE;
 }
 
-bool32 sub_80596E8(s32 x, s32 width)
+static bool32 sub_80596E8(s32 x, s32 width)
 {
     if (x >= 0 && x < width)
         return TRUE;
@@ -819,7 +819,7 @@ bool32 sub_80596E8(s32 x, s32 width)
     return FALSE;
 }
 
-s32 sub_80596FC(struct MapConnection *connection, s32 x, s32 y)
+static s32 sub_80596FC(struct MapConnection *connection, s32 x, s32 y)
 {
     struct MapHeader const *mapHeader;
     mapHeader = mapconnection_get_mapheader(connection);
@@ -881,7 +881,7 @@ void GetCameraFocusCoords(u16 *x, u16 *y)
     *y = gSaveBlock1Ptr->pos.y + 7;
 }
 
-void SetCameraCoords(u16 x, u16 y)
+static void SetCameraCoords(u16 x, u16 y)
 {
     gSaveBlock1Ptr->pos.x = x;
     gSaveBlock1Ptr->pos.y = y;
@@ -892,7 +892,7 @@ void GetCameraCoords(u16 *x, u16 *y)
     *x = gSaveBlock1Ptr->pos.x;
     *y = gSaveBlock1Ptr->pos.y;
 }
-void copy_tileset_patterns_to_vram(struct Tileset const *tileset, u16 numTiles, u16 offset)
+static void copy_tileset_patterns_to_vram(struct Tileset const *tileset, u16 numTiles, u16 offset)
 {
     if (tileset)
     {
@@ -903,7 +903,7 @@ void copy_tileset_patterns_to_vram(struct Tileset const *tileset, u16 numTiles,
     }
 }
 
-void copy_tileset_patterns_to_vram2(struct Tileset const *tileset, u16 numTiles, u16 offset)
+static void copy_tileset_patterns_to_vram2(struct Tileset const *tileset, u16 numTiles, u16 offset)
 {
     if (tileset)
     {
@@ -914,7 +914,7 @@ void copy_tileset_patterns_to_vram2(struct Tileset const *tileset, u16 numTiles,
     }
 }
 
-void sub_80598CC(u16 a0, u16 a1)
+static void sub_80598CC(u16 a0, u16 a1)
 {
     switch (gUnknown_2036E28)
     {
@@ -958,7 +958,7 @@ void sub_8059948(u8 a0, u8 a1)
     CpuFastCopy(gPlttBufferUnfaded + a0 * 16, gPlttBufferFaded + a0 * 16, a1 * 16 * sizeof(u16));
 }
 
-void apply_map_tileset_palette(struct Tileset const *tileset, u16 destOffset, u16 size)
+static void apply_map_tileset_palette(struct Tileset const *tileset, u16 destOffset, u16 size)
 {
     u16 black = RGB_BLACK;
 
diff --git a/src/fldeff_berrytree.c b/src/fldeff_berrytree.c
index 90ca36508..3826e1d33 100644
--- a/src/fldeff_berrytree.c
+++ b/src/fldeff_berrytree.c
@@ -1,4 +1,4 @@
-void nullsub_56(void)
+// From R/S, removed
+void DoWateringBerryTreeAnim(void)
 {
-	
 }
diff --git a/src/fldeff_cut.c b/src/fldeff_cut.c
new file mode 100644
index 000000000..8617a1aaa
--- /dev/null
+++ b/src/fldeff_cut.c
@@ -0,0 +1,299 @@
+#include "global.h"
+#include "gflib.h"
+#include "event_object_lock.h"
+#include "event_object_movement.h"
+#include "event_scripts.h"
+#include "fieldmap.h"
+#include "field_camera.h"
+#include "field_specials.h"
+#include "fldeff.h"
+#include "field_effect.h"
+#include "field_player_avatar.h"
+#include "metatile_behavior.h"
+#include "overworld.h"
+#include "party_menu.h"
+#include "script.h"
+#include "trig.h"
+#include "constants/event_objects.h"
+#include "constants/songs.h"
+#include "constants/metatile_labels.h"
+
+#define CUT_GRASS_SPRITE_COUNT 8
+
+static EWRAM_DATA u8 *sCutGrassSpriteArrayPtr = NULL;
+static EWRAM_DATA bool8 sScheduleOpenDottedHole = FALSE;
+
+static void FieldCallback_CutGrass(void);
+static void FieldCallback_CutTree(void);
+static void FieldMoveCallback_CutGrass(void);
+static void SetCutGrassMetatileAt(s16 x, s16 y);
+static void SpriteCallback_CutGrass_Init(struct Sprite * sprite);
+static void SpriteCallback_CutGrass_Run(struct Sprite * sprite);
+static void SpriteCallback_CutGrass_Cleanup(struct Sprite * sprite);
+static void FieldMoveCallback_CutTree(void);
+
+static const u16 sCutGrassMetatileMapping[][2] = {
+    {
+        METATILE_ID(General, Plain_Grass),
+        METATILE_ID(General, Plain_Mowed)
+    }, {
+        METATILE_ID(General, ThinTreeTop_Grass),
+        METATILE_ID(General, ThinTreeTop_Mowed)
+    }, {
+        METATILE_ID(General, WideTreeTopLeft_Grass),
+        METATILE_ID(General, WideTreeTopLeft_Mowed)
+    }, {
+        METATILE_ID(General, WideTreeTopRight_Grass),
+        METATILE_ID(General, WideTreeTopRight_Mowed)
+    }, {
+        METATILE_ID(CeladonCity, CyclingRoad_Grass),
+        METATILE_ID(CeladonCity, CyclingRoad_Mowed)
+    }, {
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopLeft_Grass),
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopLeft_Mowed)
+    }, {
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopMiddle_Grass),
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopMiddle_Mowed)
+    }, {
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopRight_Grass),
+        METATILE_ID(FuchsiaCity, SafariZoneTreeTopRight_Mowed)
+    }, {
+        METATILE_ID(ViridianForest, HugeTreeTopMiddle_Grass),
+        METATILE_ID(ViridianForest, HugeTreeTopMiddle_Mowed)
+    }, {
+        0xffff,
+        0xffff
+    }
+};
+
+static const struct OamData sOamData_FldEff_CutGrass = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = FALSE,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(8x8),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(8x8),
+    .tileNum = 0x001,
+    .priority = 1,
+    .paletteNum = 0x1,
+    .affineParam = 0
+};
+
+static const union AnimCmd sSpriteAnim_Fldeff_CutGrass_0[] = {
+    ANIMCMD_FRAME(0, 30),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const sSpriteAnimTable_FldEff_CutGrass[] = {
+    sSpriteAnim_Fldeff_CutGrass_0
+};
+
+static const struct SpriteFrameImage sSpriteFrameImages_FldEff_CutGrass[] = {
+    {gUnknown_8398648, 0x20}
+};
+
+const struct SpritePalette gFldEffPalette_CutGrass[] = {
+    gUnknown_8398688, 4096
+};
+
+static const struct SpriteTemplate sSpriteTemplate_FldEff_CutGrass = {
+    .tileTag = 0xFFFF,
+    .paletteTag = 4096,
+    .oam = &sOamData_FldEff_CutGrass,
+    .anims = sSpriteAnimTable_FldEff_CutGrass,
+    .images = sSpriteFrameImages_FldEff_CutGrass,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallback_CutGrass_Init
+};
+
+static u8 MetatileAtCoordsIsGrassTile(s16 x, s16 y)
+{
+    return TestMetatileAttributeBit(MapGridGetMetatileAttributeAt(x, y, 1), 1);
+}
+
+bool8 SetUpFieldMove_Cut(void)
+{
+    s16 x, y;
+    u8 i, j;
+    sScheduleOpenDottedHole = FALSE;
+    if (CutMoveRuinValleyCheck() == TRUE)
+    {
+        sScheduleOpenDottedHole = TRUE;
+        gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
+        gPostMenuFieldCallback = FieldCallback_CutGrass;
+        return TRUE;
+    }
+
+    if (CheckObjectGraphicsInFrontOfPlayer(OBJ_EVENT_GFX_CUT_TREE) == TRUE)
+    {
+        gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
+        gPostMenuFieldCallback = FieldCallback_CutTree;
+        return TRUE;
+    }
+    else
+    {
+        // FIXME: this fakematch
+        register s32 neg1 asm("r8");
+        struct MapPosition *pos;
+        PlayerGetDestCoords(&gPlayerFacingPosition.x, &gPlayerFacingPosition.y);
+
+        for (i = 0, pos = &gPlayerFacingPosition, neg1 = 0xFFFF; i < 3; i++)
+        {
+
+            y = i + neg1 + pos->y;
+            for (j = 0; j < 3; j++)
+            {
+                x = j + neg1 + pos->x;
+                if (MapGridGetZCoordAt(x, y) == pos->height)
+                {
+                    if (MetatileAtCoordsIsGrassTile(x, y) == TRUE)
+                    {
+                        gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
+                        gPostMenuFieldCallback = FieldCallback_CutGrass;
+                        return TRUE;
+                    }
+                }
+            }
+        }
+        return FALSE;
+    }
+}
+
+static void FieldCallback_CutGrass(void)
+{
+    FieldEffectStart(FLDEFF_USE_CUT_ON_GRASS);
+    gFieldEffectArguments[0] = GetCursorSelectionMonId();
+}
+
+bool8 FldEff_UseCutOnGrass(void)
+{
+    u8 taskId = CreateFieldEffectShowMon();
+    FLDEFF_SET_FUNC_TO_DATA(FieldMoveCallback_CutGrass);
+    IncrementGameStat(GAME_STAT_USED_CUT);
+    return FALSE;
+}
+
+static void FieldCallback_CutTree(void)
+{
+    gFieldEffectArguments[0] = GetCursorSelectionMonId();
+    ScriptContext1_SetupScript(EventScript_FldEffCut);
+}
+
+bool8 FldEff_UseCutOnTree(void)
+{
+    u8 taskId = CreateFieldEffectShowMon();
+    FLDEFF_SET_FUNC_TO_DATA(FieldMoveCallback_CutTree);
+    IncrementGameStat(GAME_STAT_USED_CUT);
+    return FALSE;
+}
+
+static void FieldMoveCallback_CutGrass(void)
+{
+    FieldEffectActiveListRemove(FLDEFF_USE_CUT_ON_GRASS);
+    if (sScheduleOpenDottedHole == TRUE)
+        CutMoveOpenDottedHoleDoor();
+    else
+        FieldEffectStart(FLDEFF_CUT_GRASS);
+}
+
+bool8 FldEff_CutGrass(void)
+{
+    u8 i, j;
+    s16 x, y;
+    // FIXME: this fakematch
+    register s32 neg1 asm("r9");
+    struct MapPosition *pos;
+
+    i = 0;
+    PlaySE(SE_W015);
+    PlayerGetDestCoords(&gPlayerFacingPosition.x, &gPlayerFacingPosition.y);
+
+    for (i = 0, pos = &gPlayerFacingPosition, neg1 = 0xFFFF; i < 3; i++)
+    {
+
+        y = i + neg1 + pos->y;
+        for (j = 0; j < 3; j++)
+        {
+            x = j + neg1 + pos->x;
+            if (MapGridGetZCoordAt(x, y) == pos->height)
+            {
+                if (MetatileAtCoordsIsGrassTile(x, y) == TRUE)
+                {
+                    SetCutGrassMetatileAt(x, y);
+                    sub_805F378(x, y);
+                }
+            }
+        }
+    }
+    DrawWholeMapView();
+    sCutGrassSpriteArrayPtr = Alloc(CUT_GRASS_SPRITE_COUNT);
+    for (i = 0; i < 8; i++)
+    {
+        sCutGrassSpriteArrayPtr[i] = CreateSprite(&sSpriteTemplate_FldEff_CutGrass, gSprites[gPlayerAvatar.spriteId].oam.x + 8, gSprites[gPlayerAvatar.spriteId].oam.y + 20, 0);
+        gSprites[sCutGrassSpriteArrayPtr[i]].data[2] = i * (0x100 / CUT_GRASS_SPRITE_COUNT);
+    }
+    return FALSE;
+}
+
+static void SetCutGrassMetatileAt(s16 x, s16 y)
+{
+    u16 i = 0;
+    u16 metatileId = MapGridGetMetatileIdAt(x, y);
+    while (1)
+    {
+        if (sCutGrassMetatileMapping[i][0] == 0xFFFF)
+            return;
+        if (sCutGrassMetatileMapping[i][0] == metatileId)
+        {
+            MapGridSetMetatileIdAt(x, y, sCutGrassMetatileMapping[i][1]);
+            break;
+        }
+        i++;
+    }
+}
+
+static void SpriteCallback_CutGrass_Init(struct Sprite * sprite)
+{
+    sprite->data[0] = 8;
+    sprite->data[1] = 0;
+    sprite->data[3] = 0;
+    sprite->callback = SpriteCallback_CutGrass_Run;
+}
+
+static void SpriteCallback_CutGrass_Run(struct Sprite * sprite)
+{
+    sprite->pos2.x = Sin(sprite->data[2], sprite->data[0]);
+    sprite->pos2.y = Cos(sprite->data[2], sprite->data[0]);
+    sprite->data[2] += 8;
+    sprite->data[2] &= 0xFF;
+    sprite->data[0]++;
+    sprite->data[0] += sprite->data[3] >> 2;
+    sprite->data[3]++;
+    if (sprite->data[1] != 28)
+        sprite->data[1]++;
+    else
+        sprite->callback = SpriteCallback_CutGrass_Cleanup;
+}
+
+static void SpriteCallback_CutGrass_Cleanup(struct Sprite * sprite)
+{
+    u8 i;
+    for (i = 1; i < CUT_GRASS_SPRITE_COUNT; i++)
+    {
+        DestroySprite(&gSprites[sCutGrassSpriteArrayPtr[i]]);
+    }
+    FieldEffectStop(&gSprites[sCutGrassSpriteArrayPtr[0]], FLDEFF_CUT_GRASS);
+    Free(sCutGrassSpriteArrayPtr);
+    sub_80696C0();
+    ScriptContext2_Disable();
+}
+
+static void FieldMoveCallback_CutTree(void)
+{
+    PlaySE(SE_W015);
+    FieldEffectActiveListRemove(FLDEFF_USE_CUT_ON_TREE);
+    EnableBothScriptContexts();
+}
diff --git a/src/fldeff_dig.c b/src/fldeff_dig.c
index 7d229ce3f..0eb0d3c1e 100644
--- a/src/fldeff_dig.c
+++ b/src/fldeff_dig.c
@@ -5,8 +5,6 @@
 #include "item_use.h"
 #include "overworld.h"
 #include "party_menu.h"
-#include "sprite.h"
-#include "constants/object_events.h"
 
 static void FieldCallback_Dig(void);
 static void sub_80C9AFC(void);
@@ -31,7 +29,7 @@ static void FieldCallback_Dig(void)
 
 bool8 FldEff_UseDig(void)
 {
-    u8 taskId = oei_task_add();
+    u8 taskId = CreateFieldEffectShowMon();
 
     FLDEFF_SET_FUNC_TO_DATA(sub_80C9AFC);
     SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT);
diff --git a/src/fldeff_flash.c b/src/fldeff_flash.c
new file mode 100644
index 000000000..58cb4c251
--- /dev/null
+++ b/src/fldeff_flash.c
@@ -0,0 +1,479 @@
+#include "global.h"
+#include "gflib.h"
+#include "event_data.h"
+#include "event_scripts.h"
+#include "fldeff.h"
+#include "field_effect.h"
+#include "map_preview_screen.h"
+#include "overworld.h"
+#include "party_menu.h"
+#include "script.h"
+#include "constants/songs.h"
+#include "constants/map_types.h"
+
+struct FlashStruct
+{
+    u8 fromType;
+    u8 toType;
+    bool8 isEnter;
+    bool8 isExit;
+    void (*func1)(void);
+    void (*func2)(u8 mapSecId);
+};
+
+static void FieldCallback_Flash(void);
+static void FldEff_UseFlash(void);
+static bool8 TryDoMapTransition(void);
+static void FlashTransition_Exit(void);
+static void Task_FlashTransition_Exit_0(u8 taskId);
+static void Task_FlashTransition_Exit_1(u8 taskId);
+static void Task_FlashTransition_Exit_2(u8 taskId);
+static void Task_FlashTransition_Exit_3(u8 taskId);
+static void Task_FlashTransition_Exit_4(u8 taskId);
+static void FlashTransition_Enter(void);
+static void Task_FlashTransition_Enter_0(u8 taskId);
+static void Task_FlashTransition_Enter_1(u8 taskId);
+static void Task_FlashTransition_Enter_2(u8 taskId);
+static void Task_FlashTransition_Enter_3(u8 taskId);
+static void RunMapPreviewScreen(u8 mapsecId);
+static void Task_MapPreviewScreen_0(u8 taskId);
+
+static const struct FlashStruct sTransitionTypes[] = {
+    {
+        .fromType = MAP_TYPE_TOWN,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_CITY,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_ROUTE,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERWATER,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_OCEAN_ROUTE,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNKNOWN,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_INDOOR,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_SECRET_BASE,
+        .toType = MAP_TYPE_UNDERGROUND,
+        .isEnter = TRUE,
+        .isExit = FALSE,
+        .func1 = FlashTransition_Enter,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_TOWN,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_CITY,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_ROUTE,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_UNDERWATER,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_OCEAN_ROUTE,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_UNKNOWN,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_INDOOR,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {
+        .fromType = MAP_TYPE_UNDERGROUND,
+        .toType = MAP_TYPE_SECRET_BASE,
+        .isEnter = FALSE,
+        .isExit = TRUE,
+        .func1 = FlashTransition_Exit,
+        .func2 = RunMapPreviewScreen
+    }, {0}
+};
+
+static const u16 sCaveTransitionPalette_White[] = INCBIN_U16("graphics/field_effects/flash_white.gbapal");
+static const u16 sCaveTransitionPalette_Black[] = INCBIN_U16("graphics/field_effects/flash_black.gbapal");
+static const u16 sCaveTransitionPalette_Gradient[] = INCBIN_U16("graphics/field_effects/flash_gradient.gbapal");
+static const u32 sCaveTransitionTilemap[] = INCBIN_U32("graphics/field_effects/flash_effect_map.bin.lz");
+static const u32 sCaveTransitionTiles[] = INCBIN_U32("graphics/field_effects/flash_effect_tiles.4bpp.lz");
+
+bool8 SetUpFieldMove_Flash(void)
+{
+    if (gMapHeader.cave != TRUE)
+        return FALSE;
+
+    if (FlagGet(FLAG_SYS_FLASH_ACTIVE))
+        return FALSE;
+
+    gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
+    gPostMenuFieldCallback = FieldCallback_Flash;
+    return TRUE;
+}
+
+static void FieldCallback_Flash(void)
+{
+    u8 taskId = CreateFieldEffectShowMon();
+    gFieldEffectArguments[0] = GetCursorSelectionMonId();
+    gTasks[taskId].data[8] = ((uintptr_t)FldEff_UseFlash) >> 16;
+    gTasks[taskId].data[9] = ((uintptr_t)FldEff_UseFlash);
+}
+
+static void FldEff_UseFlash(void)
+{
+    PlaySE(SE_W115);
+    FlagSet(FLAG_SYS_FLASH_ACTIVE);
+    ScriptContext1_SetupScript(EventScript_FldEffFlash);
+}
+
+// Map transition animatics
+
+static void CB2_ChangeMapMain(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void VBC_ChangeMapVBlank(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void CB2_DoChangeMap(void)
+{
+    SetVBlankCallback(NULL);
+
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    SetGpuReg(REG_OFFSET_BG2CNT, 0);
+    SetGpuReg(REG_OFFSET_BG1CNT, 0);
+    SetGpuReg(REG_OFFSET_BG0CNT, 0);
+    SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+
+    DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE);
+    DmaFill32(3, 0, (void *)OAM, OAM_SIZE);
+    DmaFill16(3, 0, (void *)(PLTT + 2), PLTT_SIZE - 2);
+    ResetPaletteFade();
+    ResetTasks();
+    ResetSpriteData();
+    EnableInterrupts(INTR_FLAG_VBLANK);
+    SetVBlankCallback(VBC_ChangeMapVBlank);
+    SetMainCallback2(CB2_ChangeMapMain);
+    if (!TryDoMapTransition())
+        SetMainCallback2(gMain.savedCallback);
+}
+
+static bool8 TryDoMapTransition(void)
+{
+    u8 fromType = GetLastUsedWarpMapType();
+    u8 toType = GetCurrentMapType();
+    u8 i = 0;
+    if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId && MapHasPreviewScreen_HandleQLState2(gMapHeader.regionMapSectionId, MPS_TYPE_CAVE) == TRUE)
+    {
+        RunMapPreviewScreen(gMapHeader.regionMapSectionId);
+        return TRUE;
+    }
+    for (; sTransitionTypes[i].fromType != 0; i++)
+    {
+        if (sTransitionTypes[i].fromType == fromType && sTransitionTypes[i].toType == toType)
+        {
+            sTransitionTypes[i].func1();
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 MapTransitionIsEnter(u8 _fromType, u8 _toType)
+{
+    u8 fromType = _fromType;
+    u8 toType = _toType;
+    u8 i = 0;
+    for (; sTransitionTypes[i].fromType != 0; i++)
+    {
+        if (sTransitionTypes[i].fromType == fromType && sTransitionTypes[i].toType == toType)
+        {
+            return sTransitionTypes[i].isEnter;
+        }
+    }
+    return FALSE;
+}
+
+bool8 MapTransitionIsExit(u8 _fromType, u8 _toType)
+{
+    u8 fromType = _fromType;
+    u8 toType = _toType;
+    u8 i = 0;
+    for (; sTransitionTypes[i].fromType != 0; i++)
+    {
+        if (sTransitionTypes[i].fromType == fromType && sTransitionTypes[i].toType == toType)
+        {
+            return sTransitionTypes[i].isExit;
+        }
+    }
+    return FALSE;
+}
+
+static void FlashTransition_Exit(void)
+{
+    CreateTask(Task_FlashTransition_Exit_0, 0);
+}
+
+static void Task_FlashTransition_Exit_0(u8 taskId)
+{
+    gTasks[taskId].func = Task_FlashTransition_Exit_1;
+}
+
+static void Task_FlashTransition_Exit_1(u8 taskId)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    LZ77UnCompVram(sCaveTransitionTiles, (void *)BG_CHAR_ADDR(3));
+    LZ77UnCompVram(sCaveTransitionTilemap, (void *)BG_SCREEN_ADDR(31));
+    LoadPalette(sCaveTransitionPalette_White, 0xE0, 0x20);
+    LoadPalette(sCaveTransitionPalette_Gradient + 8, 0xE0, 0x10);
+    SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG0 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD);
+    SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+    SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(3) | BGCNT_SCREENBASE(31));
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_OBJ_ON);
+    gTasks[taskId].func = Task_FlashTransition_Exit_2;
+    gTasks[taskId].data[0] = 16;
+    gTasks[taskId].data[1] = 0;
+}
+
+static void Task_FlashTransition_Exit_2(u8 taskId)
+{
+    u16 r4 = gTasks[taskId].data[1];
+    SetGpuReg(REG_OFFSET_BLDALPHA, (16 << 8) + r4);
+    if (r4 <= 16)
+    {
+        gTasks[taskId].data[1]++;
+    }
+    else
+    {
+        gTasks[taskId].data[2] = 0;
+        gTasks[taskId].func = Task_FlashTransition_Exit_3;
+    }
+}
+
+static void Task_FlashTransition_Exit_3(u8 taskId)
+{
+    u16 r4;
+    SetGpuReg(REG_OFFSET_BLDALPHA, (16 << 8) + 16);
+    r4 = gTasks[taskId].data[2];
+    if (r4 < 8)
+    {
+        gTasks[taskId].data[2]++;
+        LoadPalette(sCaveTransitionPalette_Gradient + 8 + r4, 0xE0, 0x10 - 2 * r4);
+    }
+    else
+    {
+        LoadPalette(sCaveTransitionPalette_White, 0x00, 0x20);
+        gTasks[taskId].func = Task_FlashTransition_Exit_4;
+        gTasks[taskId].data[2] = 8;
+    }
+}
+
+static void Task_FlashTransition_Exit_4(u8 taskId)
+{
+    if (gTasks[taskId].data[2] != 0)
+        gTasks[taskId].data[2]--;
+    else
+        SetMainCallback2(gMain.savedCallback);
+}
+
+static void FlashTransition_Enter(void)
+{
+    CreateTask(Task_FlashTransition_Enter_0, 0);
+}
+
+static void Task_FlashTransition_Enter_0(u8 taskId)
+{
+    gTasks[taskId].func = Task_FlashTransition_Enter_1;
+}
+
+static void Task_FlashTransition_Enter_1(u8 taskId)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    LZ77UnCompVram(sCaveTransitionTiles, (void *)BG_CHAR_ADDR(3));
+    LZ77UnCompVram(sCaveTransitionTilemap, (void *)BG_SCREEN_ADDR(31));
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+    SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(3) | BGCNT_SCREENBASE(31));
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_OBJ_ON);
+    LoadPalette(sCaveTransitionPalette_White, 0xE0, 0x20);
+    LoadPalette(sCaveTransitionPalette_Black, 0, 0x20);
+    gTasks[taskId].func = Task_FlashTransition_Enter_2;
+    gTasks[taskId].data[0] = 16;
+    gTasks[taskId].data[1] = 0;
+    gTasks[taskId].data[2] = 0;
+}
+
+static void Task_FlashTransition_Enter_2(u8 taskId)
+{
+    u16 r4;
+    r4 = gTasks[taskId].data[2];
+    if (r4 < 16)
+    {
+        gTasks[taskId].data[2]++;
+        gTasks[taskId].data[2]++;
+        LoadPalette(&sCaveTransitionPalette_Gradient[16 - (r4 + 1)], 0xE0, 2 * (r4 + 1));
+    }
+    else
+    {
+        SetGpuReg(REG_OFFSET_BLDALPHA, (16 << 8) + 16);
+        SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG0 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD);
+        gTasks[taskId].func = Task_FlashTransition_Enter_3;
+    }
+}
+
+static void Task_FlashTransition_Enter_3(u8 taskId)
+{
+    u16 r4 = 16 - gTasks[taskId].data[1];
+    SetGpuReg(REG_OFFSET_BLDALPHA, (16 << 8) + r4);
+    if (r4 != 0)
+    {
+        gTasks[taskId].data[1]++;
+    }
+    else
+    {
+        LoadPalette(sCaveTransitionPalette_Black, 0x00, 0x20);
+        SetMainCallback2(gMain.savedCallback);
+    }
+}
+
+static void RunMapPreviewScreen(u8 mapSecId)
+{
+    u8 taskId = CreateTask(Task_MapPreviewScreen_0, 0);
+    gTasks[taskId].data[3] = mapSecId;
+}
+
+static void Task_MapPreviewScreen_0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    switch (data[0])
+    {
+    case 0:
+        SetWordTaskArg(taskId, 5, (uintptr_t)gMain.vblankCallback);
+        SetVBlankCallback(NULL);
+        MapPreview_InitBgs();
+        MapPreview_LoadGfx(data[3]);
+        BlendPalettes(0xFFFFFFFF, 0x10, RGB_BLACK);
+        data[0]++;
+        break;
+    case 1:
+        if (!MapPreview_IsGfxLoadFinished())
+        {
+            data[4] = MapPreview_CreateMapNameWindow(data[3]);
+            CopyWindowToVram(data[4], 3);
+            data[0]++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            BeginNormalPaletteFade(0xFFFFFFFF, -1, 16, 0, RGB_BLACK);
+            SetVBlankCallback((IntrCallback)GetWordTaskArg(taskId, 5));
+            data[0]++;
+        }
+        break;
+    case 3:
+        if (!UpdatePaletteFade())
+        {
+            data[2] = MapPreview_GetDuration(data[3]);
+            data[0]++;
+        }
+        break;
+    case 4:
+        data[1]++;
+        if (data[1] > data[2] || JOY_HELD(B_BUTTON))
+        {
+            BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_WHITE);
+            data[0]++;
+        }
+        break;
+    case 5:
+        if (!UpdatePaletteFade())
+        {
+            int i;
+            for (i = 0; i < 16; i++)
+            {
+                data[i] = 0;
+            }
+            MapPreview_Unload(data[4]);
+            gTasks[taskId].func = Task_FlashTransition_Enter_1;
+        }
+        break;
+    }
+}
diff --git a/src/fldeff_rocksmash.c b/src/fldeff_rocksmash.c
index 2cca37f7a..dc372ce18 100644
--- a/src/fldeff_rocksmash.c
+++ b/src/fldeff_rocksmash.c
@@ -3,25 +3,22 @@
 #include "field_player_avatar.h"
 #include "field_effect.h"
 #include "party_menu.h"
-#include "malloc.h"
 #include "event_data.h"
 #include "script.h"
 #include "fldeff.h"
 #include "event_scripts.h"
-#include "field_weather.h"
 #include "sound.h"
-#include "palette.h"
 #include "overworld.h"
-#include "wild_encounter.h"
 #include "event_object_movement.h"
 #include "constants/songs.h"
-#include "constants/object_events.h"
-#include "constants/map_types.h"
+#include "constants/event_objects.h"
+#include "constants/event_object_movement.h"
+#include "constants/maps.h"
 
-static void task08_080C9820(u8 taskId);
-static void sub_80C98FC(u8 taskId);
-static void sub_80C98B0(u8 taskId);
-static void sub_80C99A0(u8 taskId);
+static void Task_FieldEffectShowMon_Init(u8 taskId);
+static void Task_FieldEffectShowMon_WaitFldeff(u8 taskId);
+static void Task_FieldEffectShowMon_WaitPlayerAnim(u8 taskId);
+static void Task_FieldEffectShowMon_Cleanup(u8 taskId);
 static void sub_80C9A10(void);
 static void sub_80C9A60(void);
 
@@ -40,75 +37,76 @@ bool8 CheckObjectGraphicsInFrontOfPlayer(u8 graphicsId)
     return TRUE;
 }
 
-u8 oei_task_add(void)
+u8 CreateFieldEffectShowMon(void)
 {
     GetXYCoordsOneStepInFrontOfPlayer(&gPlayerFacingPosition.x, &gPlayerFacingPosition.y);
-    return CreateTask(task08_080C9820, 8);
+    return CreateTask(Task_FieldEffectShowMon_Init, 8);
 }
 
-static void task08_080C9820(u8 taskId)
+static void Task_FieldEffectShowMon_Init(u8 taskId)
 {
     u8 mapObjId;
 
     ScriptContext2_Enable();
-    gPlayerAvatar.unk6 = TRUE;
+    gPlayerAvatar.preventStep = TRUE;
     mapObjId = gPlayerAvatar.objectEventId;
     if (!ObjectEventIsMovementOverridden(&gObjectEvents[mapObjId])
      || ObjectEventClearHeldMovementIfFinished(&gObjectEvents[mapObjId]))
     {
         if (gMapHeader.mapType == MAP_TYPE_UNDERWATER)
         {
+            // Leftover from RS, inhibits the player anim while underwater.
             FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
-            gTasks[taskId].func = sub_80C98FC;
+            gTasks[taskId].func = Task_FieldEffectShowMon_WaitFldeff;
         }
         else
         {
             sub_805CB70();
-            ObjectEventSetHeldMovement(&gObjectEvents[mapObjId], 0x45);
-            gTasks[taskId].func = sub_80C98B0;
+            ObjectEventSetHeldMovement(&gObjectEvents[mapObjId], MOVEMENT_ACTION_START_ANIM_IN_DIRECTION);
+            gTasks[taskId].func = Task_FieldEffectShowMon_WaitPlayerAnim;
         }
     }
 }
 
-static void sub_80C98B0(u8 taskId)
+static void Task_FieldEffectShowMon_WaitPlayerAnim(u8 taskId)
 {
     if (ObjectEventCheckHeldMovementStatus(&gObjectEvents[gPlayerAvatar.objectEventId]) == TRUE)
     {
         FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT);
-        gTasks[taskId].func = sub_80C98FC;
+        gTasks[taskId].func = Task_FieldEffectShowMon_WaitFldeff;
     }
 }
 
-static void sub_80C98FC(u8 taskId)
+static void Task_FieldEffectShowMon_WaitFldeff(u8 taskId)
 {
     if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON))
     {
         gFieldEffectArguments[1] = GetPlayerFacingDirection();
-        if (gFieldEffectArguments[1] == 1)
+        if (gFieldEffectArguments[1] == DIR_SOUTH)
             gFieldEffectArguments[2] = 0;
-        if (gFieldEffectArguments[1] == 2)
+        if (gFieldEffectArguments[1] == DIR_NORTH)
             gFieldEffectArguments[2] = 1;
-        if (gFieldEffectArguments[1] == 3)
+        if (gFieldEffectArguments[1] == DIR_WEST)
             gFieldEffectArguments[2] = 2;
-        if (gFieldEffectArguments[1] == 4)
+        if (gFieldEffectArguments[1] == DIR_EAST)
             gFieldEffectArguments[2] = 3;
         ObjectEventSetGraphicsId(&gObjectEvents[gPlayerAvatar.objectEventId], GetPlayerAvatarGraphicsIdByCurrentState());
         StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], gFieldEffectArguments[2]);
-        FieldEffectActiveListRemove(6);
-        gTasks[taskId].func = sub_80C99A0;
+        FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON);
+        gTasks[taskId].func = Task_FieldEffectShowMon_Cleanup;
     }
 }
 
-static void sub_80C99A0(u8 taskId)
+static void Task_FieldEffectShowMon_Cleanup(u8 taskId)
 {
     FLDEFF_CALL_FUNC_IN_DATA();
-    gPlayerAvatar.unk6 = FALSE;
+    gPlayerAvatar.preventStep = FALSE;
     DestroyTask(taskId);
 }
 
 bool8 SetUpFieldMove_RockSmash(void)
 {
-    if (CheckObjectGraphicsInFrontOfPlayer(OBJECT_EVENT_GFX_ROCK_SMASH_ROCK) == TRUE)
+    if (CheckObjectGraphicsInFrontOfPlayer(OBJ_EVENT_GFX_ROCK_SMASH_ROCK) == TRUE)
     {
         gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
         gPostMenuFieldCallback = sub_80C9A10;
@@ -125,7 +123,7 @@ static void sub_80C9A10(void)
 
 bool8 FldEff_UseRockSmash(void)
 {
-    u8 taskId = oei_task_add();
+    u8 taskId = CreateFieldEffectShowMon();
 
     FLDEFF_SET_FUNC_TO_DATA(sub_80C9A60);
     IncrementGameStat(GAME_STAT_USED_ROCK_SMASH);
diff --git a/src/fldeff_softboiled.c b/src/fldeff_softboiled.c
index 60437c125..966a7934c 100644
--- a/src/fldeff_softboiled.c
+++ b/src/fldeff_softboiled.c
@@ -5,7 +5,6 @@
 #include "menu.h"
 #include "new_menu_helpers.h"
 #include "constants/songs.h"
-#include "fldeff.h"
 
 static void sub_80E57E8(u8 taskId);
 static void sub_80E583C(u8 taskId);
diff --git a/src/fldeff_strength.c b/src/fldeff_strength.c
index b8d5af31d..c6b92b28c 100644
--- a/src/fldeff_strength.c
+++ b/src/fldeff_strength.c
@@ -6,15 +6,14 @@
 #include "script.h"
 #include "fldeff.h"
 #include "event_scripts.h"
-#include "constants/songs.h"
-#include "constants/object_events.h"
+#include "constants/event_objects.h"
 
-static void FldEff_UseStrength(void);
-static void sub_80D08A8(void);
+static void FieldCB_UseStrength(void);
+static void ShowMonCB_UseStrength(void);
 
 bool8 SetUpFieldMove_Strength(void)
 {
-    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) || CheckObjectGraphicsInFrontOfPlayer(OBJECT_EVENT_GFX_STRENGTH_BOULDER) != TRUE)
+    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) || CheckObjectGraphicsInFrontOfPlayer(OBJ_EVENT_GFX_STRENGTH_BOULDER) != TRUE)
     {
     	return FALSE;
     }
@@ -22,25 +21,25 @@ bool8 SetUpFieldMove_Strength(void)
     {
         gSpecialVar_Result = GetCursorSelectionMonId();
         gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu;
-        gPostMenuFieldCallback = FldEff_UseStrength;
+        gPostMenuFieldCallback = FieldCB_UseStrength;
         return TRUE;
     }
 }
-static void FldEff_UseStrength(void)
+static void FieldCB_UseStrength(void)
 {
     gFieldEffectArguments[0] = GetCursorSelectionMonId();
     ScriptContext1_SetupScript(EventScript_FldEffStrength);
 }
 
-bool8 sub_80D0860(void)
+bool8 FldEff_UseStrength(void)
 {
-    u8 taskId = oei_task_add();
-    FLDEFF_SET_FUNC_TO_DATA(sub_80D08A8);
+    u8 taskId = CreateFieldEffectShowMon();
+    FLDEFF_SET_FUNC_TO_DATA(ShowMonCB_UseStrength);
     GetMonNickname(&gPlayerParty[gFieldEffectArguments[0]], gStringVar1);
     return FALSE;
 }
 
-static void sub_80D08A8(void)
+static void ShowMonCB_UseStrength(void)
 {
     FieldEffectActiveListRemove(FLDEFF_USE_STRENGTH);
     EnableBothScriptContexts();
diff --git a/src/fldeff_sweetscent.c b/src/fldeff_sweetscent.c
index 943d8504c..d827aff4d 100644
--- a/src/fldeff_sweetscent.c
+++ b/src/fldeff_sweetscent.c
@@ -3,7 +3,6 @@
 #include "field_effect.h"
 #include "party_menu.h"
 #include "malloc.h"
-#include "event_data.h"
 #include "script.h"
 #include "fldeff.h"
 #include "event_scripts.h"
@@ -44,7 +43,7 @@ bool8 FldEff_SweetScent(void)
     u8 taskId;
 
     SetWeatherScreenFadeOut();
-    taskId = oei_task_add();
+    taskId = CreateFieldEffectShowMon();
     FLDEFF_SET_FUNC_TO_DATA(StartSweetScentFieldEffect);
     return FALSE;
 }
diff --git a/src/fldeff_teleport.c b/src/fldeff_teleport.c
index a66a332bf..44a7af732 100644
--- a/src/fldeff_teleport.c
+++ b/src/fldeff_teleport.c
@@ -28,7 +28,7 @@ static void FieldCallback_Teleport(void)
 
 bool8 FldEff_UseTeleport(void)
 {
-    u8 taskId = oei_task_add();
+    u8 taskId = CreateFieldEffectShowMon();
     FLDEFF_SET_FUNC_TO_DATA(StartTeleportFieldEffect);
     SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT);
     return FALSE;
diff --git a/src/flying.c b/src/flying.c
index 6d4a1eb56..4ecfa2899 100644
--- a/src/flying.c
+++ b/src/flying.c
@@ -178,7 +178,7 @@ const struct SpriteTemplate gUnknown_83E6C00 =
 };
 
 // not used
-static const u16 gUnknown_83E6C18[] = INCBIN_U16("graphics/battle_anims/sprites/unk_83E6C18.gbapal");
+static const u16 gUnknown_83E6C18[] = INCBIN_U16("graphics/battle_anims/unk_83E6C18.gbapal");
 
 const struct SpriteTemplate gUnknown_83E6C38 =
 {
diff --git a/src/graphics.c b/src/graphics.c
new file mode 100644
index 000000000..69e804fd9
--- /dev/null
+++ b/src/graphics.c
@@ -0,0 +1,1419 @@
+#include "global.h"
+
+const u32 gBattleTextboxTiles[] = INCBIN_U32("graphics/battle_interface/window.4bpp.lz");
+const u32 gBattleTextboxPalette[] = INCBIN_U32("graphics/battle_interface/window.gbapal.lz");
+const u32 gBattleTextboxTilemap[] = INCBIN_U32("graphics/interface/menu_map.bin.lz");
+
+const u32 gMonFrontPic_CircledQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/circled/front.4bpp.lz");
+const u32 gMonBackPic_CircledQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/circled/back.4bpp.lz");
+const u32 gMonPalette_CircledQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/circled/normal.gbapal.lz");
+const u32 gMonShinyPalette_CircledQuestionMark[] = INCBIN_U32("graphics/pokemon/question_mark/circled/shiny.gbapal.lz");
+
+// From Ruby.
+const u32 gUnusedGfx_OldCharmap[] = INCBIN_U32("graphics/unused/old_charmap.4bpp.lz");
+const u32 gUnusedTimemap_OldCharmap[] = INCBIN_U32("graphics/unused/old_charmap.bin.lz");
+const u32 gUnusedPal_OldCharmap[] = INCBIN_U32("graphics/unused/old_charmap.gbapal.lz");
+
+const u32 gSmokescreenImpactTiles[] = INCBIN_U32("graphics/battle_anims/sprites/smokescreen_impact.4bpp.lz");
+const u32 gSmokescreenImpactPalette[] = INCBIN_U32("graphics/battle_anims/sprites/smokescreen_impact.gbapal.lz");
+
+#include "data/graphics/interface_pokeballs.h"
+
+const u32 gBlankGfxCompressed[] = INCBIN_U32("graphics/interface/blank.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Bubble[] = INCBIN_U32("graphics/battle_anims/sprites/bubble.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Bone[] = INCBIN_U32("graphics/battle_anims/sprites/bone.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_AirWave[] = INCBIN_U32("graphics/battle_anims/sprites/air_wave.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Orb[] = INCBIN_U32("graphics/battle_anims/sprites/orb.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Sword[] = INCBIN_U32("graphics/battle_anims/sprites/sword.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Seed[] = INCBIN_U32("graphics/battle_anims/sprites/seed.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_RainDrops[] = INCBIN_U32("graphics/battle_anims/sprites/rain_drops.gbapal.lz");
+const u32 gBattleAnimSpritePal_Bone[] = INCBIN_U32("graphics/battle_anims/sprites/bone.gbapal.lz");
+const u32 gBattleAnimSpritePal_AirWave[] = INCBIN_U32("graphics/battle_anims/sprites/air_wave.gbapal.lz");
+const u32 gBattleAnimSpritePal_Orb[] = INCBIN_U32("graphics/battle_anims/sprites/orb.gbapal.lz");
+const u32 gBattleAnimSpritePal_Sword[] = INCBIN_U32("graphics/battle_anims/sprites/sword.gbapal.lz");
+const u32 gBattleAnimSpritePal_Seed[] = INCBIN_U32("graphics/battle_anims/sprites/seed.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Needle[] = INCBIN_U32("graphics/battle_anims/sprites/needle.4bpp.lz");
+const u32 gBattleAnimSpritePal_Needle[] = INCBIN_U32("graphics/battle_anims/sprites/needle.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion6[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_6.4bpp.lz");
+const u32 gBattleAnimSpritePal_Explosion6[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_6.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PinkOrb[] = INCBIN_U32("graphics/battle_anims/sprites/pink_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_PinkOrb[] = INCBIN_U32("graphics/battle_anims/sprites/pink_orb.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_IceCube[] = INCBIN_U32("graphics/battle_anims/sprites/ice_cube.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_IceCube[] = INCBIN_U32("graphics/battle_anims/sprites/ice_cube.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Gust[] = INCBIN_U32("graphics/battle_anims/sprites/gust.4bpp.lz");
+const u32 gBattleAnimSpritePal_Gust[] = INCBIN_U32("graphics/battle_anims/sprites/gust.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spark2[] = INCBIN_U32("graphics/battle_anims/sprites/spark_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Spark2[] = INCBIN_U32("graphics/battle_anims/sprites/spark_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Orange[] = INCBIN_U32("graphics/battle_anims/sprites/orange.4bpp.lz");
+const u32 gBattleAnimSpritePal_Orange[] = INCBIN_U32("graphics/battle_anims/sprites/orange.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spikes[] = INCBIN_U32("graphics/battle_anims/sprites/spikes.4bpp.lz");
+const u32 gBattleAnimSpritePal_Spikes[] = INCBIN_U32("graphics/battle_anims/sprites/spikes.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_YellowBall[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_ball.4bpp.lz");
+const u32 gBattleAnimSpritePal_YellowBall[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_ball.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_TiedBag[] = INCBIN_U32("graphics/battle_anims/sprites/tied_bag.4bpp.lz");
+const u32 gBattleAnimSpritePal_TiedBag[] = INCBIN_U32("graphics/battle_anims/sprites/tied_bag.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BlackSmoke[] = INCBIN_U32("graphics/battle_anims/sprites/black_smoke.4bpp.lz");
+const u32 gBattleAnimSpritePal_BlackSmoke[] = INCBIN_U32("graphics/battle_anims/sprites/black_smoke.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BlackBall[] = INCBIN_U32("graphics/battle_anims/sprites/black_ball.4bpp.lz");
+
+const u32 gUnknownGfx_8D035A0[] = INCBIN_U32("graphics/unknown/unknown_D035A0.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Glass[] = INCBIN_U32("graphics/battle_anims/sprites/glass.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Glass[] = INCBIN_U32("graphics/battle_anims/sprites/glass.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_HornHit[] = INCBIN_U32("graphics/battle_anims/sprites/horn_hit.4bpp.lz");
+const u32 gBattleAnimSpritePal_HornHit[] = INCBIN_U32("graphics/battle_anims/sprites/horn_hit.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BlueShards[] = INCBIN_U32("graphics/battle_anims/sprites/blue_shards.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_BlueShards[] = INCBIN_U32("graphics/battle_anims/sprites/blue_shards.4bpp.lz");
+
+const u32 gUnused_BattleSpritePalette_023[] = INCBIN_U32("graphics/unused/battle_anim_023.gbapal.lz");
+
+const u32 gUnusedGfx_MusicNotes[] = INCBIN_U32("graphics/unused/music_notes.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Hit[] = INCBIN_U32("graphics/battle_anims/sprites/hit.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Hit[] = INCBIN_U32("graphics/battle_anims/sprites/hit.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Hit2[] = INCBIN_U32("graphics/battle_anims/sprites/hit_2.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_WavingHand[] = INCBIN_U32("graphics/battle_anims/sprites/waving_hand.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_WavingHand[] = INCBIN_U32("graphics/battle_anims/sprites/waving_hand.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_ClosingEye[] = INCBIN_U32("graphics/battle_anims/sprites/closing_eye.4bpp.lz");
+const u32 gBattleAnimSpritePal_ClosingEye[] = INCBIN_U32("graphics/battle_anims/sprites/closing_eye.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BlueStar[] = INCBIN_U32("graphics/battle_anims/sprites/blue_star.4bpp.lz");
+const u32 gBattleAnimSpritePal_BlueStar[] = INCBIN_U32("graphics/battle_anims/sprites/blue_star.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BubbleBurst[] = INCBIN_U32("graphics/battle_anims/sprites/bubble_burst.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_BubbleBurst[] = INCBIN_U32("graphics/battle_anims/sprites/bubble_burst.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_HitDuplicate[] = INCBIN_U32("graphics/battle_anims/sprites/hit_duplicate.4bpp.lz");
+const u32 gBattleAnimSpritePal_HitDuplicate[] = INCBIN_U32("graphics/battle_anims/sprites/hit_duplicate.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Leer[] = INCBIN_U32("graphics/battle_anims/sprites/leer.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Leer[] = INCBIN_U32("graphics/battle_anims/sprites/leer.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_BlueBurst[] = INCBIN_U32("graphics/battle_anims/sprites/blue_burst.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_BlueBurst[] = INCBIN_U32("graphics/battle_anims/sprites/blue_burst.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_SmallEmber[] = INCBIN_U32("graphics/battle_anims/sprites/small_ember.4bpp.lz");
+const u32 gBattleAnimSpritePal_SmallEmber[] = INCBIN_U32("graphics/battle_anims/sprites/small_ember.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GraySmoke[] = INCBIN_U32("graphics/battle_anims/sprites/gray_smoke.4bpp.lz");
+const u32 gBattleAnimSpritePal_GraySmoke[] = INCBIN_U32("graphics/battle_anims/sprites/gray_smoke.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Fire[] = INCBIN_U32("graphics/battle_anims/sprites/fire.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Fire[] = INCBIN_U32("graphics/battle_anims/sprites/fire.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_SpinningFire[] = INCBIN_U32("graphics/battle_anims/sprites/spinning_fire.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_FirePlume[] = INCBIN_U32("graphics/battle_anims/sprites/fire_plume.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Lightning2[] = INCBIN_U32("graphics/battle_anims/sprites/lightning_2.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Lightning2[] = INCBIN_U32("graphics/battle_anims/sprites/lightning_2.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Lightning[] = INCBIN_U32("graphics/battle_anims/sprites/lightning.4bpp.lz");
+
+const u32 gUnknownGfx_D06D80[] = INCBIN_U32("graphics/unknown/unknown_D06D80.4bpp.lz");
+const u32 gUnknownPal_D06DC4[] = INCBIN_U32("graphics/unknown/unknown_D06D80.gbapal.lz");
+const u32 gUnknownPal_D06DD8[] = INCBIN_U32("graphics/unknown/unknown_D06D80_2.gbapal.lz");
+
+// old battle interface data, unused
+const u32 gOldBattleInterfaceGfx[] = INCBIN_U32("graphics/unused/obi1.4bpp.lz");
+const u32 gOldBattleInterfacePal_1_2_3[] = INCBIN_U32("graphics/unused/obi_palpak1.gbapal.lz"); // palettes 1-3
+const u32 gOldBattleInterfacePal4[] = INCBIN_U32("graphics/unused/old_pal4.gbapal.lz"); // 4 is by itself
+const u32 gOldBattleInterfacePal_5_6_7[] = INCBIN_U32("graphics/unused/obi_palpak3.gbapal.lz"); // palettes 5-7
+const u32 gOldBattleInterfaceGfx2[] = INCBIN_U32("graphics/unused/obi2.4bpp.lz");
+const u32 gOldBattleInterfaceTilemap[] = INCBIN_U32("graphics/unused/old_battle_interface_tilemap.bin.lz");
+
+const u32 gBattleAnimSpritePal_ClawSlash2[] = INCBIN_U32("graphics/battle_anims/sprites/claw_slash_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_ClawSlash[] = INCBIN_U32("graphics/battle_anims/sprites/claw_slash.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_ClawSlash2[] = INCBIN_U32("graphics/battle_anims/sprites/claw_slash_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_ClawSlash[] = INCBIN_U32("graphics/battle_anims/sprites/claw_slash.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Scratch3[] = INCBIN_U32("graphics/battle_anims/sprites/scratch_3.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Scratch2[] = INCBIN_U32("graphics/battle_anims/sprites/scratch_2.4bpp.lz");
+
+const u32 gPartyMenuHpBar_Gfx[] = INCBIN_U32("graphics/interface/party_menu_hpbar.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_BubbleBurst2[] = INCBIN_U32("graphics/battle_anims/sprites/bubble_burst_2.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_BubbleBurst2[] = INCBIN_U32("graphics/battle_anims/sprites/bubble_burst_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_IceChunk[] = INCBIN_U32("graphics/battle_anims/sprites/ice_chunk.4bpp.lz");
+const u32 gBattleAnimSpritePal_IceChunk[] = INCBIN_U32("graphics/battle_anims/sprites/ice_chunk.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Glass2[] = INCBIN_U32("graphics/battle_anims/sprites/glass_2.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Glass2[] = INCBIN_U32("graphics/battle_anims/sprites/glass_2.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_PinkHeart2[] = INCBIN_U32("graphics/battle_anims/sprites/pink_heart_2.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_PinkHeart2[] = INCBIN_U32("graphics/battle_anims/sprites/pink_heart_2.4bpp.lz");
+
+const u32 gInterfaceGfx_UnusedWindow[] = INCBIN_U32("graphics/battle_interface/unused_window.4bpp.lz");
+const u32 gInterfacePal_UnusedWindow[] = INCBIN_U32("graphics/battle_interface/unused_window.gbapal.lz");
+
+const u32 gInterfaceGfx_HPNumbers[] = INCBIN_U32("graphics/interface/hp_numbers.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_SapDrip[] = INCBIN_U32("graphics/battle_anims/sprites/sap_drip.4bpp.lz");
+const u32 gBattleAnimSpritePal_SapDrip[] = INCBIN_U32("graphics/battle_anims/sprites/sap_drip.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_SapDrip2[] = INCBIN_U32("graphics/battle_anims/sprites/sap_drip_2.gbapal.lz");
+
+const u32 gUnusedGfx_Window2[] = INCBIN_U32("graphics/battle_interface/unused_window2.4bpp.lz");
+const u32 gUnusedGfx_Window2Bar[] = INCBIN_U32("graphics/battle_interface/unused_window2bar.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Sparkle1[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_1.4bpp.lz");
+const u32 gBattleAnimSpritePal_Sparkle1[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_1.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Sparkle2[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_HumanoidFoot[] = INCBIN_U32("graphics/battle_anims/sprites/humanoid_foot.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_HumanoidFoot[] = INCBIN_U32("graphics/battle_anims/sprites/humanoid_foot.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_MonsterFoot[] = INCBIN_U32("graphics/battle_anims/sprites/monster_foot.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_HumanoidHand[] = INCBIN_U32("graphics/battle_anims/sprites/humanoid_hand.4bpp.lz");
+
+const u32 gUnusedGfx_LineSketch[] = INCBIN_U32("graphics/unused/line_sketch.4bpp.lz");
+const u32 gUnusedPal_LineSketch[] = INCBIN_U32("graphics/unused/line_sketch.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_YellowUnk[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_unk.4bpp.lz");
+const u32 gBattleAnimSpritePal_YellowUnk[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_unk.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SlamHit[] = INCBIN_U32("graphics/battle_anims/sprites/slam_hit.4bpp.lz");
+const u32 gBattleAnimSpritePal_SlamHit[] = INCBIN_U32("graphics/battle_anims/sprites/slam_hit.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RedFist[] = INCBIN_U32("graphics/battle_anims/sprites/red_fist.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Ring[] = INCBIN_U32("graphics/battle_anims/sprites/ring.4bpp.lz");
+const u32 gBattleAnimSpritePal_Ring[] = INCBIN_U32("graphics/battle_anims/sprites/ring.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Rocks[] = INCBIN_U32("graphics/battle_anims/sprites/rocks.4bpp.lz");
+const u32 gBattleAnimSpritePal_Rocks[] = INCBIN_U32("graphics/battle_anims/sprites/rocks.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Z[] = INCBIN_U32("graphics/battle_anims/sprites/z.4bpp.lz");
+const u32 gBattleAnimSpritePal_Z[] = INCBIN_U32("graphics/battle_anims/sprites/z.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_YellowUnk2[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_unk_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_YellowUnk2[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_unk_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_AirSlash[] = INCBIN_U32("graphics/battle_anims/sprites/air_slash.4bpp.lz");
+const u32 gBattleAnimSpritePal_AirSlash[] = INCBIN_U32("graphics/battle_anims/sprites/air_slash.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SpinningGreenOrbs[] = INCBIN_U32("graphics/battle_anims/sprites/spinning_green_orbs.4bpp.lz");
+const u32 gBattleAnimSpritePal_SpinningGreenOrbs[] = INCBIN_U32("graphics/battle_anims/sprites/spinning_green_orbs.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Leaf[] = INCBIN_U32("graphics/battle_anims/sprites/leaf.4bpp.lz");
+const u32 gBattleAnimSpritePal_Leaf[] = INCBIN_U32("graphics/battle_anims/sprites/leaf.gbapal.lz");
+
+const u32 gUnusedGfx_Metronome[] = INCBIN_U32("graphics/unused/metronome_hand_small.4bpp.lz"); // unused, was for metronome at one point
+
+const u32 gBattleAnimSpritePal_Clapping[] = INCBIN_U32("graphics/battle_anims/sprites/clapping.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PoisonPowder[] = INCBIN_U32("graphics/battle_anims/sprites/poison_powder.4bpp.lz");
+const u32 gBattleAnimSpritePal_PoisonPowder[] = INCBIN_U32("graphics/battle_anims/sprites/poison_powder.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BrownTriangle[] = INCBIN_U32("graphics/battle_anims/sprites/brown_triangle.4bpp.lz");
+const u32 gBattleAnimSpritePal_BrownTriangle[] = INCBIN_U32("graphics/battle_anims/sprites/brown_triangle.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Sparkle3[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_3.4bpp.lz");
+const u32 gBattleAnimSpritePal_Sparkle3[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_3.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Sparkle4[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_4.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_MusicNotes[] = INCBIN_U32("graphics/battle_anims/sprites/music_notes.4bpp.lz");
+const u32 gBattleAnimSpritePal_MusicNotes[] = INCBIN_U32("graphics/battle_anims/sprites/music_notes.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Duck[] = INCBIN_U32("graphics/battle_anims/sprites/duck.4bpp.lz");
+const u32 gBattleAnimSpritePal_Duck[] = INCBIN_U32("graphics/battle_anims/sprites/duck.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Alert[] = INCBIN_U32("graphics/battle_anims/sprites/alert.4bpp.lz");
+const u32 gBattleAnimSpritePal_Alert[] = INCBIN_U32("graphics/battle_anims/sprites/alert.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Shock4[] = INCBIN_U32("graphics/battle_anims/sprites/shock_4.4bpp.lz");
+const u32 gBattleAnimSpritePal_Shock4[] = INCBIN_U32("graphics/battle_anims/sprites/shock_4.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Shock[] = INCBIN_U32("graphics/battle_anims/sprites/shock.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Bell2[] = INCBIN_U32("graphics/battle_anims/sprites/bell_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Bell2[] = INCBIN_U32("graphics/battle_anims/sprites/bell_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PinkGlove[] = INCBIN_U32("graphics/battle_anims/sprites/pink_glove.4bpp.lz");
+const u32 gBattleAnimSpritePal_PinkGlove[] = INCBIN_U32("graphics/battle_anims/sprites/pink_glove.gbapal.lz");
+
+const u16 gUnknown_D0CA04[] = INCBIN_U16("graphics/unknown/unknown_D0CA04.bin");
+const u16 gUnknown_D0CA28[] = INCBIN_U16("graphics/unknown/unknown_D0CA28.bin");
+const u16 gUnknown_D0CA4C[] = INCBIN_U16("graphics/unknown/unknown_D0CA4C.bin");
+const u32 gUnusedGfx8bpp_LineSketch2[] = INCBIN_U32("graphics/unused/line_sketch_2.8bpp.lz");
+const u16 gUnknown_D0CAC8[] = INCBIN_U16("graphics/unknown/unknown_D0CAC8.bin");
+const u32 gUnusedTilemap_LineSketch2[] = INCBIN_U32("graphics/unused/line_sketch_2.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_BlueLines[] = INCBIN_U32("graphics/battle_anims/sprites/blue_lines.4bpp.lz");
+const u32 gBattleAnimSpritePal_BlueLines[] = INCBIN_U32("graphics/battle_anims/sprites/blue_lines.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Impact3[] = INCBIN_U32("graphics/battle_anims/sprites/impact_3.gbapal.lz");
+const u32 gBattleAnimSpritePal_Impact2[] = INCBIN_U32("graphics/battle_anims/sprites/impact_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_Reticle[] = INCBIN_U32("graphics/battle_anims/sprites/reticle.gbapal.lz");
+const u32 gBattleAnimSpritePal_Breath[] = INCBIN_U32("graphics/battle_anims/sprites/breath.gbapal.lz");
+const u32 gBattleAnimSpritePal_Snowball[] = INCBIN_U32("graphics/battle_anims/sprites/snowball.gbapal.lz");
+const u32 gBattleAnimSpritePal_Vine[] = INCBIN_U32("graphics/battle_anims/sprites/vine.gbapal.lz");
+const u32 gBattleAnimSpritePal_Sword2[] = INCBIN_U32("graphics/battle_anims/sprites/sword_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_RedTube[] = INCBIN_U32("graphics/battle_anims/sprites/red_tube.gbapal.lz");
+const u32 gBattleAnimSpritePal_Amnesia[] = INCBIN_U32("graphics/battle_anims/sprites/amnesia.gbapal.lz");
+const u32 gBattleAnimSpritePal_String2[] = INCBIN_U32("graphics/battle_anims/sprites/string_2.gbapal.lz");
+
+const u32 gFile_graphics_unknown_unknown_D0CD0C[] = INCBIN_U32("graphics/unknown/unknown_D0CD0C.bin.lz");
+
+const u32 gBattleAnimSpritePal_Pencil2[] = INCBIN_U32("graphics/battle_anims/sprites/pencil_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_Petal[] = INCBIN_U32("graphics/battle_anims/sprites/petal.gbapal.lz");
+const u32 gBattleAnimSpritePal_BentSpoon[] = INCBIN_U32("graphics/battle_anims/sprites/bent_spoon.gbapal.lz");
+const u32 gBattleAnimSpritePal_Coin[] = INCBIN_U32("graphics/battle_anims/sprites/coin.gbapal.lz");
+const u32 gBattleAnimSpritePal_CrackedEgg[] = INCBIN_U32("graphics/battle_anims/sprites/cracked_egg.gbapal.lz");
+const u32 gBattleAnimSpritePal_FreshEgg[] = INCBIN_U32("graphics/battle_anims/sprites/fresh_egg.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Impact3[] = INCBIN_U32("graphics/battle_anims/sprites/impact_3.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Impact2[] = INCBIN_U32("graphics/battle_anims/sprites/impact_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Reticle[] = INCBIN_U32("graphics/battle_anims/sprites/reticle.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Breath[] = INCBIN_U32("graphics/battle_anims/sprites/breath.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Snowball[] = INCBIN_U32("graphics/battle_anims/sprites/snowball.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Vine[] = INCBIN_U32("graphics/battle_anims/sprites/vine.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Sword2[] = INCBIN_U32("graphics/battle_anims/sprites/sword_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Clapping[] = INCBIN_U32("graphics/battle_anims/sprites/clapping.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_RedTube[] = INCBIN_U32("graphics/battle_anims/sprites/red_tube.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Amnesia[] = INCBIN_U32("graphics/battle_anims/sprites/amnesia.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_String2[] = INCBIN_U32("graphics/battle_anims/sprites/string_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Pencil2[] = INCBIN_U32("graphics/battle_anims/sprites/pencil_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Petal[] = INCBIN_U32("graphics/battle_anims/sprites/petal.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_BentSpoon[] = INCBIN_U32("graphics/battle_anims/sprites/bent_spoon.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Web[] = INCBIN_U32("graphics/battle_anims/sprites/web.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Coin[] = INCBIN_U32("graphics/battle_anims/sprites/coin.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_CrackedEgg[] = INCBIN_U32("graphics/battle_anims/sprites/cracked_egg.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_HatchedEgg[] = INCBIN_U32("graphics/battle_anims/sprites/hatched_egg.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_FreshEgg[] = INCBIN_U32("graphics/battle_anims/sprites/fresh_egg.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Fangs[] = INCBIN_U32("graphics/battle_anims/sprites/fangs.4bpp.lz");
+const u32 gBattleAnimSpritePal_Fangs[] = INCBIN_U32("graphics/battle_anims/sprites/fangs.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion2[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Explosion2[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion3[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_3.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_WaterDroplet[] = INCBIN_U32("graphics/battle_anims/sprites/water_droplet.4bpp.lz");
+const u32 gBattleAnimSpritePal_WaterDroplet[] = INCBIN_U32("graphics/battle_anims/sprites/water_droplet.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WaterDroplet2[] = INCBIN_U32("graphics/battle_anims/sprites/water_droplet_2.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Seed2[] = INCBIN_U32("graphics/battle_anims/sprites/seed_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Seed2[] = INCBIN_U32("graphics/battle_anims/sprites/seed_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Sprout[] = INCBIN_U32("graphics/battle_anims/sprites/sprout.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_RedWand[] = INCBIN_U32("graphics/battle_anims/sprites/red_wand.4bpp.lz");
+const u32 gBattleAnimSpritePal_RedWand[] = INCBIN_U32("graphics/battle_anims/sprites/red_wand.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleGreenUnk[] = INCBIN_U32("graphics/battle_anims/sprites/purple_green_unk.4bpp.lz");
+const u32 gBattleAnimSpritePal_PurpleGreenUnk[] = INCBIN_U32("graphics/battle_anims/sprites/purple_green_unk.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WaterColumn[] = INCBIN_U32("graphics/battle_anims/sprites/water_column.4bpp.lz");
+const u32 gBattleAnimSpritePal_WaterColumn[] = INCBIN_U32("graphics/battle_anims/sprites/water_column.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MudUnk[] = INCBIN_U32("graphics/battle_anims/sprites/mud_unk.4bpp.lz");
+const u32 gBattleAnimSpritePal_MudUnk[] = INCBIN_U32("graphics/battle_anims/sprites/mud_unk.gbapal.lz");
+
+const u32 gUnusedTilemap_BlueFrame[] = INCBIN_U32("graphics/unused/blue_frame.bin.lz"); // P1, P2, P3 and P4 tilemaps?
+const u32 gUnusedTilemap_RedYellowGreenFrame[] = INCBIN_U32("graphics/unused/redyellowgreen_frame.bin.lz");
+const u32 gUnusedGfx_ColorFrames[] = INCBIN_U32("graphics/unused/color_frames.4bpp.lz");
+const u32 gUnusedPal_ColorFrames[] = INCBIN_U32("graphics/unused/color_frames.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RainDrops[] = INCBIN_U32("graphics/battle_anims/sprites/rain_drops.4bpp.lz");
+
+const u32 gUnusedGfx8bpp_WaterSplash [] = INCBIN_U32("graphics/unused/water_splash.8bpp.lz");
+const u32 gUnusedTilemap_WaterSplash[] = INCBIN_U32("graphics/unused/water_splash.bin.lz");
+const u32 gUnusedPalette_WaterSplash[] = INCBIN_U32("graphics/unused/water_splash.gbapal.lz");
+
+const u32 gUnusedGfx_BasicFrame[] = INCBIN_U32("graphics/unused/basic_frame.4bpp.lz");
+const u32 gUnusedPal_BasicFrame[] = INCBIN_U32("graphics/unused/basic_frame.gbapal.lz");
+const u32 gUnusedTilemap_BasicFrame[] = INCBIN_U32("graphics/unused/basic_frame.bin.lz");
+
+// Battle Interface
+
+const u16 gBattleInterface_BallStatusBarPal[] = INCBIN_U16("graphics/battle_interface/ball_status_bar.gbapal");
+
+const u16 gBattleInterface_BallDisplayPal[] = INCBIN_U16("graphics/battle_interface/ball_display.gbapal");
+
+//Originally an array?
+const u8 gHealthboxElementsGfxTable[] = INCBIN_U8("graphics/battle_interface/hp_bar.4bpp");
+const u8 gHealthboxElementsGfxTable_ExpBar[] = INCBIN_U8("graphics/battle_interface/exp_bar.4bpp");
+const u8 gHealthboxElementsGfxTable_StatusPsn[] = INCBIN_U8("graphics/battle_interface/status_psn.4bpp");
+const u8 gHealthboxElementsGfxTable_StatusPar[] = INCBIN_U8("graphics/battle_interface/status_par.4bpp");
+const u8 gHealthboxElementsGfxTable_StatusSlp[] = INCBIN_U8("graphics/battle_interface/status_slp.4bpp");
+const u8 gHealthboxElementsGfxTable_StatusFrz[] = INCBIN_U8("graphics/battle_interface/status_frz.4bpp");
+const u8 gHealthboxElementsGfxTable_StatusBrn[] = INCBIN_U8("graphics/battle_interface/status_brn.4bpp");
+const u8 gHealthboxElementsGfxTable_Misc[] = INCBIN_U8("graphics/battle_interface/misc.4bpp");
+const u8 gHealthboxElementsGfxTable_HpBarAnim[] = INCBIN_U8("graphics/battle_interface/hp_bar_anim.4bpp");
+const u8 gHealthboxElementsGfxTable_MiscFrameEnd[] = INCBIN_U8("graphics/battle_interface/misc_frame_end.4bpp");
+
+const u8 gUnknown_8D12404[] = INCBIN_U8("graphics/battle_interface/ball_display.4bpp");
+
+//Originally an array?
+const u8 gUnknown_08C1249C[] = INCBIN_U8("graphics/battle_interface/ball_display_unused_extra.4bpp");
+const u8 gBattleInterfaceGfx_Status2[] = INCBIN_U8("graphics/battle_interface/status2.4bpp"); // these three duplicate sets of graphics are for the opponent pokemon
+const u8 gBattleInterfaceGfx_Status3[] = INCBIN_U8("graphics/battle_interface/status3.4bpp"); // and are also for use in double battles. they use dynamic palettes so
+const u8 gBattleInterfaceGfx_Status4[] = INCBIN_U8("graphics/battle_interface/status4.4bpp"); // coloring them is an extreme headache and wont be done for now
+const u8 gUnknown_8D12A44[] = INCBIN_U8("graphics/unknown/unknown_D12A44.4bpp");
+const u8 gUnknown_8D12A64[] = INCBIN_U8("graphics/unknown/unknown_D12A64.4bpp");
+const u32 gBattleInterfaceGfx_UnusedWindow3[] = INCBIN_U32("graphics/battle_interface/unused_window3.4bpp.lz");
+const u32 gBattleInterfaceGfx_UnusedWindow4[] = INCBIN_U32("graphics/battle_interface/unused_window4.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_FurySwipes[] = INCBIN_U32("graphics/battle_anims/sprites/fury_swipes.4bpp.lz");
+const u32 gBattleAnimSpritePal_FurySwipes[] = INCBIN_U32("graphics/battle_anims/sprites/fury_swipes.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Vine2[] = INCBIN_U32("graphics/battle_anims/sprites/vine_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Vine2[] = INCBIN_U32("graphics/battle_anims/sprites/vine_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Teeth[] = INCBIN_U32("graphics/battle_anims/sprites/teeth.4bpp.lz");
+const u32 gBattleAnimSpritePal_Teeth[] = INCBIN_U32("graphics/battle_anims/sprites/teeth.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Bone2[] = INCBIN_U32("graphics/battle_anims/sprites/bone_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Bone2[] = INCBIN_U32("graphics/battle_anims/sprites/bone_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WhiteBag[] = INCBIN_U32("graphics/battle_anims/sprites/white_bag.4bpp.lz");
+const u32 gBattleAnimSpritePal_WhiteBag[] = INCBIN_U32("graphics/battle_anims/sprites/white_bag.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Unknown[] = INCBIN_U32("graphics/battle_anims/sprites/unknown.4bpp.lz");
+const u32 gBattleAnimSpritePal_Unknown[] = INCBIN_U32("graphics/battle_anims/sprites/unknown.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleCoral[] = INCBIN_U32("graphics/battle_anims/sprites/purple_coral.4bpp.lz");
+const u32 gBattleAnimSpritePal_PurpleCoral[] = INCBIN_U32("graphics/battle_anims/sprites/purple_coral.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleDroplet[] = INCBIN_U32("graphics/battle_anims/sprites/purple_droplet.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Shock2[] = INCBIN_U32("graphics/battle_anims/sprites/shock_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_Shock2[] = INCBIN_U32("graphics/battle_anims/sprites/shock_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_ClosingEye2[] = INCBIN_U32("graphics/battle_anims/sprites/closing_eye_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_ClosingEye2[] = INCBIN_U32("graphics/battle_anims/sprites/closing_eye_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MetalBall[] = INCBIN_U32("graphics/battle_anims/sprites/metal_ball.4bpp.lz");
+const u32 gBattleAnimSpritePal_MetalBall[] = INCBIN_U32("graphics/battle_anims/sprites/metal_ball.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MonsterDoll[] = INCBIN_U32("graphics/battle_anims/sprites/monster_doll.4bpp.lz");
+const u32 gBattleAnimSpritePal_MonsterDoll[] = INCBIN_U32("graphics/battle_anims/sprites/monster_doll.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Whirlwind[] = INCBIN_U32("graphics/battle_anims/sprites/whirlwind.4bpp.lz");
+const u32 gBattleAnimSpritePal_Whirlwind[] = INCBIN_U32("graphics/battle_anims/sprites/whirlwind.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Whirlwind2[] = INCBIN_U32("graphics/battle_anims/sprites/whirlwind_2.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion4[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_4.4bpp.lz");
+const u32 gBattleAnimSpritePal_Explosion4[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_4.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion5[] = INCBIN_U32("graphics/battle_anims/sprites/explosion_5.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Tongue[] = INCBIN_U32("graphics/battle_anims/sprites/tongue.4bpp.lz");
+const u32 gBattleAnimSpritePal_Tongue[] = INCBIN_U32("graphics/battle_anims/sprites/tongue.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Smoke[] = INCBIN_U32("graphics/battle_anims/sprites/smoke.4bpp.lz");
+const u32 gBattleAnimSpritePal_Smoke[] = INCBIN_U32("graphics/battle_anims/sprites/smoke.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Smoke2[] = INCBIN_U32("graphics/battle_anims/sprites/smoke_2.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_BlueFlames[] = INCBIN_U32("graphics/battle_anims/sprites/blue_flames.4bpp.lz");
+const u32 gBattleAnimSpritePal_BlueFlames[] = INCBIN_U32("graphics/battle_anims/sprites/blue_flames.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BlueFlames2[] = INCBIN_U32("graphics/battle_anims/sprites/blue_flames_2.4bpp.lz");
+
+// Contest
+
+const u32 gUnusedGfx_OldContest[] = INCBIN_U32("graphics/unused/old_contest.4bpp.lz");
+const u32 gUnusedPal_OldContest[] = INCBIN_U32("graphics/unused/old_contest.gbapal.lz");
+const u32 gUnusedTilemap_OldContest[] = INCBIN_U32("graphics/unused/old_contest.bin.lz");
+
+const u32 gFile_graphics_unknown_unknown_D15BE8_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D15BE8.bin.lz");
+
+const u32 gFile_graphics_unused_numbers_sheet[] = INCBIN_U32("graphics/unused/numbers.4bpp.lz"); // From ruby
+const u32 gFile_graphics_unused_numbers_palette[] = INCBIN_U32("graphics/unused/numbers.gbapal.lz"); // From ruby
+
+const u32 gUnusedGfx_OldContest2[] = INCBIN_U32("graphics/unused/old_contest_2.4bpp.lz");
+const u32 gOldContestPalette[] = INCBIN_U32("graphics/unused/old_contest_2.gbapal.lz");
+const u32 gOldContestGfx[] = INCBIN_U32("graphics/unused/old_contest_2.bin.lz");
+
+const u32 gFile_graphics_unknown_unknown_D172A8_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D172A8.bin.lz");
+
+const u32 gFile_graphics_unknown_unknown_D17548_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D17548.bin.lz");
+
+const u32 gFile_graphics_unknown_unknown_D17654_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D17654.bin.lz");
+
+const u32 gFile_graphics_unknown_unknown_D17AB8_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D17AB8.bin.lz");
+
+const u32 gContestMiscGfx[] = INCBIN_U32("graphics/contest/misc.4bpp.lz");
+
+const u32 gFile_graphics_contest_audience_sheet[] = INCBIN_U32("graphics/contest/audience.4bpp.lz");
+
+const u32 gFile_graphics_contest_faces_sheet[] = INCBIN_U32("graphics/contest/faces.4bpp.lz");
+
+const u32 gFile_graphics_contest_judge_symbols_sheet[] = INCBIN_U32("graphics/contest/judge_symbols.4bpp.lz");
+const u32 gFile_graphics_contest_judge_symbols_palette[] = INCBIN_U32("graphics/contest/judge_symbols.gbapal.lz");
+
+const u8 gFile_graphics_contest_heart[] = INCBIN_U8("graphics/contest/heart.4bpp");
+
+const u32 gFile_graphics_unknown_unknown_D196E4_sheet[] = INCBIN_U32("graphics/unknown/unknown_D196E4.4bpp.lz");
+const u32 gFile_graphics_unknown_unknown_D196E4_palette[] = INCBIN_U32("graphics/unknown/unknown_D196E4.gbapal.lz");
+
+const u32 gUnknown_8D197FC[] = INCBIN_U32("graphics/contest/misc_2.4bpp.lz");
+
+const u32 gFile_graphics_contest_misc_2_tilemap_1_tilemap[] = INCBIN_U32("graphics/contest/misc_2_tilemap_1.bin.lz");
+const u32 gFile_graphics_contest_misc_2_tilemap_2_tilemap[] = INCBIN_U32("graphics/contest/misc_2_tilemap_2.bin.lz");
+const u32 gFile_graphics_contest_misc_2_tilemap_3_tilemap[] = INCBIN_U32("graphics/contest/misc_2_tilemap_3.bin.lz");
+
+const u32 gFile_graphics_contest_misc_2_palette[] = INCBIN_U32("graphics/contest/misc_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Impact[] = INCBIN_U32("graphics/battle_anims/sprites/impact.4bpp.lz");
+const u32 gBattleAnimSpritePal_Impact[] = INCBIN_U32("graphics/battle_anims/sprites/impact.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Particles[] = INCBIN_U32("graphics/battle_anims/sprites/particles.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_CircleImpact[] = INCBIN_U32("graphics/battle_anims/sprites/circle_impact.4bpp.lz");
+const u32 gBattleAnimSpritePal_CircleImpact[] = INCBIN_U32("graphics/battle_anims/sprites/circle_impact.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Scratch[] = INCBIN_U32("graphics/battle_anims/sprites/scratch.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_SharpTeeth[] = INCBIN_U32("graphics/battle_anims/sprites/sharp_teeth.4bpp.lz");
+const u32 gBattleAnimSpritePal_SharpTeeth[] = INCBIN_U32("graphics/battle_anims/sprites/sharp_teeth.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Clamp[] = INCBIN_U32("graphics/battle_anims/sprites/clamp.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Cut[] = INCBIN_U32("graphics/battle_anims/sprites/cut.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_RainbowRings[] = INCBIN_U32("graphics/battle_anims/sprites/rainbow_rings.4bpp.lz");
+const u32 gBattleAnimSpritePal_RainbowRings[] = INCBIN_U32("graphics/battle_anims/sprites/rainbow_rings.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_IceCrystals[] = INCBIN_U32("graphics/battle_anims/sprites/ice_crystals.4bpp.lz");
+const u32 gBattleAnimSpritePal_IceCrystals[] = INCBIN_U32("graphics/battle_anims/sprites/ice_crystals.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_IceSpikes[] = INCBIN_U32("graphics/battle_anims/sprites/ice_spikes.4bpp.lz");
+
+const u32 gUnusedGfx_OldBeatUp[] = INCBIN_U32("graphics/unused/old_beatup.4bpp.lz");
+const u32 gUnusedPal_OldBeatUp[] = INCBIN_U32("graphics/unused/old_beatup.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Orbs[] = INCBIN_U32("graphics/battle_anims/sprites/orbs.4bpp.lz");
+const u32 gBattleAnimSpritePal_Orbs[] = INCBIN_U32("graphics/battle_anims/sprites/orbs.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WaterOrb[] = INCBIN_U32("graphics/battle_anims/sprites/water_orb.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_WaterImpact[] = INCBIN_U32("graphics/battle_anims/sprites/water_impact.4bpp.lz");
+const u32 gBattleAnimSpritePal_WaterImpact[] = INCBIN_U32("graphics/battle_anims/sprites/water_impact.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BrownOrb[] = INCBIN_U32("graphics/battle_anims/sprites/brown_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MudSand[] = INCBIN_U32("graphics/battle_anims/sprites/mud_sand.4bpp.lz");
+const u32 gBattleAnimSpritePal_MudSand[] = INCBIN_U32("graphics/battle_anims/sprites/mud_sand.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PoisonBubble[] = INCBIN_U32("graphics/battle_anims/sprites/poison_bubble.4bpp.lz");
+const u32 gBattleAnimSpritePal_PoisonBubble[] = INCBIN_U32("graphics/battle_anims/sprites/poison_bubble.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_ToxicBubble[] = INCBIN_U32("graphics/battle_anims/sprites/toxic_bubble.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_HornHit2[] = INCBIN_U32("graphics/battle_anims/sprites/horn_hit_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_HornHit2[] = INCBIN_U32("graphics/battle_anims/sprites/horn_hit_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_AirWave2[] = INCBIN_U32("graphics/battle_anims/sprites/air_wave_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_AirWave2[] = INCBIN_U32("graphics/battle_anims/sprites/air_wave_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SmallBubbles[] = INCBIN_U32("graphics/battle_anims/sprites/small_bubbles.4bpp.lz");
+const u32 gBattleAnimSpritePal_SmallBubbles[] = INCBIN_U32("graphics/battle_anims/sprites/small_bubbles.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RoundShadow[] = INCBIN_U32("graphics/battle_anims/sprites/round_shadow.4bpp.lz");
+const u32 gBattleAnimSpritePal_RoundShadow[] = INCBIN_U32("graphics/battle_anims/sprites/round_shadow.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Sunlight[] = INCBIN_U32("graphics/battle_anims/sprites/sunlight.4bpp.lz");
+const u32 gBattleAnimSpritePal_Sunlight[] = INCBIN_U32("graphics/battle_anims/sprites/sunlight.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spore[] = INCBIN_U32("graphics/battle_anims/sprites/spore.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Spore[] = INCBIN_U32("graphics/battle_anims/sprites/spore.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Flower[] = INCBIN_U32("graphics/battle_anims/sprites/flower.4bpp.lz");
+const u32 gBattleAnimSpritePal_Flower[] = INCBIN_U32("graphics/battle_anims/sprites/flower.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RazorLeaf[] = INCBIN_U32("graphics/battle_anims/sprites/razor_leaf.4bpp.lz");
+const u32 gBattleAnimSpritePal_RazorLeaf[] = INCBIN_U32("graphics/battle_anims/sprites/razor_leaf.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MistCloud[] = INCBIN_U32("graphics/battle_anims/sprites/mist_cloud.4bpp.lz");
+const u32 gBattleAnimSpritePal_MistCloud[] = INCBIN_U32("graphics/battle_anims/sprites/mist_cloud.gbapal.lz");
+
+const u32 gFile_graphics_unknown_unknown_D1BE74_sheet[] = INCBIN_U32("graphics/unknown/unknown_D1BE74.4bpp.lz");
+const u32 gFile_graphics_unknown_unknown_D1BE74_palette[] = INCBIN_U32("graphics/unknown/unknown_D1BE74.gbapal.lz");
+const u32 gFile_graphics_unknown_unknown_D1BE74_tilemap[] = INCBIN_U32("graphics/unknown/unknown_D1BE74.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_WhirlwindLines[] = INCBIN_U32("graphics/battle_anims/sprites/whirlwind_lines.4bpp.lz");
+const u32 gBattleAnimSpritePal_WhirlwindLines[] = INCBIN_U32("graphics/battle_anims/sprites/whirlwind_lines.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GoldRing[] = INCBIN_U32("graphics/battle_anims/sprites/gold_ring.4bpp.lz");
+const u32 gBattleAnimSpritePal_GoldRing[] = INCBIN_U32("graphics/battle_anims/sprites/gold_ring.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BlueRing2[] = INCBIN_U32("graphics/battle_anims/sprites/blue_ring_2.gbapal.lz");
+const u32 gBattleAnimSpritePal_PurpleRing[] = INCBIN_U32("graphics/battle_anims/sprites/purple_ring.gbapal.lz");
+const u32 gBattleAnimSpritePal_BlueRing[] = INCBIN_U32("graphics/battle_anims/sprites/blue_ring.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GreenLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/green_light_wall.4bpp.lz");
+const u32 gBattleAnimSpritePal_GreenLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/green_light_wall.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BlueLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/blue_light_wall.gbapal.lz");
+const u32 gBattleAnimSpritePal_RedLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/red_light_wall.gbapal.lz");
+const u32 gBattleAnimSpritePal_GrayLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/gray_light_wall.gbapal.lz");
+const u32 gBattleAnimSpritePal_OrangeLightWall[] = INCBIN_U32("graphics/battle_anims/sprites/orange_light_wall.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BlackBall2[] = INCBIN_U32("graphics/battle_anims/sprites/black_ball_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_BlackBall2[] = INCBIN_U32("graphics/battle_anims/sprites/black_ball_2.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_PurpleGasCloud[] = INCBIN_U32("graphics/battle_anims/sprites/purple_gas_cloud.gbapal.lz");
+
+const u32 gFile_graphics_contest_judge_sheet[] = INCBIN_U32("graphics/contest/judge.4bpp.lz");
+const u32 gFile_graphics_contest_judge_palette[] = INCBIN_U32("graphics/contest/judge.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spark[] = INCBIN_U32("graphics/battle_anims/sprites/spark.4bpp.lz");
+const u32 gBattleAnimSpritePal_Spark[] = INCBIN_U32("graphics/battle_anims/sprites/spark.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SparkH[] = INCBIN_U32("graphics/battle_anims/sprites/spark_h.4bpp.lz");
+
+const u32 gBattleAnimBgImage_Dark[] = INCBIN_U32("graphics/battle_anims/backgrounds/dark.4bpp.lz");
+const u32 gBattleAnimBgPalette_Dark[] = INCBIN_U32("graphics/battle_anims/backgrounds/dark.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Dark[] = INCBIN_U32("graphics/battle_anims/backgrounds/dark.bin.lz");
+
+const u32 gMetalShineGfx[] = INCBIN_U32("graphics/battle_anims/masks/metal_shine.4bpp.lz");
+const u32 gMetalShinePalette[] = INCBIN_U32("graphics/battle_anims/masks/metal_shine.gbapal.lz");
+const u32 gMetalShineTilemap[] = INCBIN_U32("graphics/battle_anims/masks/metal_shine.bin.lz");
+
+const u32 gUnusedGfx_Goosuto[] = INCBIN_U32("graphics/unused/goosuto.4bpp.lz"); // ghost
+const u32 gUnusedPal_Goosuto[] = INCBIN_U32("graphics/unused/goosuto.gbapal.lz");
+const u32 gUnusedTilemap_Goosuto[] = INCBIN_U32("graphics/unused/goosuto.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_YellowStar[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_star.4bpp.lz");
+const u32 gBattleAnimSpritePal_YellowStar[] = INCBIN_U32("graphics/battle_anims/sprites/yellow_star.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_LargeFreshEgg[] = INCBIN_U32("graphics/battle_anims/sprites/large_fresh_egg.4bpp.lz");
+const u32 gBattleAnimSpritePal_LargeFreshEgg[] = INCBIN_U32("graphics/battle_anims/sprites/large_fresh_egg.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_ShadowBall[] = INCBIN_U32("graphics/battle_anims/sprites/shadow_ball.4bpp.lz");
+const u32 gBattleAnimSpritePal_ShadowBall[] = INCBIN_U32("graphics/battle_anims/sprites/shadow_ball.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Lick[] = INCBIN_U32("graphics/battle_anims/sprites/lick.4bpp.lz");
+const u32 gBattleAnimSpritePal_Lick[] = INCBIN_U32("graphics/battle_anims/sprites/lick.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_VoidLines[] = INCBIN_U32("graphics/battle_anims/sprites/void_lines.4bpp.lz");
+const u32 gBattleAnimSpritePal_VoidLines[] = INCBIN_U32("graphics/battle_anims/sprites/void_lines.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_String[] = INCBIN_U32("graphics/battle_anims/sprites/string.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_String[] = INCBIN_U32("graphics/battle_anims/sprites/string.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_WebThread[] = INCBIN_U32("graphics/battle_anims/sprites/web_thread.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_SpiderWeb[] = INCBIN_U32("graphics/battle_anims/sprites/spider_web.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Lightbulb[] = INCBIN_U32("graphics/battle_anims/sprites/lightbulb.4bpp.lz");
+const u32 gBattleAnimSpritePal_Lightbulb[] = INCBIN_U32("graphics/battle_anims/sprites/lightbulb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Slash[] = INCBIN_U32("graphics/battle_anims/sprites/slash.4bpp.lz");
+const u32 gBattleAnimSpritePal_Slash[] = INCBIN_U32("graphics/battle_anims/sprites/slash.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_FocusEnergy[] = INCBIN_U32("graphics/battle_anims/sprites/focus_energy.4bpp.lz");
+const u32 gBattleAnimSpritePal_FocusEnergy[] = INCBIN_U32("graphics/battle_anims/sprites/focus_energy.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SphereToCube[] = INCBIN_U32("graphics/battle_anims/sprites/sphere_to_cube.4bpp.lz");
+const u32 gBattleAnimSpritePal_SphereToCube[] = INCBIN_U32("graphics/battle_anims/sprites/sphere_to_cube.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Psychic[] = INCBIN_U32("graphics/battle_anims/backgrounds/psychic.4bpp.lz");
+const u32 gBattleAnimBgPalette_Psychic[] = INCBIN_U32("graphics/battle_anims/backgrounds/psychic.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Psychic[] = INCBIN_U32("graphics/battle_anims/backgrounds/psychic.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_Eye[] = INCBIN_U32("graphics/battle_anims/sprites/eye.4bpp.lz");
+const u32 gBattleAnimSpritePal_Eye[] = INCBIN_U32("graphics/battle_anims/sprites/eye.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Tendrils[] = INCBIN_U32("graphics/battle_anims/sprites/tendrils.4bpp.lz");
+const u32 gBattleAnimSpritePal_Tendrils[] = INCBIN_U32("graphics/battle_anims/sprites/tendrils.gbapal.lz");
+
+const u32 gHealthboxSinglesPlayerGfx[] = INCBIN_U32("graphics/battle_interface/healthbox_singles_player.4bpp.lz");
+const u32 gHealthboxSinglesOpponentGfx[] = INCBIN_U32("graphics/battle_interface/healthbox_singles_opponent.4bpp.lz");
+const u32 gHealthboxDoublesPlayerGfx[] = INCBIN_U32( "graphics/battle_interface/healthbox_doubles_player.4bpp.lz");
+const u32 gHealthboxDoublesOpponentGfx[] = INCBIN_U32("graphics/battle_interface/healthbox_doubles_opponent.4bpp.lz");
+const u32 gHealthboxSafariGfx[] = INCBIN_U32("graphics/battle_interface/healthbox_safari.4bpp.lz");
+
+const u32 gUnusedGfx_Shadow[] = INCBIN_U32("graphics/unused/shadow.4bpp.lz");
+const u32 gUnusedPal_Shadow[] = INCBIN_U32("graphics/unused/shadow.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_LockOn[] = INCBIN_U32("graphics/battle_anims/sprites/lock_on.4bpp.lz");
+const u32 gBattleAnimSpritePal_LockOn[] = INCBIN_U32("graphics/battle_anims/sprites/lock_on.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_OpeningEye[] = INCBIN_U32("graphics/battle_anims/sprites/opening_eye.4bpp.lz");
+const u32 gBattleAnimSpritePal_OpeningEye[] = INCBIN_U32("graphics/battle_anims/sprites/opening_eye.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RoundWhiteHalo[] = INCBIN_U32("graphics/battle_anims/sprites/round_white_halo.4bpp.lz");
+const u32 gBattleAnimSpritePal_RoundWhiteHalo[] = INCBIN_U32("graphics/battle_anims/sprites/round_white_halo.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_TealAlert[] = INCBIN_U32("graphics/battle_anims/sprites/teal_alert.4bpp.lz");
+const u32 gBattleAnimSpritePal_TealAlert[] = INCBIN_U32("graphics/battle_anims/sprites/teal_alert.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_FangAttack[] = INCBIN_U32("graphics/battle_anims/sprites/fang_attack.4bpp.lz");
+const u32 gBattleAnimSpritePal_FangAttack[] = INCBIN_U32("graphics/battle_anims/sprites/fang_attack.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleHandOutline[] = INCBIN_U32("graphics/battle_anims/sprites/purple_hand_outline.4bpp.lz");
+const u32 gBattleAnimSpritePal_PurpleHandOutline[] = INCBIN_U32("graphics/battle_anims/sprites/purple_hand_outline.gbapal.lz");
+
+const u32 gFile_graphics_battle_anims_masks_curse_sheet[] = INCBIN_U32("graphics/battle_anims/masks/curse.4bpp.lz");
+const u32 gFile_graphics_battle_anims_masks_curse_tilemap[] = INCBIN_U32("graphics/battle_anims/masks/curse.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_Pencil[] = INCBIN_U32("graphics/battle_anims/sprites/pencil.4bpp.lz");
+const u32 gBattleAnimSpritePal_Pencil[] = INCBIN_U32("graphics/battle_anims/sprites/pencil.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spiral[] = INCBIN_U32("graphics/battle_anims/sprites/spiral.4bpp.lz");
+const u32 gBattleAnimSpritePal_Spiral[] = INCBIN_U32("graphics/battle_anims/sprites/spiral.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Moon[] = INCBIN_U32("graphics/battle_anims/sprites/moon.4bpp.lz");
+const u32 gBattleAnimSpritePal_Moon[] = INCBIN_U32("graphics/battle_anims/sprites/moon.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GreenSparkle[] = INCBIN_U32("graphics/battle_anims/sprites/green_sparkle.4bpp.lz");
+const u32 gBattleAnimSpritePal_GreenSparkle[] = INCBIN_U32("graphics/battle_anims/sprites/green_sparkle.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SnoreZ[] = INCBIN_U32("graphics/battle_anims/sprites/snore_z.4bpp.lz");
+const u32 gBattleAnimSpritePal_SnoreZ[] = INCBIN_U32("graphics/battle_anims/sprites/snore_z.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Explosion[] = INCBIN_U32("graphics/battle_anims/sprites/explosion.4bpp.lz");
+const u32 gBattleAnimSpritePal_Explosion[] = INCBIN_U32("graphics/battle_anims/sprites/explosion.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Nail[] = INCBIN_U32("graphics/battle_anims/sprites/nail.4bpp.lz");
+const u32 gBattleAnimSpritePal_Nail[] = INCBIN_U32("graphics/battle_anims/sprites/nail.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GhostlySpirit[] = INCBIN_U32("graphics/battle_anims/sprites/ghostly_spirit.4bpp.lz");
+const u32 gBattleAnimSpritePal_GhostlySpirit[] = INCBIN_U32("graphics/battle_anims/sprites/ghostly_spirit.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WarmRock[] = INCBIN_U32("graphics/battle_anims/sprites/warm_rock.4bpp.lz");
+const u32 gBattleAnimSpritePal_WarmRock[] = INCBIN_U32("graphics/battle_anims/sprites/warm_rock.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PunchImpact[] = INCBIN_U32("graphics/battle_anims/sprites/punch_impact.4bpp.lz");
+const u32 gBattleAnimSpritePal_PunchImpact[] = INCBIN_U32("graphics/battle_anims/sprites/punch_impact.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_BreakingEgg[] = INCBIN_U32("graphics/battle_anims/sprites/breaking_egg.4bpp.lz");
+const u32 gBattleAnimSpritePal_BreakingEgg[] = INCBIN_U32("graphics/battle_anims/sprites/breaking_egg.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_ThinRing[] = INCBIN_U32("graphics/battle_anims/sprites/thin_ring.4bpp.lz");
+const u32 gBattleAnimSpritePal_ThinRing[] = INCBIN_U32("graphics/battle_anims/sprites/thin_ring.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MusicNotes2[] = INCBIN_U32("graphics/battle_anims/sprites/music_notes_2.4bpp.lz");
+const u32 gBattleAnimSpritePal_MusicNotes2[] = INCBIN_U32("graphics/battle_anims/sprites/music_notes_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Bell[] = INCBIN_U32("graphics/battle_anims/sprites/bell.4bpp.lz");
+const u32 gBattleAnimSpritePal_Bell[] = INCBIN_U32("graphics/battle_anims/sprites/bell.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SpeedDust[] = INCBIN_U32("graphics/battle_anims/sprites/speed_dust.4bpp.lz");
+const u32 gBattleAnimSpritePal_SpeedDust[] = INCBIN_U32("graphics/battle_anims/sprites/speed_dust.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_TornMetal[] = INCBIN_U32("graphics/battle_anims/sprites/torn_metal.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_ThoughtBubble[] = INCBIN_U32("graphics/battle_anims/sprites/thought_bubble.4bpp.lz");
+const u32 gBattleAnimSpritePal_ThoughtBubble[] = INCBIN_U32("graphics/battle_anims/sprites/thought_bubble.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Finger[] = INCBIN_U32("graphics/battle_anims/sprites/finger.4bpp.lz");
+const u32 gBattleAnimSpritePal_Finger[] = INCBIN_U32("graphics/battle_anims/sprites/finger.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MagentaHeart[] = INCBIN_U32("graphics/battle_anims/sprites/magenta_heart.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_PinkHeart[] = INCBIN_U32("graphics/battle_anims/sprites/pink_heart.gbapal.lz");
+const u32 gBattleAnimSpritePal_MagentaHeart[] = INCBIN_U32("graphics/battle_anims/sprites/magenta_heart.gbapal.lz");
+const u32 gBattleAnimSpritePal_RedHeart[] = INCBIN_U32("graphics/battle_anims/sprites/red_heart.gbapal.lz");
+
+const u32 gBattleAnimBg_AttractGfx[] = INCBIN_U32("graphics/battle_anims/backgrounds/attract.4bpp.lz");
+const u32 gBattleAnimBg_AttractPal[] = INCBIN_U32("graphics/battle_anims/backgrounds/attract.gbapal.lz");
+const u32 gBattleAnimBg_AttractTilemap[] = INCBIN_U32("graphics/battle_anims/backgrounds/attract.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_RedOrb[] = INCBIN_U32("graphics/battle_anims/sprites/red_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_RedOrb[] = INCBIN_U32("graphics/battle_anims/sprites/red_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_CircleOfLight[] = INCBIN_U32("graphics/battle_anims/sprites/circle_of_light.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_ElectricOrbs[] = INCBIN_U32("graphics/battle_anims/sprites/electric_orbs.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Electricity[] = INCBIN_U32("graphics/battle_anims/sprites/electricity.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_ElectricOrbs[] = INCBIN_U32("graphics/battle_anims/sprites/electric_orbs.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Finger2[] = INCBIN_U32("graphics/battle_anims/sprites/finger_2.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_MovementWaves[] = INCBIN_U32("graphics/battle_anims/sprites/movement_waves.4bpp.lz");
+const u32 gBattleAnimSpritePal_MovementWaves[] = INCBIN_U32("graphics/battle_anims/sprites/movement_waves.gbapal.lz");
+
+const u32 gBattleAnim_ScaryFacePal[] = INCBIN_U32("graphics/battle_anims/backgrounds/scary_face.gbapal.lz");
+const u32 gBattleAnim_ScaryFaceGfx[] = INCBIN_U32("graphics/battle_anims/backgrounds/scary_face.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_EyeSparkle[] = INCBIN_U32("graphics/battle_anims/sprites/eye_sparkle.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_EyeSparkle[] = INCBIN_U32("graphics/battle_anims/sprites/eye_sparkle.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Anger[] = INCBIN_U32("graphics/battle_anims/sprites/anger.4bpp.lz");
+const u32 gBattleAnimSpritePal_Anger[] = INCBIN_U32("graphics/battle_anims/sprites/anger.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Conversion[] = INCBIN_U32("graphics/battle_anims/sprites/conversion.4bpp.lz");
+const u32 gBattleAnimSpritePal_Conversion[] = INCBIN_U32("graphics/battle_anims/sprites/conversion.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Angel[] = INCBIN_U32("graphics/battle_anims/sprites/angel.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Angel[] = INCBIN_U32("graphics/battle_anims/sprites/angel.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Devil[] = INCBIN_U32("graphics/battle_anims/sprites/devil.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Devil[] = INCBIN_U32("graphics/battle_anims/sprites/devil.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Swipe[] = INCBIN_U32("graphics/battle_anims/sprites/swipe.4bpp.lz");
+const u32 gBattleAnimSpritePal_Swipe[] = INCBIN_U32("graphics/battle_anims/sprites/swipe.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_Roots[] = INCBIN_U32("graphics/battle_anims/sprites/roots.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Roots[] = INCBIN_U32("graphics/battle_anims/sprites/roots.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_ItemBag[] = INCBIN_U32("graphics/battle_anims/sprites/item_bag.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_ItemBag[] = INCBIN_U32("graphics/battle_anims/sprites/item_bag.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_TriForceTriangle[] = INCBIN_U32("graphics/battle_anims/sprites/tri_attack_triangle.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_TriForceTriangle[] = INCBIN_U32("graphics/battle_anims/sprites/tri_attack_triangle.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_LetterZ[] = INCBIN_U32("graphics/battle_anims/sprites/letter_z.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_LetterZ[] = INCBIN_U32("graphics/battle_anims/sprites/letter_z.4bpp.lz");
+
+const u32 gBattleAnimBgPalette_Impact[] = INCBIN_U32("graphics/battle_anims/backgrounds/impact.gbapal.lz");
+const u32 gBattleAnimBgImage_Impact[] = INCBIN_U32("graphics/battle_anims/backgrounds/impact.4bpp.lz");
+const u32 gBattleAnimBgTilemap_ImpactOpponent[] = INCBIN_U32("graphics/battle_anims/backgrounds/impact_opponent.bin.lz");
+
+const u32 gBattleAnimBgTilemap_ImpactPlayer[] = INCBIN_U32("graphics/battle_anims/backgrounds/impact_player.bin.lz");
+const u32 gBattleAnimBgTilemap_ImpactContests[] = INCBIN_U32("graphics/battle_anims/backgrounds/impact_contests.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_JaggedMusicNote[] = INCBIN_U32("graphics/battle_anims/sprites/jagged_music_note.4bpp.lz");
+const u32 gBattleAnimSpritePal_JaggedMusicNote[] = INCBIN_U32("graphics/battle_anims/sprites/jagged_music_note.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Spotlight[] = INCBIN_U32("graphics/battle_anims/sprites/spotlight.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Pokeball[] = INCBIN_U32("graphics/battle_anims/sprites/pokeball.4bpp.lz");
+const u32 gBattleAnimSpritePal_Pokeball[] = INCBIN_U32("graphics/battle_anims/sprites/pokeball.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RapidSpin[] = INCBIN_U32("graphics/battle_anims/sprites/rapid_spin.4bpp.lz");
+const u32 gBattleAnimSpritePal_RapidSpin[] = INCBIN_U32("graphics/battle_anims/sprites/rapid_spin.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MilkBottle[] = INCBIN_U32("graphics/battle_anims/sprites/milk_bottle.4bpp.lz");
+const u32 gBattleAnimSpritePal_MilkBottle[] = INCBIN_U32("graphics/battle_anims/sprites/milk_bottle.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WispFire[] = INCBIN_U32("graphics/battle_anims/sprites/wisp_fire.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_WispOrb[] = INCBIN_U32("graphics/battle_anims/sprites/wisp_orb.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_WispOrb[] = INCBIN_U32("graphics/battle_anims/sprites/wisp_orb.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_GoldStars[] = INCBIN_U32("graphics/battle_anims/sprites/gold_stars.4bpp.lz");
+const u32 gBattleAnimSpritePal_GoldStars[] = INCBIN_U32("graphics/battle_anims/sprites/gold_stars.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_EclipsingOrb[] = INCBIN_U32("graphics/battle_anims/sprites/eclipsing_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_EclipsingOrb[] = INCBIN_U32("graphics/battle_anims/sprites/eclipsing_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PinkPetal[] = INCBIN_U32("graphics/battle_anims/sprites/pink_petal.4bpp.lz");
+const u32 gBattleAnimSpritePal_PinkPetal[] = INCBIN_U32("graphics/battle_anims/sprites/pink_petal.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GrayOrb[] = INCBIN_U32("graphics/battle_anims/sprites/gray_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_GrayOrb[] = INCBIN_U32("graphics/battle_anims/sprites/gray_orb.gbapal.lz");
+
+const u32 gBattleAnimSpritePal_BlueOrb[] = INCBIN_U32("graphics/battle_anims/sprites/blue_orb.gbapal.lz");
+const u32 gBattleAnimSpritePal_RedOrb2[] = INCBIN_U32("graphics/battle_anims/sprites/red_orb_2.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Drill[] = INCBIN_U32("graphics/battle_anims/backgrounds/drill.4bpp.lz");
+const u32 gBattleAnimBgPalette_Drill[] = INCBIN_U32("graphics/battle_anims/backgrounds/drill.gbapal.lz");
+
+const u32 gBattleAnimBgPalette_Sky[] = INCBIN_U32("graphics/battle_anims/backgrounds/sky.gbapal.lz");
+
+const u32 gBattleAnimBgTilemap_Drill[] = INCBIN_U32("graphics/battle_anims/backgrounds/drill.bin.lz");
+const u32 gBattleAnimBgTilemap_DrillContests[] = INCBIN_U32("graphics/battle_anims/backgrounds/drill_contests.bin.lz");
+
+const u32 gBattleAnimBgImage_Aurora[] = INCBIN_U32("graphics/battle_anims/backgrounds/aurora.4bpp.lz");
+const u32 gBattleAnimBgPalette_Aurora[] = INCBIN_U32("graphics/battle_anims/backgrounds/aurora.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Aurora[] = INCBIN_U32("graphics/battle_anims/backgrounds/aurora.bin.lz");
+
+const u32 gBattleAnimBgTilemap_HighspeedOpponent[] = INCBIN_U32("graphics/battle_anims/backgrounds/highspeed_opponent.bin.lz");
+const u32 gBattleAnimBgPalette_Highspeed[] = INCBIN_U32("graphics/battle_anims/backgrounds/highspeed.gbapal.lz");
+
+const u32 gBattleAnimBgPalette_Bug[] = INCBIN_U32("graphics/battle_anims/backgrounds/bug.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Highspeed[] = INCBIN_U32("graphics/battle_anims/backgrounds/highspeed.4bpp.lz");
+const u32 gBattleAnimBgTilemap_HighspeedPlayer[] = INCBIN_U32("graphics/battle_anims/backgrounds/highspeed_player.bin.lz");
+
+const u32 gBattleAnim_MorningSunGfx[] = INCBIN_U32("graphics/battle_anims/masks/light_beam.4bpp.lz");
+const u32 gBattleAnim_MorningSunPal[] = INCBIN_U32("graphics/battle_anims/masks/light_beam.gbapal.lz");
+const u32 gBattleAnim_MorningSunTilemap[] = INCBIN_U32("graphics/battle_anims/masks/light_beam.bin.lz");
+
+const u32 gBattleAnimBgTilemap_GuillotineOpponent[] = INCBIN_U32("graphics/battle_anims/backgrounds/guillotine_opponent.bin.lz");
+const u32 gBattleAnimBgTilemap_GuillotinePlayer[] = INCBIN_U32("graphics/battle_anims/backgrounds/guillotine_player.bin.lz");
+const u32 gBattleAnimBgTilemap_GuillotineContests[] = INCBIN_U32("graphics/battle_anims/backgrounds/guillotine_contests.bin.lz");
+
+const u32 gBattleAnimBgImage_Guillotine[] = INCBIN_U32("graphics/battle_anims/backgrounds/guillotine.4bpp.lz");
+const u32 gBattleAnimBgPalette_Guillotine[] = INCBIN_U32("graphics/battle_anims/backgrounds/guillotine.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Thunder[] = INCBIN_U32("graphics/battle_anims/backgrounds/thunder.4bpp.lz");
+const u32 gBattleAnimBgPalette_Thunder[] = INCBIN_U32("graphics/battle_anims/backgrounds/thunder.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Thunder[] = INCBIN_U32("graphics/battle_anims/backgrounds/thunder.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_PainSplit[] = INCBIN_U32("graphics/battle_anims/sprites/pain_split.4bpp.lz");
+const u32 gBattleAnimSpritePal_PainSplit[] = INCBIN_U32("graphics/battle_anims/sprites/pain_split.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_HandsAndFeet[] = INCBIN_U32("graphics/battle_anims/sprites/hands_and_feet.4bpp.lz");
+const u32 gBattleAnimSpritePal_HandsAndFeet[] = INCBIN_U32("graphics/battle_anims/sprites/hands_and_feet.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Confetti[] = INCBIN_U32("graphics/battle_anims/sprites/confetti.4bpp.lz");
+const u32 gBattleAnimSpritePal_Confetti[] = INCBIN_U32("graphics/battle_anims/sprites/confetti.gbapal.lz");
+
+const u32 gSubstituteDollPal[] = INCBIN_U32("graphics/battle_anims/sprites/substitute.gbapal.lz");
+const u32 gSubstituteDollGfx[] = INCBIN_U32("graphics/battle_anims/sprites/substitute.4bpp.lz");
+const u32 gSubstituteDollTilemap[] = INCBIN_U32("graphics/battle_anims/sprites/substitute.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_GreenStar[] = INCBIN_U32("graphics/battle_anims/sprites/green_star.4bpp.lz");
+const u32 gBattleAnimSpritePal_GreenStar[] = INCBIN_U32("graphics/battle_anims/sprites/green_star.gbapal.lz");
+
+const u32 gFile_graphics_misc_confetti_sheet[] = INCBIN_U32("graphics/misc/confetti.4bpp.lz");
+const u32 gFile_graphics_misc_confetti_palette[] = INCBIN_U32("graphics/misc/confetti.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PinkCloud[] = INCBIN_U32("graphics/battle_anims/sprites/pink_cloud.4bpp.lz");
+const u32 gBattleAnimSpritePal_PinkCloud[] = INCBIN_U32("graphics/battle_anims/sprites/pink_cloud.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SweatDrop[] = INCBIN_U32("graphics/battle_anims/sprites/sweat_drop.4bpp.lz");
+const u32 gBattleAnimSpritePal_SweatDrop[] = INCBIN_U32("graphics/battle_anims/sprites/sweat_drop.gbapal.lz");
+
+const u32 gBattleStatMask_Gfx[] = INCBIN_U32("graphics/battle_anims/masks/stat.4bpp.lz");
+const u32 gBattleStatMask1_Tilemap[] = INCBIN_U32("graphics/battle_anims/masks/stat_tilemap_1.bin.lz");
+const u32 gBattleStatMask2_Tilemap[] = INCBIN_U32("graphics/battle_anims/masks/stat_tilemap_2.bin.lz");
+
+const u32 gBattleStatMask1_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat1.gbapal.lz");
+const u32 gBattleStatMask2_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat2.gbapal.lz");
+const u32 gBattleStatMask3_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat3.gbapal.lz");
+const u32 gBattleStatMask4_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat4.gbapal.lz");
+const u32 gBattleStatMask5_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat5.gbapal.lz");
+const u32 gBattleStatMask6_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat6.gbapal.lz");
+const u32 gBattleStatMask7_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat7.gbapal.lz");
+const u32 gBattleStatMask8_Pal[] = INCBIN_U32("graphics/battle_anims/masks/stat8.gbapal.lz");
+
+const u32 gCureBubblesGfx[] = INCBIN_U32("graphics/battle_anims/masks/cure_bubbles.4bpp.lz");
+const u32 gCureBubblesPal[] = INCBIN_U32("graphics/battle_anims/masks/cure_bubbles.gbapal.lz");
+const u32 gCureBubblesTilemap[] = INCBIN_U32("graphics/battle_anims/masks/cure_bubbles.bin.lz");
+
+const u32 gBattleAnimSpritePal_PurpleScratch[] = INCBIN_U32("graphics/battle_anims/sprites/purple_scratch.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_PurpleScratch[] = INCBIN_U32("graphics/battle_anims/sprites/purple_scratch.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleSwipe[] = INCBIN_U32("graphics/battle_anims/sprites/purple_swipe.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_GuardRing[] = INCBIN_U32("graphics/battle_anims/sprites/guard_ring.4bpp.lz");
+const u32 gBattleAnimSpritePal_GuardRing[] = INCBIN_U32("graphics/battle_anims/sprites/guard_ring.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_TagHand[] = INCBIN_U32("graphics/battle_anims/sprites/tag_hand.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_NoiseLine[] = INCBIN_U32("graphics/battle_anims/sprites/noise_line.4bpp.lz");
+
+const u32 gUnknown_D2EC24_Gfx[] = INCBIN_U32("graphics/battle_anims/masks/unknown_D2EC24.4bpp.lz");
+const u32 gUnknown_D2EC24_Tilemap[] = INCBIN_U32("graphics/battle_anims/masks/unknown_D2EC24.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_SmallRedEye[] = INCBIN_U32("graphics/battle_anims/sprites/small_red_eye.4bpp.lz");
+const u32 gBattleAnimSpritePal_SmallRedEye[] = INCBIN_U32("graphics/battle_anims/sprites/small_red_eye.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_HollowOrb[] = INCBIN_U32("graphics/battle_anims/sprites/hollow_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_HollowOrb[] = INCBIN_U32("graphics/battle_anims/sprites/hollow_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_XSign[] = INCBIN_U32("graphics/battle_anims/sprites/x_sign.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_BluegreenOrb[] = INCBIN_U32("graphics/battle_anims/sprites/bluegreen_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_BluegreenOrb[] = INCBIN_U32("graphics/battle_anims/sprites/bluegreen_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PawPrint[] = INCBIN_U32("graphics/battle_anims/sprites/paw_print.4bpp.lz");
+const u32 gBattleAnimSpritePal_PawPrint[] = INCBIN_U32("graphics/battle_anims/sprites/paw_print.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_PurpleFlame[] = INCBIN_U32("graphics/battle_anims/sprites/purple_flame.4bpp.lz");
+const u32 gBattleAnimSpritePal_PurpleFlame[] = INCBIN_U32("graphics/battle_anims/sprites/purple_flame.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RedBall[] = INCBIN_U32("graphics/battle_anims/sprites/red_ball.4bpp.lz");
+const u32 gBattleAnimSpritePal_RedBall[] = INCBIN_U32("graphics/battle_anims/sprites/red_ball.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SmellingsaltEffect[] = INCBIN_U32("graphics/battle_anims/sprites/smellingsalt_effect.4bpp.lz");
+const u32 gBattleAnimSpritePal_SmellingsaltEffect[] = INCBIN_U32("graphics/battle_anims/sprites/smellingsalt_effect.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MagnifyingGlass[] = INCBIN_U32("graphics/battle_anims/sprites/magnifying_glass.4bpp.lz");
+const u32 gBattleAnimSpritePal_MagnifyingGlass[] = INCBIN_U32("graphics/battle_anims/sprites/magnifying_glass.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Meteor[] = INCBIN_U32("graphics/battle_anims/sprites/meteor.4bpp.lz");
+const u32 gBattleAnimSpritePal_Meteor[] = INCBIN_U32("graphics/battle_anims/sprites/meteor.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_FlatRock[] = INCBIN_U32("graphics/battle_anims/sprites/flat_rock.4bpp.lz");
+const u32 gBattleAnimSpritePal_FlatRock[] = INCBIN_U32("graphics/battle_anims/sprites/flat_rock.gbapal.lz");
+
+const u16 gUnknown_8D2FBB4[] = INCBIN_U16("graphics/interface/unk_8D2FBB4.gbapal");
+
+#include "data/graphics/pokemon.h"
+#include "data/graphics/trainers.h"
+
+const u8 gMonIcon_QuestionMark[] = INCBIN_U8("graphics/pokemon/question_mark/icon.4bpp");
+const u8 gMonFootprint_QuestionMark[] = INCBIN_U8("graphics/pokemon/question_mark/footprint.1bpp");
+
+const u32 gFile_graphics_battle_transitions_vs_frame_sheet[] = INCBIN_U32("graphics/battle_transitions/vs_frame.4bpp.lz");
+const u32 gFile_graphics_battle_transitions_vs_frame_tilemap[] = INCBIN_U32("graphics/battle_transitions/vs_frame.bin.lz");
+const u32 gFile_graphics_battle_transitions_vs_frame_palette[] = INCBIN_U32("graphics/battle_transitions/vs_frame.gbapal.lz");
+
+const u32 gVsLettersGfx[] = INCBIN_U32("graphics/battle_transitions/vs.4bpp.lz");
+
+#include "data/graphics/battle_terrain.h"
+
+const u32 gBattleAnimSpriteGfx_FlyingDirt[] = INCBIN_U32("graphics/battle_anims/sprites/flying_dirt.4bpp.lz");
+
+const u32 gFile_graphics_battle_anims_backgrounds_sandstorm_brew_tilemap[] = INCBIN_U32("graphics/battle_anims/backgrounds/sandstorm_brew.bin.lz");
+const u32 gFile_graphics_battle_anims_backgrounds_sandstorm_brew_sheet[] = INCBIN_U32("graphics/battle_anims/backgrounds/sandstorm_brew.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_FlyingDirt[] = INCBIN_U32("graphics/battle_anims/sprites/flying_dirt.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_MetalSoundWaves[] = INCBIN_U32("graphics/battle_anims/sprites/metal_sound_waves.4bpp.lz");
+const u32 gBattleAnimSpritePal_MetalSoundWaves[] = INCBIN_U32("graphics/battle_anims/sprites/metal_sound_waves.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Ice[] = INCBIN_U32("graphics/battle_anims/backgrounds/ice.4bpp.lz");
+const u32 gBattleAnimBgPalette_Ice[] = INCBIN_U32("graphics/battle_anims/backgrounds/ice.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Ice[] = INCBIN_U32("graphics/battle_anims/backgrounds/ice.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_IcicleSpear[] = INCBIN_U32("graphics/battle_anims/sprites/icicle_spear.4bpp.lz");
+const u32 gBattleAnimSpritePal_IcicleSpear[] = INCBIN_U32("graphics/battle_anims/sprites/icicle_spear.gbapal.lz");
+
+const u32 gContestNextTurnGfx[] = INCBIN_U32("graphics/contest/next_turn.4bpp.lz");
+const u8 gFile_graphics_contest_nextturn_numbers[] = INCBIN_U8("graphics/contest/next_turn_numbers.4bpp");
+const u8 gFile_graphics_contest_nextturn_random[] = INCBIN_U8("graphics/contest/next_turn_random.4bpp");
+
+const u32 gBattleAnimSpriteGfx_GlowyRedOrb[] = INCBIN_U32("graphics/battle_anims/sprites/glowy_red_orb.4bpp.lz");
+const u32 gBattleAnimSpritePal_GlowyRedOrb[] = INCBIN_U32("graphics/battle_anims/sprites/glowy_red_orb.gbapal.lz");
+const u32 gBattleAnimSpritePal_GlowyGreenOrb[] = INCBIN_U32("graphics/battle_anims/sprites/glowy_green_orb.gbapal.lz");
+const u32 gBattleAnimSpritePal_SleepPowder[] = INCBIN_U32("graphics/battle_anims/sprites/sleep_powder.gbapal.lz");
+const u32 gBattleAnimSpritePal_StunSpore[] = INCBIN_U32("graphics/battle_anims/sprites/stun_spore.gbapal.lz");
+
+const u32 gContestApplauseGfx[] = INCBIN_U32("graphics/contest/applause.4bpp.lz");
+const u8 gFile_graphics_contest_applause_meter[] = INCBIN_U8("graphics/contest/applause_meter.4bpp");
+
+const u16 gFile_graphics_contest_nextturn[] = INCBIN_U16("graphics/contest/next_turn.gbapal");
+
+const u32 gBattleAnimSpriteGfx_Splash[] = INCBIN_U32("graphics/battle_anims/sprites/splash.4bpp.lz");
+const u32 gBattleAnimSpritePal_Splash[] = INCBIN_U32("graphics/battle_anims/sprites/splash.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_SweatBead[] = INCBIN_U32("graphics/battle_anims/sprites/sweat_bead.4bpp.lz");
+
+const u32 gBattleAnimSpriteGfx_Pokeblock[] = INCBIN_U32("graphics/battle_anims/sprites/pokeblock.4bpp.lz");
+const u32 gBattleAnimSpritePal_Pokeblock[] = INCBIN_U32("graphics/battle_anims/sprites/pokeblock.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Gem1[] = INCBIN_U32("graphics/battle_anims/sprites/gem_1.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Gem2[] = INCBIN_U32("graphics/battle_anims/sprites/gem_2.4bpp.lz");
+const u32 gBattleAnimSpriteGfx_Gem3[] = INCBIN_U32("graphics/battle_anims/sprites/gem_3.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Gem1[] = INCBIN_U32("graphics/battle_anims/sprites/gem_1.gbapal.lz");
+
+const u32 gBattleAnimBgImage_InAir[] = INCBIN_U32("graphics/battle_anims/backgrounds/in_air.4bpp.lz");
+const u32 gBattleAnimBgPalette_InAir[] = INCBIN_U32("graphics/battle_anims/backgrounds/in_air.gbapal.lz");
+const u32 gBattleAnimBgTilemap_InAir[] = INCBIN_U32("graphics/battle_anims/backgrounds/in_air.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_Protect[] = INCBIN_U32("graphics/battle_anims/sprites/protect.4bpp.lz");
+const u32 gBattleAnimSpritePal_Protect[] = INCBIN_U32("graphics/battle_anims/sprites/protect.gbapal.lz");
+
+const u32 gFile_graphics_battle_anims_backgrounds_water_muddy_palette[] = INCBIN_U32("graphics/battle_anims/backgrounds/water_muddy.gbapal.lz");
+
+const u32 gFile_graphics_battle_interface_enemy_mon_shadow_sheet[] = INCBIN_U32("graphics/battle_interface/enemy_mon_shadow.4bpp.lz");
+
+const u32 gFile_graphics_battle_interface_ball_status_bar_sheet[] = INCBIN_U32("graphics/battle_interface/ball_status_bar.4bpp.lz");
+
+const u8 gMonIcon_Egg[] = INCBIN_U8("graphics/pokemon/egg/icon.4bpp");
+
+const u32 gBattleAnimBgImage_Ghost[] = INCBIN_U32("graphics/battle_anims/backgrounds/ghost.4bpp.lz");
+const u32 gBattleAnimBgPalette_Ghost[] = INCBIN_U32("graphics/battle_anims/backgrounds/ghost.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Ghost[] = INCBIN_U32("graphics/battle_anims/backgrounds/ghost.bin.lz");
+
+const u32 gBattleAnimSpritePal_WhipHit[] = INCBIN_U32("graphics/battle_anims/sprites/whip_hit.gbapal.lz");
+
+const u32 gBattleAnimBgPalette_Solarbeam[] = INCBIN_U32("graphics/battle_anims/backgrounds/solarbeam.gbapal.lz");
+
+const u32 gFile_graphics_unknown_unknown_E7CFB0_tilemap[] = INCBIN_U32("graphics/unknown/unknown_E7CFB0.bin.lz");
+
+const u32 gFile_graphics_berry_blender_center_sheet[] = INCBIN_U32("graphics/berry_blender/center.8bpp.lz");
+
+const u32 gFile_graphics_berry_blender_outer_sheet[] = INCBIN_U32("graphics/berry_blender/outer.4bpp.lz");
+const u32 gFile_graphics_berry_blender_outer_map_tilemap[] = INCBIN_U32("graphics/berry_blender/outer_map.bin.lz");
+
+const u32 gBattleAnimBgPalette_Cosmic[] = INCBIN_U32("graphics/battle_anims/backgrounds/cosmic.gbapal.lz");
+const u32 gBattleAnimBgImage_Cosmic[] = INCBIN_U32("graphics/battle_anims/backgrounds/cosmic.4bpp.lz");
+const u32 gBattleAnimBgTilemap_Cosmic[] = INCBIN_U32("graphics/battle_anims/backgrounds/cosmic.bin.lz");
+
+const u32 gBattleAnimSpritePal_SlamHit2[] = INCBIN_U32("graphics/battle_anims/sprites/slam_hit_2.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_SlamHit2[] = INCBIN_U32("graphics/battle_anims/sprites/slam_hit_2.4bpp.lz");
+
+const u32 gBattleAnimFogTilemap[] = INCBIN_U32("graphics/battle_anims/backgrounds/fog.bin.lz");
+
+const u32 gBattleAnimSpritePal_WeatherBall[] = INCBIN_U32("graphics/battle_anims/sprites/weather_ball.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_WeatherBall[] = INCBIN_U32("graphics/battle_anims/sprites/weather_ball.4bpp.lz");
+
+const u32 gBattleAnimBgTilemap_ScaryFacePlayer[] = INCBIN_U32("graphics/battle_anims/backgrounds/scary_face_player.bin.lz");
+const u32 gBattleAnimBgTilemap_ScaryFaceOpponent[] = INCBIN_U32("graphics/battle_anims/backgrounds/scary_face_opponent.bin.lz");
+const u32 gBattleAnimBgTilemap_ScaryFaceContest[] = INCBIN_U32("graphics/battle_anims/backgrounds/scary_face_contest.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_Hail[] = INCBIN_U32("graphics/battle_anims/sprites/hail.4bpp.lz");
+const u32 gBattleAnimSpritePal_Hail[] = INCBIN_U32("graphics/battle_anims/sprites/hail.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_GreenSpike[] = INCBIN_U32("graphics/battle_anims/sprites/green_spike.4bpp.lz");
+const u32 gBattleAnimSpritePal_GreenSpike[] = INCBIN_U32("graphics/battle_anims/sprites/green_spike.gbapal.lz");
+const u32 gBattleAnimSpritePal_WhiteCircleOfLight[] = INCBIN_U32("graphics/battle_anims/sprites/white_circle_of_light.gbapal.lz");
+const u32 gBattleAnimSpritePal_GlowyBlueOrb[] = INCBIN_U32("graphics/battle_anims/sprites/glowy_blue_orb.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_Recycle[] = INCBIN_U32("graphics/battle_anims/sprites/recycle.4bpp.lz");
+const u32 gBattleAnimSpritePal_Recycle[] = INCBIN_U32("graphics/battle_anims/sprites/recycle.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_RedParticles[] = INCBIN_U32("graphics/battle_anims/sprites/red_particles.4bpp.lz");
+const u32 gBattleAnimSpritePal_RedParticles[] = INCBIN_U32("graphics/battle_anims/sprites/red_particles.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_DirtMound[] = INCBIN_U32("graphics/battle_anims/sprites/dirt_mound.4bpp.lz");
+const u32 gBattleAnimSpritePal_DirtMound[] = INCBIN_U32("graphics/battle_anims/sprites/dirt_mound.gbapal.lz");
+
+const u32 gBattleAnimBgImage_Fissure[] = INCBIN_U32("graphics/battle_anims/backgrounds/fissure.4bpp.lz");
+const u32 gBattleAnimBgPalette_Fissure[] = INCBIN_U32("graphics/battle_anims/backgrounds/fissure.gbapal.lz");
+const u32 gBattleAnimBgTilemap_Fissure[] = INCBIN_U32("graphics/battle_anims/backgrounds/fissure.bin.lz");
+
+const u32 gBattleAnimSpriteGfx_Bird[] = INCBIN_U32("graphics/battle_anims/sprites/bird.4bpp.lz");
+const u32 gBattleAnimSpritePal_Bird[] = INCBIN_U32("graphics/battle_anims/sprites/bird.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_CrossImpact[] = INCBIN_U32("graphics/battle_anims/sprites/cross_impact.4bpp.lz");
+const u32 gBattleAnimSpritePal_CrossImpact[] = INCBIN_U32("graphics/battle_anims/sprites/cross_impact.gbapal.lz");
+
+const u32 gFile_graphics_battle_anims_backgrounds_water_sheet[] = INCBIN_U32("graphics/battle_anims/backgrounds/water.4bpp.lz");
+const u32 gFile_graphics_battle_anims_backgrounds_water_palette[] = INCBIN_U32("graphics/battle_anims/backgrounds/water.gbapal.lz");
+const u32 gFile_graphics_unknown_unknown_E81D14_tilemap[] = INCBIN_U32("graphics/unknown/unknown_E81D14.bin.lz");
+const u32 gFile_graphics_unknown_unknown_E81FE4_tilemap[] = INCBIN_U32("graphics/unknown/unknown_E81FE4.bin.lz");
+const u32 gFile_graphics_unknown_unknown_E822B8_tilemap[] = INCBIN_U32("graphics/unknown/unknown_E822B8.bin.lz");
+
+const u32 gBattleAnimSpritePal_Slash2[] = INCBIN_U32("graphics/battle_anims/sprites/slash_2.gbapal.lz");
+
+const u32 gBattleAnimSpriteGfx_WhiteShadow[] = INCBIN_U32("graphics/battle_anims/sprites/white_shadow.4bpp.lz");
+const u32 gBattleAnimSpritePal_WhiteShadow[] = INCBIN_U32("graphics/battle_anims/sprites/white_shadow.gbapal.lz");
+
+const u32 gPartyMenuBg_Gfx[] = INCBIN_U32("graphics/interface/party_menu_misc.4bpp.lz");
+const u32 gPartyMenuBg_Pal[] = INCBIN_U32("graphics/interface/party_menu_misc.gbapal.lz");
+const u32 gPartyMenuBg_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_misc.bin.lz");
+
+const u32 gPartyMenuPokeball_Gfx[] = INCBIN_U32("graphics/interface/party_menu_pokeball.4bpp.lz");
+const u32 gPartyMenuPokeballSmall_Gfx[] = INCBIN_U32("graphics/interface/party_menu_pokeball_small.4bpp.lz"); //unused
+const u32 gPartyMenuPokeball_Pal[] = INCBIN_U32("graphics/interface/party_menu_pokeball.gbapal.lz");
+
+const u32 gStatusGfx_Icons[] = INCBIN_U32("graphics/interface/status_icons.4bpp.lz");
+const u32 gStatusPal_Icons[] = INCBIN_U32("graphics/interface/status_icons.gbapal.lz");
+
+const u32 gUnknown_8E830CC[] = INCBIN_U32("graphics/item_menu/bag_tiles.4bpp.lz");
+
+const u32 gUnknown_8E832C0[] = INCBIN_U32("graphics/item_menu/bag_tilemap1.bin.lz"); // bag menu
+const u32 gUnknown_8E83444[] = INCBIN_U32("graphics/item_menu/bag_tilemap2.bin.lz"); // PC deposit items
+
+const u32 gBagBgPalette[] = INCBIN_U32("graphics/item_menu/bag_pal1.gbapal.lz"); // palette 1 (Boy + misc Pal)
+const u32 gBagBgPalette_FemaleOverride[] = INCBIN_U32("graphics/item_menu/bag_pal2.gbapal.lz"); // palette 2 (Girl)
+
+const u32 gUnknown_8E8362C[] = INCBIN_U32("graphics/interface/unk_8E8362C.4bpp.lz");
+const u32 gUnknown_8E83DBC[] = INCBIN_U32("graphics/interface/unk_8E83DBC.4bpp.lz");
+const u32 gUnknown_8E84560[] = INCBIN_U32("graphics/interface/unk_8E84560.gbapal.lz");
+
+const u32 gFile_graphics_interface_bag_swap_sheet[] = INCBIN_U32("graphics/interface/bag_swap.4bpp.lz");
+const u32 gFile_graphics_interface_bag_swap_palette[] = INCBIN_U32("graphics/interface/bag_swap.gbapal.lz");
+
+const u32 gUnknown_8E845D8[] = INCBIN_U32("graphics/tm_case/unk_8E845D8.4bpp.lz");
+const u32 gUnknown_8E84A24[] = INCBIN_U32("graphics/tm_case/unk_8E84A24.bin.lz");
+const u32 gUnknown_8E84B70[] = INCBIN_U32("graphics/tm_case/unk_8E84B70.bin.lz");
+const u32 gUnknown_8E84CB0[] = INCBIN_U32("graphics/tm_case/unk_8E84CB0.gbapal.lz");
+const u32 gUnknown_8E84D20[] = INCBIN_U32("graphics/tm_case/unk_8E84D20.gbapal.lz");
+const u32 gTMCase_TMSpriteGfx[] = INCBIN_U32("graphics/tm_case/unk_8E84D90.4bpp.lz");
+const u32 gUnknown_8E84F20[] = INCBIN_U32("graphics/tm_case/unk_8E84F20.gbapal.lz");
+const u32 gUnknown_8E85068[] = INCBIN_U32("graphics/tm_case/unk_8E85068.gbapal.lz");
+
+const u8 gItemPcTiles[] = INCBIN_U8("graphics/item_pc/unk_8E85090.4bpp.lz");
+const u32 gItemPcBgPals[] = INCBIN_U32("graphics/item_pc/unk_8E85408.gbapal.lz");
+const u8 gItemPcTilemap[] = INCBIN_U8("graphics/item_pc/unk_8E85458.bin.lz");
+
+const u32 gBerryPouchSpriteTiles[] = INCBIN_U32("graphics/berry_pouch/unk_8E8560C.4bpp.lz");
+const u8 gBerryPouchBgGfx[] = INCBIN_U8("graphics/berry_pouch/unk_8E859D0.4bpp.lz");
+const u32 gBerryPouchBgPals[] = INCBIN_U32("graphics/berry_pouch/unk_8E85BA4.gbapal.lz");
+const u32 gBerryPouchBgPal0FemaleOverride[] = INCBIN_U32("graphics/berry_pouch/unk_8E85BF4.gbapal.lz");
+const u32 gBerryPouchSpritePalette[] = INCBIN_U32("graphics/berry_pouch/unk_8E85C1C.gbapal.lz");
+const u8 gBerryPouchBg1Tilemap[] = INCBIN_U8("graphics/berry_pouch/unk_8E85C44.bin.lz");
+
+const u32 gBuyMenuFrame_Gfx[] = INCBIN_U32("graphics/shop_menu/shop_menu.4bpp.lz");
+const u32 gBuyMenuFrame_Tilemap[] = INCBIN_U32("graphics/shop_menu/shop_tilemap.bin");
+const u32 gBuyMenuFrame_TmHmTilemap[] = INCBIN_U32("graphics/shop_menu/shop_tm_hm_tilemap.bin");
+const u32 gBuyMenuFrame_Pal[] = INCBIN_U32("graphics/shop_menu/shop_menu.gbapal.lz");
+
+const u32 gUnknown_8E861A8[] = INCBIN_U32("graphics/unknown/unknown_E861A8.bin.lz");
+
+const u8 gUnknown_8E86240[] = INCBIN_U8("graphics/teachy_tv/tiles.4bpp.lz");
+const u8 gUnknown_8E86BE8[] = INCBIN_U8("graphics/teachy_tv/bg1_tilemap.bin.lz");
+const u8 gUnknown_8E86D6C[] = INCBIN_U8("graphics/teachy_tv/bg2_tilemap.bin.lz");
+const u32 gUnknown_8E86F98[] = INCBIN_U32("graphics/teachy_tv/palettes.gbapal.lz");
+
+const u32 gUnknown_8E87010[] = INCBIN_U32("graphics/unknown/unknown_E87010.gbapal.lz");
+
+#include "data/graphics/items.h"
+
+const u32 gBattleAnimSpritePal_Shock3[] = INCBIN_U32("graphics/battle_anims/sprites/shock_3.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Shock3[] = INCBIN_U32("graphics/battle_anims/sprites/shock_3.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_WhiteFeather[] = INCBIN_U32("graphics/battle_anims/sprites/white_feather.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_WhiteFeather[] = INCBIN_U32("graphics/battle_anims/sprites/white_feather.4bpp.lz");
+
+const u32 gBattleAnimSpritePal_Sparkle6[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_6.gbapal.lz");
+const u32 gBattleAnimSpriteGfx_Sparkle6[] = INCBIN_U32("graphics/battle_anims/sprites/sparkle_6.4bpp.lz");
+
+const u32 gGhostPalette[] = INCBIN_U32("graphics/pokemon/ghost/front.gbapal.lz");
+const u32 gGhostFrontPic[] = INCBIN_U32("graphics/pokemon/ghost/front.4bpp.lz");
+
+#include "data/graphics/mail.h"
+
+const u16 gFireRedMenuElements1_Pal[] = INCBIN_U16("graphics/interface/dex_caught_pokeball.gbapal");
+const u16 gFireRedMenuElements2_Pal[] = INCBIN_U16("graphics/interface/pokemon_types.gbapal");
+const u8 gFireRedMenuElements_Gfx[] = INCBIN_U8("graphics/interface/dex_caught_pokeball_and_pokemon_types.4bpp");
+
+const u16 gUnknown_8E97DDC[] = INCBIN_U16("graphics/interface/learn_move.gbapal");
+const u32 gUnknown_8E97DFC[] = INCBIN_U32("graphics/interface/learn_move.4bpp.lz");
+const u32 gUnknown_8E97EC4[] = INCBIN_U32("graphics/interface/learn_move.bin.lz");
+
+const u16 gUnknown_8E97FE4[] = INCBIN_U16("graphics/interface/naming_screen_8E97FE4.gbapal");
+const u16 gUnknown_8E98004[] = INCBIN_U16("graphics/interface/naming_screen_8E98004.gbapal");
+const u16 gNamingScreenMenu_Pal[] = INCBIN_U16("graphics/interface/naming_screen_8E98024.gbapal");
+const u16 gUnknown_8E98044[] = INCBIN_U16("graphics/interface/naming_screen_8E98044.gbapal");
+const u16 gUnknown_8E98064[] = INCBIN_U16("graphics/interface/naming_screen_8E98064.gbapal");
+const u16 gUnknown_8E98084[] = INCBIN_U16("graphics/interface/naming_screen_8E98084.gbapal");
+const u16 gUnknown_8E980A4[] = INCBIN_U16("graphics/interface/naming_screen_8E980A4.gbapal");
+const u16 gUnknown_8E980C4[] = INCBIN_U16("graphics/interface/naming_screen_8E980C4.gbapal");
+
+const u32 gNamingScreenMenu_Gfx[] = INCBIN_U32("graphics/interface/naming_screen_menu.4bpp.lz");
+const u32 gUnknown_8E982BC[] = INCBIN_U32("graphics/interface/naming_screen_menu.bin.lz");
+const u32 gUnknown_8E98398[] = INCBIN_U32("graphics/interface/naming_screen_E98398.bin.lz");
+const u32 gUnknown_8E98458[] = INCBIN_U32("graphics/interface/naming_screen_E98458.bin.lz");
+const u32 gUnknown_8E98518[] = INCBIN_U32("graphics/interface/naming_screen_E98518.bin.lz");
+
+const u32 gUnknown_8E985D8[] = INCBIN_U32("graphics/interface/naming_screen_8E985D8.4bpp");
+const u32 gUnknown_8E98858[] = INCBIN_U32("graphics/interface/naming_screen_8E98858.4bpp");
+const u32 gUnknown_8E98A38[] = INCBIN_U32("graphics/interface/naming_screen_8E98A38.4bpp");
+const u32 gUnknown_8E98C18[] = INCBIN_U32("graphics/interface/naming_screen_8E98C18.4bpp");
+const u32 gUnknown_8E98CB8[] = INCBIN_U32("graphics/interface/naming_screen_8E98CB8.4bpp");
+const u32 gUnknown_8E98D58[] = INCBIN_U32("graphics/interface/naming_screen_8E98D58.4bpp");
+const u32 gUnknown_8E98DF8[] = INCBIN_U32("graphics/interface/naming_screen_8E98DF8.4bpp");
+const u32 gUnknown_8E98E98[] = INCBIN_U32("graphics/interface/naming_screen_8E98E98.4bpp");
+const u32 gUnknown_8E98F38[] = INCBIN_U32("graphics/interface/naming_screen_8E98F38.4bpp");
+const u32 gUnknown_8E98FD8[] = INCBIN_U32("graphics/interface/naming_screen_8E98FD8.4bpp");
+const u32 gUnknown_8E990D8[] = INCBIN_U32("graphics/interface/naming_screen_8E990D8.4bpp");
+const u32 gUnknown_8E990F8[] = INCBIN_U32("graphics/interface/naming_screen_8E990F8.4bpp");
+
+const u8 gUnknown_8E99118[] = INCBIN_U8("graphics/tm_case/unk_8E99118.4bpp");
+
+const u16 gKantoTrainerCard_Pal[] = INCBIN_U16("graphics/trainer_card/0star.gbapal");
+const u32 gKantoTrainerCard_Gfx[] = INCBIN_U32("graphics/trainer_card/card.4bpp.lz");
+const u16 gHoennTrainerCard_Pal[] = INCBIN_U16("graphics/trainer_card/0star_em.gbapal");
+const u32 gHoennTrainerCard_Gfx[] = INCBIN_U32("graphics/trainer_card/card_em.4bpp.lz");
+
+const u16 gEasyChatMode_Pal[] = INCBIN_U16("graphics/link_rfu/unk_8E99DAC.gbapal");
+const u32 gEasyChatWindow_Gfx[] = INCBIN_U32("graphics/link_rfu/unk_8E99DAC.4bpp.lz");
+const u32 gEasyChatWindow_Tilemap[] = INCBIN_U32("graphics/link_rfu/unk_8E99E74.bin.lz");
+
+const u16 gUnknown_8E99F24[] = INCBIN_U16("graphics/link_rfu/unk_8E9A168.gbapal");
+const u32 gEasyChatSelectGroupHelp_Tiles[] = INCBIN_U32("graphics/link_rfu/unk_8E99F44.4bpp.lz");
+const u32 gEasyChatModeIcons_Tiles[] = INCBIN_U32("graphics/link_rfu/unk_8E9A168.4bpp.lz");
+
+const u32 gUnknown_8E9A460[] = INCBIN_U32("graphics/interface/trainer_memo.4bpp.lz");
+const u32 gUnknown_8E9B310[] = INCBIN_U32("graphics/interface/trainer_memo_pal1.gbapal");
+const u32 gUnknown_8E9B3B0[] = INCBIN_U32("graphics/interface/trainer_memo_pal2.gbapal");
+const u32 gUnknown_8E9B3D0[] = INCBIN_U32("graphics/interface/trainer_memo_pal3.gbapal");
+
+const u32 gUnknown_8E9B3F0[] = INCBIN_U32("graphics/interface/summary_exp_bar.4bpp.lz");
+const u32 gUnknown_8E9B4B8[] = INCBIN_U32("graphics/interface/summary_hp_bar.4bpp.lz");
+const u16 gUnknown_8E9B578[] = INCBIN_U16("graphics/interface/summary_exp_bar.gbapal"); // hp bar uses this too
+
+const u32 gUnknown_8E9B598[] = INCBIN_U32("graphics/interface/trainer_memo.bin.lz");
+const u32 gUnknown_8E9B750[] = INCBIN_U32("graphics/interface/trainer_memo_2.bin.lz");
+const u32 gUnknown_8E9B950[] = INCBIN_U32("graphics/interface/trainer_memo_3.bin.lz");
+const u32 gUnknown_8E9BA9C[] = INCBIN_U32("graphics/interface/trainer_memo_4.bin.lz");
+const u32 gUnknown_8E9BBCC[] = INCBIN_U32("graphics/interface/trainer_memo_5.bin.lz");
+
+const u16 gUnknown_8E9BD08[] = INCBIN_U16("graphics/unknown/unknown_E9BD08.gbapal"); // might be an alternate unused palette of the link_rfu gfx below.
+
+const u32 gEasyChatRedRectangularCursor_Tiles[] = INCBIN_U32("graphics/interface/link_rfu_frame.4bpp.lz");
+const u16 gUnknown_8E9BF28[] = INCBIN_U16("graphics/interface/link_rfu_frame.gbapal");
+const u32 gUnknown_8E9BF48[] = INCBIN_U32("graphics/interface/link_rfu_status.4bpp.lz");
+
+const u16 gUnknown_8E9C14C[] = INCBIN_U16("graphics/interface/pokedex_abc.gbapal");
+const u32 gUnknown_8E9C16C[] = INCBIN_U32("graphics/interface/pokedex_abc.4bpp.lz");
+
+const u16 gUnknown_8E9C3D8[] = INCBIN_U16("graphics/interface/box_tiles_pal1.gbapal");
+const u16 gUnknown_8E9C3F8[] = INCBIN_U16("graphics/interface/box_tiles_pal2.gbapal");
+const u16 gUnknown_8E9C418[] = INCBIN_U16("graphics/interface/box_tiles_pal3.gbapal");
+const u32 gUnknown_8E9C438[] = INCBIN_U32("graphics/interface/box_tiles.4bpp.lz");
+
+const u32 gUnknown_8E9CAEC[] = INCBIN_U32("graphics/unknown/unknown_E9CAEC.bin.lz");
+
+const u16 gUnknown_8E9CB9C[] = INCBIN_U16("graphics/misc/markings2.gbapal");
+const u16 gUnknown_8E9CBBC[] = INCBIN_U16("graphics/misc/markings2.4bpp");
+
+const u16 gTradeMenu_Pal[] = INCBIN_U16("graphics/trade/menu.gbapal");
+const u16 gTradeButtons_Pal[] = INCBIN_U16("graphics/trade/unknown_DDB444.gbapal");
+const u16 gTradeMenu_Gfx[] = INCBIN_U16("graphics/trade/menu.4bpp");
+const u16 gTradeButtons_Gfx[] = INCBIN_U16("graphics/trade/buttons.4bpp");
+const u16 gUnknown_8E9E9DC[] = INCBIN_U16("graphics/unused/unused_DDCEE4.bin");
+const u16 gUnknown_8E9E9FC[] = INCBIN_U16("graphics/trade/unknown_DDCF04.bin");
+const u16 gTradeMenuMonBox_Tilemap[] = INCBIN_U16("graphics/trade/menu_mon_box.bin");
+
+const u16 gFameCheckerBgPals[] = INCBIN_U16("data/graphics/fame_checker_bg.gbapal");
+const u16 gFameCheckerBgTiles[] = INCBIN_U16("data/graphics/fame_checker_bg.4bpp");
+const u16 gFameCheckerBg3Tilemap[] = INCBIN_U16("data/graphics/fame_checker_tilemap3.bin");
+const u16 gFameCheckerBg2Tilemap[] = INCBIN_U16("data/graphics/fame_checker_tilemap2.bin");
+
+const u16 gLinkMiscMenu_Pal[] = INCBIN_U16("graphics/interface/union_room_chat.gbapal");
+const u32 gLinkMiscMenu_Gfx[] = INCBIN_U32("graphics/interface/union_room_chat.4bpp.lz");
+const u32 gLinkMiscMenu_Tilemap[] = INCBIN_U32("graphics/interface/union_room_chat.bin.lz");
+const u32 gUnionRoomChatIcons[] = INCBIN_U32("graphics/interface/union_room_chat_icons.4bpp.lz");
+
+const u16 gTilesetPalettes_General[][16] =
+{
+    INCBIN_U16("data/tilesets/primary/general/palettes/00.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/01.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/02.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/03.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/04.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/05.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/06.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/07.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/08.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/09.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/10.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/11.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/12.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/13.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/14.gbapal"),
+    INCBIN_U16("data/tilesets/primary/general/palettes/15.gbapal"),
+};
+
+const u32 gTilesetTiles_General[] = INCBIN_U32("data/tilesets/primary/general/tiles.4bpp.lz");
+
+const u8 gBerryFixGameboy_Pal[] = INCBIN_U8("graphics/berry_fix/gba_small.gbapal");
+const u8 gBerryFixGameboy_Gfx[] = INCBIN_U8("graphics/berry_fix/gba_small.4bpp.lz");
+const u8 gBerryFixGameboy_Tilemap[] = INCBIN_U8("graphics/berry_fix/gba_small.bin.lz");
+const u8 gBerryFixGameboyLogo_Pal[] = INCBIN_U8("graphics/berry_fix/logo.gbapal");
+const u8 gBerryFixGameboyLogo_Gfx[] = INCBIN_U8("graphics/berry_fix/logo.4bpp.lz");
+const u8 gBerryFixGameboyLogo_Tilemap[] = INCBIN_U8("graphics/berry_fix/logo.bin.lz");
+const u8 gBerryFixGbaTransfer_Pal[] = INCBIN_U8("graphics/berry_fix/gba_transfer.gbapal");
+const u8 gBerryFixGbaTransfer_Gfx[] = INCBIN_U8("graphics/berry_fix/gba_transfer.4bpp.lz");
+const u8 gBerryFixGbaTransfer_Tilemap[] = INCBIN_U8("graphics/berry_fix/gba_transfer.bin.lz");
+const u8 gBerryFixGbaTransferHighlight_Pal[] = INCBIN_U8("graphics/berry_fix/gba_transfer_highlight.gbapal");
+const u8 gBerryFixGbaTransferHighlight_Gfx[] = INCBIN_U8("graphics/berry_fix/gba_transfer_highlight.4bpp.lz");
+const u8 gBerryFixGbaTransferHighlight_Tilemap[] = INCBIN_U8("graphics/berry_fix/gba_transfer_highlight.bin.lz");
+const u8 gBerryFixGbaTransferError_Pal[] = INCBIN_U8("graphics/berry_fix/gba_transfer_error.gbapal");
+const u8 gBerryFixGbaTransferError_Gfx[] = INCBIN_U8("graphics/berry_fix/gba_transfer_error.4bpp.lz");
+const u8 gBerryFixGbaTransferError_Tilemap[] = INCBIN_U8("graphics/berry_fix/gba_transfer_error.bin.lz");
+const u8 gBerryFixWindow_Pal[] = INCBIN_U8("graphics/berry_fix/window.gbapal");
+const u8 gBerryFixWindow_Gfx[] = INCBIN_U8("graphics/berry_fix/window.4bpp.lz");
+const u8 gBerryFixWindow_Tilemap[] = INCBIN_U8("graphics/berry_fix/window.bin.lz");
+
+const u16 gTilesetPalettes_GenericBuilding1[][16] =
+{
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/00.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/01.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/02.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/03.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/04.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/05.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/06.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/07.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/08.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/09.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/10.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/11.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/12.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/13.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/14.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/generic_building1/palettes/15.gbapal"),
+};
+
+const u32 gTilesetTiles_GenericBuilding1[] = INCBIN_U32("data/tilesets/secondary/generic_building1/tiles.4bpp.lz");
+
+const u16 gTilesetPalettes_DepartmentStore[][16] =
+{
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/00.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/01.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/02.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/03.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/04.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/05.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/06.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/07.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/08.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/09.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/10.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/11.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/12.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/13.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/14.gbapal"),
+    INCBIN_U16("data/tilesets/secondary/department_store/palettes/15.gbapal"),
+};
+
+const u32 gTilesetTiles_DepartmentStore[] = INCBIN_U32("data/tilesets/secondary/department_store/tiles.4bpp.lz");
+
+const u16 gUnionRoomChatPanelBgPal_7[] = INCBIN_U16("graphics/interface/union_room_chat_panel.gbapal");
+const u32 gUnionRoomChatPanelBgTiles[] = INCBIN_U32("graphics/interface/union_room_chat_panel.4bpp.lz");
+const u32 gUnionRoomChatPanelBgMap[] = INCBIN_U32("graphics/interface/union_room_chat_panel.bin.lz");
+
+const u16 gCreditsMonBackdropPals[][16] =
+{
+    INCBIN_U16("graphics/credits/charizard.gbapal"),
+    INCBIN_U16("graphics/credits/venusaur.gbapal"),
+    INCBIN_U16("graphics/credits/blastoise.gbapal"),
+    INCBIN_U16("graphics/credits/pikachu.gbapal"),
+};
+
+const u32 gCreditsPokeballBgGfxTiles[] = INCBIN_U32("graphics/credits/unk_8EAAB98.4bpp.lz");
+const u32 gCreditsPokeballBgGfxMap[] = INCBIN_U32("graphics/credits/unk_8EAB30C.bin.lz");
+
+#ifdef FIRERED
+const u16 gGraphics_TitleScreen_GameTitleLogoPals[] = INCBIN_U16("graphics/title_screen/unk_8eab6c4.gbapal");
+const u8 gGraphics_TitleScreen_GameTitleLogoTiles[] = INCBIN_U8("graphics/title_screen/unk_8eab8c4.8bpp.lz");
+const u8 gGraphics_TitleScreen_GameTitleLogoMap[] = INCBIN_U8("graphics/title_screen/unk_8ead390.bin.lz");
+const u16 gGraphics_TitleScreen_BoxArtMonPals[] = INCBIN_U16("graphics/title_screen/unk_8ead5e8.gbapal");
+const u8 gGraphics_TitleScreen_BoxArtMonTiles[] = INCBIN_U8("graphics/title_screen/unk_8ead608.4bpp.lz");
+const u8 gGraphics_TitleScreen_BoxArtMonMap[] = INCBIN_U8("graphics/title_screen/unk_8eadee4.bin.lz");
+const u16 gGraphics_TitleScreen_BackgroundPals[] = INCBIN_U16("graphics/title_screen/unk_8eae094.gbapal");
+const u8 gGraphics_TitleScreen_CopyrightPressStartTiles[] = INCBIN_U8("graphics/title_screen/unk_8eae0b4.4bpp.lz");
+const u8 gGraphics_TitleScreen_CopyrightPressStartMap[] = INCBIN_U8("graphics/title_screen/unk_8eae374.bin.lz");
+const u16 gGraphics_TitleScreen_FireOrLeafPals[] = INCBIN_U16("graphics/title_screen/unk_8eae488.gbapal");
+const u32 gGraphics_TitleScreen_BlankObjTiles[] = INCBIN_U32("graphics/title_screen/unk_8eae4a8.4bpp.lz");
+#endif
+
+#ifdef LEAFGREEN
+const u16 gGraphics_TitleScreen_GameTitleLogoPals[] = INCBIN_U16("graphics/title_screen/unk_lg_8eab744.gbapal");
+const u8 gGraphics_TitleScreen_GameTitleLogoTiles[] = INCBIN_U8("graphics/title_screen/unk_lg_8eab944.8bpp.lz");
+const u8 gGraphics_TitleScreen_GameTitleLogoMap[] = INCBIN_U8("graphics/title_screen/unk_lg_8ead508.bin.lz");
+const u16 gGraphics_TitleScreen_BoxArtMonPals[] = INCBIN_U16("graphics/title_screen/unk_lg_8ead768.gbapal");
+const u8 gGraphics_TitleScreen_BoxArtMonTiles[] = INCBIN_U8("graphics/title_screen/unk_lg_8ead788.4bpp.lz");
+const u8 gGraphics_TitleScreen_BoxArtMonMap[] = INCBIN_U8("graphics/title_screen/unk_lg_8eae1ec.bin.lz");
+const u16 gGraphics_TitleScreen_BackgroundPals[] = INCBIN_U16("graphics/title_screen/unk_lg_8eae388.gbapal");
+const u8 gGraphics_TitleScreen_CopyrightPressStartTiles[] = INCBIN_U8("graphics/title_screen/unk_8eae0b4.4bpp.lz");
+const u8 gGraphics_TitleScreen_CopyrightPressStartMap[] = INCBIN_U8("graphics/title_screen/unk_8eae374.bin.lz");
+const u16 gGraphics_TitleScreen_FireOrLeafPals[] = INCBIN_U16("graphics/title_screen/unk_lg_8eae77c.gbapal");
+const u32 gGraphics_TitleScreen_BlankObjTiles[] = INCBIN_U32("graphics/title_screen/unk_8eae4a8.4bpp.lz");
+#endif
+
+const u16 gCreditsAllRightsReservedGfxPal[] = INCBIN_U16("graphics/credits/unk_8EAE548.gbapal");
+const u8 gCreditsAllRightsReservedGfxTiles[] = INCBIN_U8("graphics/credits/unk_8EAE548.4bpp.lz");
+const u8 gCreditsAllRightsReservedGfxMap[] = INCBIN_U8("graphics/credits/unk_8EAE548.bin.lz");
+
+const u32 gUnknown_8EAEA00[] = INCBIN_U32("graphics/link/gba.gbapal");
+const u32 gTradeGba2_Pal[] = INCBIN_U32("graphics/link/gba_pal2.gbapal");
+const u32 gTradeGba_Gfx[] = INCBIN_U32("graphics/link/gba.4bpp");
+
+const u16 gUnknown_8EAFE80[] = INCBIN_U16("graphics/interface/blank2.gbapal");
+
+const u16 gUnknown_8EAFEA0[] = INCBIN_U16("graphics/berry_crush/berry_crush.gbapal");
+const u16 gUnknown_8EAFF60[] = INCBIN_U16("graphics/unknown/unknown_EAFF60.gbapal");
+const u32 gUnknown_8EAFFC0[] = INCBIN_U32("graphics/berry_crush/berry_crush.4bpp.lz");
+const u32 gUnknown_8EB0ADC[] = INCBIN_U32("graphics/berry_crush/data_EB0ADC.bin.lz");
diff --git a/src/heal_location.c b/src/heal_location.c
index 89d9478c0..5c31e2df3 100644
--- a/src/heal_location.c
+++ b/src/heal_location.c
@@ -124,13 +124,13 @@ void SetBlackoutRespawnWarpAndHealerNpc(struct WarpData * warp)
 
     if (VarGet(VAR_MAP_SCENE_TRAINER_TOWER) == 1)
     {
-        if (!gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2)
+        if (!gSaveBlock1Ptr->trainerTower[gSaveBlock1Ptr->towerChallengeId].spokeToOwner)
             VarSet(VAR_MAP_SCENE_TRAINER_TOWER, 0);
         gSpecialVar_LastTalked = 1;
         warp->x = 4;
         warp->y = 11;
-        warp->mapGroup = MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_LOBBY);
-        warp->mapNum = MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY);
+        warp->mapGroup = MAP_GROUP(TRAINER_TOWER_LOBBY);
+        warp->mapNum = MAP_NUM(TRAINER_TOWER_LOBBY);
         warp->warpId = 0xFF;
     }
     else
@@ -155,7 +155,7 @@ void SetBlackoutRespawnWarpAndHealerNpc(struct WarpData * warp)
             warp->x = 5;
             warp->y = 4;
         }
-        else if (sBlackoutRespawnHealCenterMapIdxs[healLocationIdx - 1][0] == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_LOBBY) && sBlackoutRespawnHealCenterMapIdxs[healLocationIdx - 1][1] == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY))
+        else if (sBlackoutRespawnHealCenterMapIdxs[healLocationIdx - 1][0] == MAP_GROUP(TRAINER_TOWER_LOBBY) && sBlackoutRespawnHealCenterMapIdxs[healLocationIdx - 1][1] == MAP_NUM(TRAINER_TOWER_LOBBY))
         {
             warp->x = 4;
             warp->y = 11;
diff --git a/src/help_system.c b/src/help_system.c
index 4a4d927c5..8eabd4e1d 100644
--- a/src/help_system.c
+++ b/src/help_system.c
@@ -10,9 +10,7 @@
 #include "strings.h"
 #include "text.h"
 #include "blit.h"
-#include "event_data.h"
 #include "constants/songs.h"
-#include "constants/flags.h"
 
 extern u8 gGlyphInfo[];
 
@@ -33,7 +31,7 @@ struct HelpSystemVideoState
 
 static EWRAM_DATA u8 sMapTilesBackup[BG_CHAR_SIZE] = {0};
 EWRAM_DATA u8 gUnknown_203F174 = 0;
-EWRAM_DATA u8 gUnknown_203F175 = 0;
+EWRAM_DATA bool8 gHelpSystemToggleWithRButtonDisabled = FALSE;
 static EWRAM_DATA u8 sDelayTimer = 0;
 static EWRAM_DATA u8 sInHelpSystem = 0;
 static EWRAM_DATA struct HelpSystemVideoState sVideoState = {0};
@@ -53,7 +51,7 @@ u8 RunHelpSystemCallback(void)
         sInHelpSystem = 0;
         if (gSaveBlock2Ptr->optionsButtonMode != OPTIONS_BUTTON_MODE_HELP)
             return 0;
-        if (JOY_NEW(R_BUTTON) && gUnknown_203F175 == 1)
+        if (JOY_NEW(R_BUTTON) && gHelpSystemToggleWithRButtonDisabled == TRUE)
             return 0;
         if (JOY_NEW(L_BUTTON | R_BUTTON))
         {
@@ -92,10 +90,10 @@ u8 RunHelpSystemCallback(void)
         HelpSystem_FillPanel2();
         HelpSystem_PrintText_Row61(gString_Help);
         sub_813BD14(1);
-        if (sub_812B40C() == TRUE)
-            sub_812BC54(&gHelpSystemListMenu, gHelpSystemListMenuItems);
+        if (HelpSystem_UpdateHasntSeenIntro() == TRUE)
+            HelpSystemSubroutine_PrintWelcomeMessage(&gHelpSystemListMenu, gHelpSystemListMenuItems);
         else
-            sub_812BCA8(&gHelpSystemListMenu, gHelpSystemListMenuItems);
+            HelpSystemSubroutine_WelcomeEndGotoMenu(&gHelpSystemListMenu, gHelpSystemListMenuItems);
         sub_813BE78(1);
         sub_813BF50(1);
         CommitTilemap();
@@ -110,7 +108,7 @@ u8 RunHelpSystemCallback(void)
         sVideoState.state = 5;
         break;
     case 5:
-        if (!sub_812BB9C(&gHelpSystemListMenu, gHelpSystemListMenuItems))
+        if (!RunHelpMenuSubroutine(&gHelpSystemListMenu, gHelpSystemListMenuItems))
         {
             PlaySE(SE_HELP_CL);
             sVideoState.state = 6;
@@ -981,9 +979,9 @@ void HelpSystem_FillPanel1(void)
 void HelpSystem_InitListMenuController(struct HelpSystemListMenu * a0, u8 a1, u8 a2)
 {
     gHelpSystemListMenu.sub = a0->sub;
-    gHelpSystemListMenu.field_0C = a1;
-    gHelpSystemListMenu.field_0D = a2;
-    gHelpSystemListMenu.field_0E = 0;
+    gHelpSystemListMenu.itemsAbove = a1;
+    gHelpSystemListMenu.cursorPos = a2;
+    gHelpSystemListMenu.state = 0;
     if (gHelpSystemListMenu.sub.totalItems < gHelpSystemListMenu.sub.maxShowed)
         gHelpSystemListMenu.sub.maxShowed = gHelpSystemListMenu.sub.totalItems;
     sub_813BDA4(0);
@@ -1007,7 +1005,7 @@ s32 HelpSystem_GetMenuInput(void)
     else if (JOY_NEW(A_BUTTON))
     {
         PlaySE(SE_SELECT);
-        return gHelpSystemListMenu.sub.items[gHelpSystemListMenu.field_0C + gHelpSystemListMenu.field_0D].index;
+        return gHelpSystemListMenu.sub.items[gHelpSystemListMenu.itemsAbove + gHelpSystemListMenu.cursorPos].index;
     }
     else if (JOY_NEW(B_BUTTON))
     {
@@ -1051,15 +1049,15 @@ void sub_813C75C(void)
     u8 r6 = gHelpSystemListMenu.sub.totalItems - 7;
     if (gHelpSystemListMenu.sub.totalItems > 7)
     {
-        s32 r4 = gHelpSystemListMenu.field_0C + gHelpSystemListMenu.field_0D;
+        s32 r4 = gHelpSystemListMenu.itemsAbove + gHelpSystemListMenu.cursorPos;
         sub_813C004(0, 0);
         if (r4 == 0)
             sub_813C004(1, 1);
-        else if (gHelpSystemListMenu.field_0C == 0 && gHelpSystemListMenu.field_0D != 0)
+        else if (gHelpSystemListMenu.itemsAbove == 0 && gHelpSystemListMenu.cursorPos != 0)
             sub_813C004(1, 1);
-        else if (gHelpSystemListMenu.field_0C == r6)
+        else if (gHelpSystemListMenu.itemsAbove == r6)
             sub_813C004(0, 1);
-        else if (gHelpSystemListMenu.field_0C != 0)
+        else if (gHelpSystemListMenu.itemsAbove != 0)
         {
             sub_813C004(0, 1);
             sub_813C004(1, 1);
@@ -1071,7 +1069,7 @@ void PrintListMenuItems(void)
 {
     u8 glyphHeight = GetFontAttribute(2, 1) + 1;
     s32 i;
-    s32 r5 = gHelpSystemListMenu.field_0C;
+    s32 r5 = gHelpSystemListMenu.itemsAbove;
 
     for (i = 0; i < gHelpSystemListMenu.sub.maxShowed; i++)
     {
@@ -1086,8 +1084,8 @@ void PlaceListMenuCursor(void)
 {
     u8 glyphHeight = GetFontAttribute(2, 1) + 1;
     u8 x = gHelpSystemListMenu.sub.left;
-    u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.field_0D;
-    HelpSystem_PrintTextAt(gFameCheckerText_ListMenuCursor, x, y);
+    u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.cursorPos;
+    HelpSystem_PrintTextAt(gText_SelectorArrow2, x, y);
 }
 
 void sub_813C860(u8 i)
@@ -1107,24 +1105,24 @@ u8 TryMoveCursor1(u8 dirn)
             r4 = 0;
         else
             r4 = gHelpSystemListMenu.sub.maxShowed - (gHelpSystemListMenu.sub.maxShowed / 2 + (gHelpSystemListMenu.sub.maxShowed & 1)) - 1;
-        if (gHelpSystemListMenu.field_0C == 0)
+        if (gHelpSystemListMenu.itemsAbove == 0)
         {
-            if (gHelpSystemListMenu.field_0D != 0)
+            if (gHelpSystemListMenu.cursorPos != 0)
             {
-                gHelpSystemListMenu.field_0D--;
+                gHelpSystemListMenu.cursorPos--;
                 return 1;
             }
             else
                 return 0;
         }
-        if (gHelpSystemListMenu.field_0D > r4)
+        if (gHelpSystemListMenu.cursorPos > r4)
         {
-            gHelpSystemListMenu.field_0D--;
+            gHelpSystemListMenu.cursorPos--;
             return 1;
         }
         else
         {
-            gHelpSystemListMenu.field_0C--;
+            gHelpSystemListMenu.itemsAbove--;
             return 2;
         }
     }
@@ -1134,24 +1132,24 @@ u8 TryMoveCursor1(u8 dirn)
             r4 = 0;
         else
             r4 = gHelpSystemListMenu.sub.maxShowed / 2 + (gHelpSystemListMenu.sub.maxShowed & 1);
-        if (gHelpSystemListMenu.field_0C == gHelpSystemListMenu.sub.totalItems - gHelpSystemListMenu.sub.maxShowed)
+        if (gHelpSystemListMenu.itemsAbove == gHelpSystemListMenu.sub.totalItems - gHelpSystemListMenu.sub.maxShowed)
         {
-            if (gHelpSystemListMenu.field_0D < gHelpSystemListMenu.sub.maxShowed - 1)
+            if (gHelpSystemListMenu.cursorPos < gHelpSystemListMenu.sub.maxShowed - 1)
             {
-                gHelpSystemListMenu.field_0D++;
+                gHelpSystemListMenu.cursorPos++;
                 return 1;
             }
             else
                 return 0;
         }
-        else if (gHelpSystemListMenu.field_0D < r4)
+        else if (gHelpSystemListMenu.cursorPos < r4)
         {
-            gHelpSystemListMenu.field_0D++;
+            gHelpSystemListMenu.cursorPos++;
             return 1;
         }
         else
         {
-            gHelpSystemListMenu.field_0C++;
+            gHelpSystemListMenu.itemsAbove++;
             return 2;
         }
     }
@@ -1159,7 +1157,7 @@ u8 TryMoveCursor1(u8 dirn)
 
 bool8 MoveCursor(u8 by, u8 dirn)
 {
-    u8 r7 = gHelpSystemListMenu.field_0D;
+    u8 r7 = gHelpSystemListMenu.cursorPos;
     u8 flags = 0;
     s32 i;
     for (i = 0; i < by; i++)
@@ -1172,21 +1170,21 @@ bool8 MoveCursor(u8 by, u8 dirn)
         // neither changed
         return TRUE;
     case 1:
-        // changed field_0D only
+        // changed cursorPos only
         sub_813C860(r7);
         PlaceListMenuCursor();
         CommitTilemap();
         break;
     case 2:
     case 3:
-        // changed field_0C
+        // changed itemsAbove
         if (sub_812BF88() == TRUE)
         {
             HelpSystem_SetInputDelay(2);
             HelpSystem_FillPanel1();
             PrintListMenuItems();
             PlaceListMenuCursor();
-            sub_812BDEC();
+            HelpSystem_PrintTopicLabel();
             sub_813C75C();
         }
         else
diff --git a/src/help_system_812B1E0.c b/src/help_system_812B1E0.c
index df892152a..ee26c6de5 100644
--- a/src/help_system_812B1E0.c
+++ b/src/help_system_812B1E0.c
@@ -16,812 +16,1678 @@
 #include "constants/maps.h"
 #include "constants/songs.h"
 
-static EWRAM_DATA u16 sSomeVariable = 0;
-static EWRAM_DATA u8 gUnknown_203B0EE = 0;
+static EWRAM_DATA u16 sHelpSystemContextId = 0;
+static EWRAM_DATA u8 sSeenHelpSystemIntro = 0;
 
-u8 gUnknown_3005E9C[4];
-u16 gSomeVariableBackup;
+u8 gHelpSystemState[4];
+u16 gHelpContextIdBackup;
 
 static bool32 IsCurrentMapInArray(const u16 * mapIdxs);
-static void sub_812B520(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
-static void sub_812B614(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
-static bool8 sub_812B754(void);
-static bool8 sub_812B780(u8);
-static bool8 sub_812BB10(void);
-
-static void sub_812BF5C(void);
-static void sub_812BF74(const u8 *);
-static void sub_812BF94(struct HelpSystemListMenu * a0);
-static void sub_812BF9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
-
-static const u8 *const gUnknown_845B080[] = {
-    gUnknown_81B2DF8,
-    gUnknown_81B2E1C,
-    gUnknown_81B2E2E,
-    gUnknown_81B2E48,
-    gUnknown_81B2E58,
-    gUnknown_81B2E6A
-};
-
-static const u8 *const gUnknown_845B098[] = {
-    gUnknown_81B2E88,
-    gUnknown_81B2EC8,
-    gUnknown_81B2F00,
-    gUnknown_81B2F43,
-    gUnknown_81B2F74,
-    gUnknown_81B2FA9
-};
-
-static const u8 *const gUnknown_845B0B0[] = {
-    NULL,
-    gUnknown_81B3083,
-    gUnknown_81B30A9,
-    gUnknown_81B30C1,
-    gUnknown_81B30DC,
-    gUnknown_81B30FC,
-    gUnknown_81B311F,
-    gUnknown_81B3140,
-    gUnknown_81B314F,
-    gUnknown_81B3168,
-    gUnknown_81B3189,
-    gUnknown_81B31AE,
-    gUnknown_81B31D3,
-    gUnknown_81B31EC,
-    gUnknown_81B31FF,
-    gUnknown_81B3215,
-    gUnknown_81B3226,
-    gUnknown_81B3243,
-    gUnknown_81B3261,
-    gUnknown_81B3276,
-    gUnknown_81B3290,
-    gUnknown_81B32B6,
-    gUnknown_81B32CD,
-    gUnknown_81B32E3,
-    gUnknown_81B32F9,
-    gUnknown_81B330B,
-    gUnknown_81B332B,
-    gUnknown_81B3344,
-    gUnknown_81B335C,
-    gUnknown_81B3373,
-    gUnknown_81B338C,
-    gUnknown_81B33A6,
-    gUnknown_81B33CA,
-    gUnknown_81B33EA,
-    gUnknown_81B3402,
-    gUnknown_81B3427,
-    gUnknown_81B3440,
-    gUnknown_81B3457,
-    gUnknown_81B346F,
-    gUnknown_81B3481,
-    gUnknown_81B349B,
-    gUnknown_81B34B7,
-    gUnknown_81B34D6,
-    gUnknown_81B34F6,
-    gUnknown_81B3516
-};
-
-static const u8 *const gUnknown_845B164[] = {
-    NULL,
-    gUnknown_81B3525,
-    gUnknown_81B35E6,
-    gUnknown_81B36EB,
-    gUnknown_81B379A,
-    gUnknown_81B3849,
-    gUnknown_81B3876,
-    gUnknown_81B3972,
-    gUnknown_81B3A51,
-    gUnknown_81B3ACC,
-    gUnknown_81B3BB6,
-    gUnknown_81B3C99,
-    gUnknown_81B3D1B,
-    gUnknown_81B3DE3,
-    gUnknown_81B3EBC,
-    gUnknown_81B3F7F,
-    gUnknown_81B406C,
-    gUnknown_81B410B,
-    gUnknown_81B41D7,
-    gUnknown_81B42B3,
-    gUnknown_81B439D,
-    gUnknown_81B4483,
-    gUnknown_81B457C,
-    gUnknown_81B4645,
-    gUnknown_81B470A,
-    gUnknown_81B47F0,
-    gUnknown_81B48C6,
-    gUnknown_81B497A,
-    gUnknown_81B4A72,
-    gUnknown_81B4B65,
-    gUnknown_81B4C54,
-    gUnknown_81B4D26,
-    gUnknown_81B4E0B,
-    gUnknown_81B4ED8,
-    gUnknown_81B4FB2,
-    gUnknown_81B4FFD,
-    gUnknown_81B50FF,
-    gUnknown_81B51B1,
-    gUnknown_81B5272,
-    gUnknown_81B5325,
-    gUnknown_81B5382,
-    gUnknown_81B547C,
-    gUnknown_81B54E1,
-    gUnknown_81B5589,
-    gUnknown_81B55F4
-};
-
-static const u8 *const gUnknown_845B218[] = {
-    NULL,
-    gUnknown_81B56E3,
-    gUnknown_81B56F4,
-    gUnknown_81B5705,
-    gUnknown_81B5717,
-    gUnknown_81B5728,
-    gUnknown_81B5737,
-    gUnknown_81B5744,
-    gUnknown_81B5754,
-    gUnknown_81B5767,
-    gUnknown_81B577B,
-    gUnknown_81B5787,
-    gUnknown_81B5795,
-    gUnknown_81B57A5,
-    gUnknown_81B57B8,
-    gUnknown_81B57CF,
-    gUnknown_81B57DE,
-    gUnknown_81B57EE,
-    gUnknown_81B580D,
-    gUnknown_81B5824,
-    gUnknown_81B5834,
-    gUnknown_81B583F,
-    gUnknown_81B5850,
-    gUnknown_81B5863,
-    gUnknown_81B5875,
-    gUnknown_81B5884,
-    gUnknown_81B5893,
-    gUnknown_81B58A4,
-    gUnknown_81B58BC,
-    gUnknown_81B58D3,
-    gUnknown_81B58E5,
-    gUnknown_81B58FD,
-    gUnknown_81B590E,
-    gUnknown_81B591D,
-    gUnknown_81B592E,
-    gUnknown_81B593E,
-    gUnknown_81B5950,
-    gUnknown_81B595D,
-    gUnknown_81B5974,
-    gUnknown_81B5989,
-    gUnknown_81B59A7,
-    gUnknown_81B59BF,
-    gUnknown_81B59D6,
-    gUnknown_81B59E8,
-    gUnknown_81B59F5,
-    gUnknown_81B5A0D,
-    gUnknown_81B5A1B,
-    gUnknown_81B5A29,
-    gUnknown_81B5A37
-};
-
-static const u8 *const gUnknown_845B2DC[] = {
-    NULL,
-    gUnknown_81B5A4D,
-    gUnknown_81B5B0C,
-    gUnknown_81B5B7D,
-    gUnknown_81B5C13,
-    gUnknown_81B5CDF,
-    gUnknown_81B5D87,
-    gUnknown_81B5E41,
-    gUnknown_81B5F10,
-    gUnknown_81B5FA6,
-    gUnknown_81B606C,
-    gUnknown_81B6140,
-    gUnknown_81B6203,
-    gUnknown_81B62E4,
-    gUnknown_81B6397,
-    gUnknown_81B6478,
-    gUnknown_81B6525,
-    gUnknown_81B65E7,
-    gUnknown_81B66BA,
-    gUnknown_81B678E,
-    gUnknown_81B6883,
-    gUnknown_81B68CD,
-    gUnknown_81B69B9,
-    gUnknown_81B6A9A,
-    gUnknown_81B6B6E,
-    gUnknown_81B6C4F,
-    gUnknown_81B6D4A,
-    gUnknown_81B6E02,
-    gUnknown_81B6EC1,
-    gUnknown_81B6FA8,
-    gUnknown_81B7075,
-    gUnknown_81B7108,
-    gUnknown_81B71EA,
-    gUnknown_81B723B,
-    gUnknown_81B7319,
-    gUnknown_81B73E8,
-    gUnknown_81B747E,
-    gUnknown_81B752C,
-    gUnknown_81B7611,
-    gUnknown_81B7692,
-    gUnknown_81B771E,
-    gUnknown_81B77DD,
-    gUnknown_81B7884,
-    gUnknown_81B7931,
-    gUnknown_81B79CB,
-    gUnknown_81B7A60,
-    gUnknown_81B7AEE,
-    gUnknown_81B7BBE,
-    gUnknown_81B7C57
-};
-
-static const u8 *const gUnknown_845B3A0[] = {
-    NULL,
-    gUnknown_81B7CC1,
-    gUnknown_81B7CC4,
-    gUnknown_81B7CD9,
-    gUnknown_81B7CDF,
-    gUnknown_81B7CE6,
-    gUnknown_81B7CEE,
-    gUnknown_81B7CF6,
-    gUnknown_81B7CFE,
-    gUnknown_81B7D04,
-    gUnknown_81B7D12,
-    gUnknown_81B7D17,
-    gUnknown_81B7D1A,
-    gUnknown_81B7D1F,
-    gUnknown_81B7D27,
-    gUnknown_81B7D2D,
-    gUnknown_81B7D37,
-    gUnknown_81B7D3E,
-    gUnknown_81B7D45,
-    gUnknown_81B7D48,
-    gUnknown_81B7D4E,
-    gUnknown_81B7D57,
-    gUnknown_81B7D5B,
-    gUnknown_81B7D61,
-    gUnknown_81B7D6B,
-    gUnknown_81B7D76,
-    gUnknown_81B7D7E,
-    gUnknown_81B7D88,
-    gUnknown_81B7D8F,
-    gUnknown_81B7D9A,
-    gUnknown_81B7DA7,
-    gUnknown_81B7DB4,
-    gUnknown_81B7DBA,
-    gUnknown_81B7DC6,
-    gUnknown_81B7DCC,
-    gUnknown_81B7DD3,
-    gUnknown_81B7DD6,
-    gUnknown_81B7DD9,
-    gUnknown_81B7DE1,
-    gUnknown_81B7DEB,
-    gUnknown_81B7DFA,
-    gUnknown_81B7E02,
-    gUnknown_81B7E09,
-    gUnknown_81B7E0F
-};
-
-static const u8 *const gUnknown_845B450[] = {
-    NULL,
-    gUnknown_81B7E16,
-    gUnknown_81B7F0A,
-    gUnknown_81B800A,
-    gUnknown_81B80EC,
-    gUnknown_81B81C2,
-    gUnknown_81B8256,
-    gUnknown_81B8348,
-    gUnknown_81B83EF,
-    gUnknown_81B847B,
-    gUnknown_81B8550,
-    gUnknown_81B8647,
-    gUnknown_81B86E2,
-    gUnknown_81B87B8,
-    gUnknown_81B8897,
-    gUnknown_81B8924,
-    gUnknown_81B8A04,
-    gUnknown_81B8A84,
-    gUnknown_81B8B62,
-    gUnknown_81B8C18,
-    gUnknown_81B8C94,
-    gUnknown_81B8D1D,
-    gUnknown_81B8DD4,
-    gUnknown_81B8E67,
-    gUnknown_81B8F4D,
-    gUnknown_81B901B,
-    gUnknown_81B90A7,
-    gUnknown_81B90E8,
-    gUnknown_81B9170,
-    gUnknown_81B91C2,
-    gUnknown_81B91F9,
-    gUnknown_81B92B8,
-    gUnknown_81B92ED,
-    gUnknown_81B93D8,
-    gUnknown_81B9439,
-    gUnknown_81B9497,
-    gUnknown_81B9560,
-    gUnknown_81B9656,
-    gUnknown_81B9749,
-    gUnknown_81B984F,
-    gUnknown_81B991C,
-    gUnknown_81B99C4,
-    gUnknown_81B9AA2,
-    gUnknown_81B9B2F
-};
-
-static const u8 *const gUnknown_845B500[] = {
-    NULL,
-    gUnknown_81B9BB7,
-    gUnknown_81B9BC7,
-    gUnknown_81B9BD0,
-    gUnknown_81B9BE1,
-    gUnknown_81B9BF5,
-    gUnknown_81B9C09,
-    gUnknown_81B9C1D
-};
-
-static const u8 *const gUnknown_845B520[] = {
-    NULL,
-    gUnknown_81B9C2F,
-    gUnknown_81B9D04,
-    gUnknown_81B9DC5,
-    gUnknown_81B9E75,
-    gUnknown_81B9F09,
-    gUnknown_81B9FCE,
-    gUnknown_81BA027
-};
-
-static const u8 *const gUnknown_845B540[] = {
-    NULL,
-    gUnknown_81BA0F1,
-    gUnknown_81BA10D,
-    gUnknown_81BA121,
-    gUnknown_81BA138,
-    gUnknown_81BA14C,
-    gUnknown_81BA163,
-    gUnknown_81BA17A,
-    gUnknown_81BA194,
-    gUnknown_81BA1AC,
-    gUnknown_81BA1C7,
-    gUnknown_81BA1DC,
-    gUnknown_81BA1F4,
-    gUnknown_81BA209,
-    gUnknown_81BA221,
-    gUnknown_81BA234,
-    gUnknown_81BA24A,
-    gUnknown_81BA260,
-    gUnknown_81BA279,
-    gUnknown_81BA291,
-    gUnknown_81BA2AC,
-    gUnknown_81BA2C2,
-    gUnknown_81BA2DB,
-    gUnknown_81BA2F1,
-    gUnknown_81BA30A,
-    gUnknown_81BA320,
-    gUnknown_81BA339,
-    gUnknown_81BA34E,
-    gUnknown_81BA366,
-    gUnknown_81BA37C,
-    gUnknown_81BA395,
-    gUnknown_81BA3A9,
-    gUnknown_81BA3C0,
-    gUnknown_81BA3D5,
-    gUnknown_81BA3ED,
-    gUnknown_81BA400
-};
-
-static const u8 *const gUnknown_845B5D0[] = {
-    NULL,
-    gUnknown_81BA416,
-    gUnknown_81BA4E6,
-    gUnknown_81BA539,
-    gUnknown_81BA595,
-    gUnknown_81BA5F2,
-    gUnknown_81BA66F,
-    gUnknown_81BA6C9,
-    gUnknown_81BA71F,
-    gUnknown_81BA796,
-    gUnknown_81BA7E9,
-    gUnknown_81BA862,
-    gUnknown_81BA8D3,
-    gUnknown_81BA92A,
-    gUnknown_81BA98D,
-    gUnknown_81BA9F1,
-    gUnknown_81BAA44,
-    gUnknown_81BAAB6,
-    gUnknown_81BAB18,
-    gUnknown_81BAB7A,
-    gUnknown_81BABCC,
-    gUnknown_81BAC29,
-    gUnknown_81BAC89,
-    gUnknown_81BACC4,
-    gUnknown_81BAD20,
-    gUnknown_81BAD60,
-    gUnknown_81BADA2,
-    gUnknown_81BADF7,
-    gUnknown_81BAEA8,
-    gUnknown_81BAF01,
-    gUnknown_81BAF6B,
-    gUnknown_81BAFCA,
-    gUnknown_81BB02E,
-    gUnknown_81BB084,
-    gUnknown_81BB0DF,
-    gUnknown_81BB156
-};
-
-
-static const u8 gUnknown_845B660[] = {
-    0x01, 0x02, 0x03, 0xff
-};
-
-static const u8 gUnknown_845B664[] = {
-    0x01, 0x02, 0x03, 0xff
-};
-
-static const u8 gUnknown_845B668[] = {
-    0x13, 0xff
-};
-
-static const u8 gUnknown_845B66A[] = {
-    0x01, 0x02, 0x03, 0xff
-};
-
-static const u8 gUnknown_845B66E[] = {
-    0x01, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B671[] = {
-    0x02, 0x03, 0x04, 0x05, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B677[] = {
-    0x09, 0x01, 0xff
-};
-
-static const u8 gUnknown_845B67A[] = {
-    0x02, 0x03, 0xff
-};
-
-static const u8 gUnknown_845B67D[] = {
-    0x09, 0x0a, 0x0b, 0x11, 0x0c, 0x10, 0xff
-};
-
-static const u8 gUnknown_845B684[] = {
-    0x09, 0x01, 0x04, 0x05, 0x06, 0x07, 0x08, 0x02, 0x0d, 0xff
-};
-
-static const u8 gUnknown_845B68E[] = {
-    0x09, 0x03, 0x0a, 0x0f, 0x12, 0x13, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B696[] = {
-    0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x12, 0xff
-};
-
-static const u8 gUnknown_845B6A1[] = {
-    0x16, 0x17, 0x18, 0xff
-};
-
-static const u8 gUnknown_845B6A5[] = {
-    0x0a, 0xff
-};
-
-static const u8 gUnknown_845B6A7[] = {
-    0x11, 0x0e, 0x19, 0x1a, 0x1b, 0xff
-};
-
-static const u8 gUnknown_845B6AD[] = {
-    0x0a, 0xff
-};
-
-static const u8 gUnknown_845B6AF[] = {
-    0x0b, 0xff
-};
-
-static const u8 gUnknown_845B6B1[] = {
-    0x2b, 0x19, 0x1a, 0xff
-};
-
-static const u8 gUnknown_845B6B5[] = {
-    0x0c, 0xff
-};
-
-static const u8 gUnknown_845B6B7[] = {
-    0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0xff
-};
-
-static const u8 gUnknown_845B6BF[] = {
-    0x02, 0x03, 0x04, 0xff
-};
-
-static const u8 gUnknown_845B6C3[] = {
-    0x01, 0x02, 0x03, 0x07, 0xff
-};
-
-static const u8 gUnknown_845B6C8[] = {
-    0x02, 0x04, 0x05, 0x09, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B6CE[] = {
-    0x1f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B6E2[] = {
-    0x09, 0x01, 0x02, 0x03, 0x0a, 0x28, 0xff
-};
-
-static const u8 gUnknown_845B6E9[] = {
-    0x02, 0x05, 0x06, 0x0a, 0x23, 0x24, 0x09, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B6F2[] = {
-    0x1f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x0a, 0x0b, 0x0c, 0x11, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B707[] = {
-    0x09, 0x01, 0x02, 0x03, 0x0a, 0x28, 0xff
-};
-
-static const u8 gUnknown_845B70E[] = {
-    0x03, 0x07, 0x04, 0x05, 0x06, 0xff
-};
-
-static const u8 gUnknown_845B714[] = {
-    0x02, 0x05, 0x06, 0x0a, 0x23, 0x24, 0x09, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B71D[] = {
-    0x1f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B731[] = {
-    0x09, 0x01, 0x02, 0x03, 0x0a, 0x0c, 0x0e, 0x16, 0x17, 0x18, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B73D[] = {
-    0x06, 0x0a, 0x23, 0x24, 0x09, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B744[] = {
-    0x1f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B758[] = {
-    0x09, 0x01, 0x02, 0x03, 0x0a, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B75F[] = {
-    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0xff
-};
-
-static const u8 gUnknown_845B783[] = {
-    0x02, 0x0a, 0x04, 0x05, 0x06, 0x07, 0x0d, 0x27, 0x08, 0x0b, 0x21, 0x23, 0x24, 0x2c, 0x09, 0x0e, 0x16, 0x17, 0x0f, 0x10, 0x11, 0x1a, 0x15, 0x1f, 0x20, 0x12, 0x13, 0x14, 0x18, 0x19, 0x1b, 0x1e, 0x1c, 0x28, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B7A7[] = {
-    0x1f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x2c, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B7BB[] = {
-    0x09, 0x01, 0x02, 0x0a, 0x0b, 0x0c, 0x0d, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B7C4[] = {
-    0x02, 0x0a, 0x04, 0x05, 0x06, 0x07, 0x0d, 0x27, 0x08, 0x0b, 0x21, 0x23, 0x24, 0x2c, 0x09, 0x0e, 0x16, 0x17, 0x0f, 0x10, 0x11, 0x1a, 0x15, 0x1f, 0x20, 0x12, 0x13, 0x14, 0x18, 0x19, 0x1b, 0x1e, 0x1c, 0x28, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B7E8[] = {
-    0x1f, 0x01, 0x02, 0x06, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B7F1[] = {
-    0x09, 0x01, 0x02, 0x0a, 0x0b, 0x0c, 0x0d, 0x15, 0x28, 0xff
-};
-
-static const u8 gUnknown_845B7FB[] = {
-    0x0a, 0x07, 0x0d, 0x27, 0x08, 0x0b, 0x21, 0x23, 0x24, 0x2c, 0x09, 0x0e, 0x16, 0x0f, 0x10, 0x11, 0x1a, 0x15, 0x1f, 0x20, 0x12, 0x13, 0x14, 0x18, 0x19, 0x1b, 0x1e, 0x1c, 0x28, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B81A[] = {
-    0x1f, 0x01, 0x02, 0x06, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B823[] = {
-    0x09, 0x01, 0x02, 0x0a, 0x0b, 0x0c, 0x0d, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B82C[] = {
-    0x07, 0x27, 0x08, 0x2c, 0x15, 0x1f, 0x20, 0x12, 0x13, 0x14, 0x18, 0x19, 0x1b, 0x1e, 0x1c, 0x28, 0x25, 0xff
-};
-
-static const u8 gUnknown_845B83E[] = {
-    0x1f, 0x01, 0x02, 0x06, 0x0a, 0x0b, 0x0c, 0x11, 0xff
-};
-
-static const u8 gUnknown_845B847[] = {
-    0x09, 0x01, 0x02, 0x0a, 0x0b, 0x0c, 0x0d, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B850[] = {
-    0x0f, 0x1b, 0x1d, 0x11, 0x12, 0x15, 0x17, 0x16, 0x1f, 0x20, 0x13, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B85D[] = {
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x07, 0x09, 0x2b, 0xff
-};
-
-static const u8 gUnknown_845B866[] = {
-    0x09, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0d, 0x0f, 0x12, 0x13, 0x14, 0x27, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B878[] = {
-    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0xff
-};
-
-static const u8 gUnknown_845B89C[] = {
-    0x0f, 0x1b, 0x1d, 0x11, 0x12, 0x16, 0x1f, 0x20, 0x13, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B8A7[] = {
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x07, 0x2b, 0xff
-};
-
-static const u8 gUnknown_845B8AF[] = {
-    0x09, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0d, 0x0f, 0x12, 0x13, 0x14, 0x27, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B8C1[] = {
-    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0xff
-};
-
-static const u8 gUnknown_845B8E5[] = {
-    0x0f, 0x1b, 0x1d, 0x11, 0x12, 0x16, 0x1f, 0x20, 0x13, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B8F0[] = {
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x07, 0x2b, 0xff
-};
-
-static const u8 gUnknown_845B8F8[] = {
-    0x09, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0d, 0x0f, 0x12, 0x13, 0x14, 0x27, 0x15, 0xff
-};
-
-static const u8 gUnknown_845B90A[] = {
-    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0xff
-};
-
-static const u8 gUnknown_845B92E[] = {
-    0x29, 0x2a, 0x2b, 0xff
-};
-
-static const u8 gUnknown_845B932[] = {
-    0x2d, 0x2e, 0x2f, 0x2b, 0xff
-};
-
-static const u8 gUnknown_845B937[] = {
-    0x09, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0d, 0x0f, 0x12, 0x13, 0x14, 0xff
-};
-
-static const u8 gUnknown_845B947[] = {
-    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0xff
-};
-
-static const u8 gUnknown_845B96B[] = {
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x30, 0xff
-};
-
-static const u8 gUnknown_845B978[] = {
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x30, 0xff
-};
-
-static const u8 gUnknown_845B985[] = {
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x30, 0xff
-};
-
-static const u8 gUnknown_845B992[] = {
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x30, 0xff
-};
-
-static const u8 gUnknown_845B99F[] = {
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x30, 0xff
-};
-
-static const u8 gUnknown_845B9AC[] = {
-    0x26, 0x27, 0x28, 0x29, 0x2a, 0xff
-};
-
-static const u8 gUnknown_845B9B2[] = {
-    0x26, 0x27, 0x28, 0x29, 0x2a, 0xff
-};
-
-static const u8 gUnknown_845B9B8[] = {
-    0x26, 0x27, 0x28, 0x29, 0x2a, 0xff
-};
-
-static const u8 gUnknown_845B9BE[] = {
-    0x09, 0x01, 0x02, 0x03, 0x23, 0x25, 0x24, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0b, 0x0c, 0x0d, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x27, 0x15, 0x26, 0x16, 0x17, 0x18, 0x1a, 0x0e, 0x1b, 0xff
-};
-
-static const u8 *const gUnknown_845B9E0[] = {
-    NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, gUnknown_845B660, NULL,
-    NULL, NULL, NULL, gUnknown_845B664, NULL,
-    NULL, gUnknown_845B668, NULL, gUnknown_845B66A, NULL,
-    NULL, gUnknown_845B66E, NULL, NULL, NULL,
-    NULL, gUnknown_845B671, gUnknown_845B677, NULL, NULL,
-    NULL, gUnknown_845B67A, gUnknown_845B67D, NULL, NULL,
-    NULL, NULL, gUnknown_845B684, NULL, NULL,
-    NULL, NULL, gUnknown_845B68E, NULL, NULL,
-    NULL, gUnknown_845B696, gUnknown_845B6A1, NULL, NULL,
-    NULL, gUnknown_845B6A5, gUnknown_845B6A7, NULL, NULL,
-    NULL, gUnknown_845B6AD, NULL, NULL, NULL,
-    NULL, gUnknown_845B6AF, gUnknown_845B6B1, NULL, NULL,
-    NULL, gUnknown_845B6B5, gUnknown_845B6B7, NULL, NULL,
-    gUnknown_845B6BF, NULL, NULL, gUnknown_845B6C3, NULL,
-    gUnknown_845B6C8, gUnknown_845B6CE, gUnknown_845B6E2, NULL, NULL,
-    gUnknown_845B6E9, gUnknown_845B6F2, gUnknown_845B707, gUnknown_845B70E, NULL,
-    gUnknown_845B714, gUnknown_845B71D, gUnknown_845B731, NULL, NULL,
-    gUnknown_845B73D, gUnknown_845B744, gUnknown_845B758, NULL, gUnknown_845B75F,
-    gUnknown_845B783, gUnknown_845B7A7, gUnknown_845B7BB, NULL, NULL,
-    gUnknown_845B7C4, gUnknown_845B7E8, gUnknown_845B7F1, NULL, NULL,
-    gUnknown_845B7FB, gUnknown_845B81A, gUnknown_845B823, NULL, NULL,
-    gUnknown_845B82C, gUnknown_845B83E, gUnknown_845B847, NULL, NULL,
-    gUnknown_845B850, gUnknown_845B85D, gUnknown_845B866, NULL, gUnknown_845B878,
-    gUnknown_845B89C, gUnknown_845B8A7, gUnknown_845B8AF, NULL, gUnknown_845B8C1,
-    gUnknown_845B8E5, gUnknown_845B8F0, gUnknown_845B8F8, NULL, gUnknown_845B90A,
-    gUnknown_845B92E, gUnknown_845B932, gUnknown_845B937, NULL, gUnknown_845B947,
-    NULL, gUnknown_845B96B, NULL, NULL, NULL,
-    NULL, gUnknown_845B978, NULL, NULL, NULL,
-    NULL, gUnknown_845B985, NULL, NULL, NULL,
-    NULL, gUnknown_845B992, NULL, NULL, NULL,
-    NULL, gUnknown_845B99F, NULL, NULL, NULL,
-    NULL, gUnknown_845B9AC, NULL, NULL, NULL,
-    NULL, gUnknown_845B9B2, NULL, NULL, NULL,
-    NULL, gUnknown_845B9B8, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL
+static void BuildMainTopicsListAndMoveToH00(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
+static void SetHelpSystemSubmenuItems(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
+static bool8 HelpSystem_ShouldShowBasicTerms(void);
+static bool8 IsHelpSystemSubmenuEnabled(u8);
+static bool8 HasGottenAtLeastOneHM(void);
+
+static void PrintWelcomeMessageOnPanel1(void);
+static void PrintTextOnPanel2Row52RightAlign(const u8 *);
+static void ResetHelpSystemCursor(struct HelpSystemListMenu * a0);
+static void PrintHelpSystemTopicMouseoverDescription(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
+
+#define HELP_NONE  0
+#define HELP_END   0xFF
+
+// Help Main Topics
+enum
+{
+    TOPIC_WHAT_TO_DO,
+    TOPIC_HOW_TO_DO,
+    TOPIC_TERMS,
+    TOPIC_ABOUT_GAME,
+    TOPIC_TYPE_MATCHUP,
+    TOPIC_EXIT,
+    TOPIC_COUNT
+};
+
+static const u8 *const sHelpSystemTopicPtrs[TOPIC_COUNT] = {
+    [TOPIC_WHAT_TO_DO]   = Help_Text_WhatShouldIDo,
+    [TOPIC_HOW_TO_DO]    = Help_Text_HowDoIDoThis,
+    [TOPIC_TERMS]        = Help_Text_WhatDoesThisTermMean,
+    [TOPIC_ABOUT_GAME]   = Help_Text_AboutThisGame,
+    [TOPIC_TYPE_MATCHUP] = Help_Text_TypeMatchupList,
+    [TOPIC_EXIT]         = Help_Text_Exit
+};
+
+static const u8 *const sHelpSystemTopicMouseoverDescriptionPtrs[TOPIC_COUNT] = {
+    [TOPIC_WHAT_TO_DO]   = Help_Text_DescWhatShouldIDo,
+    [TOPIC_HOW_TO_DO]    = Help_Text_DescHowDoIDoThis,
+    [TOPIC_TERMS]        = Help_Text_DescWhatDoesThisTermMean,
+    [TOPIC_ABOUT_GAME]   = Help_Text_DescAboutThisGame,
+    [TOPIC_TYPE_MATCHUP] = Help_Text_DescTypeMatchupList,
+    [TOPIC_EXIT]         = Help_Text_DescExit
+};
+
+// Submenu IDs for TOPIC_WHAT_TO_DO
+enum
+{
+    HELP_PLAYING_FOR_FIRST_TIME = 1,
+    HELP_WHAT_SHOULD_I_BE_DOING,
+    HELP_CANT_GET_OUT_OF_ROOM,
+    HELP_CANT_FIND_PERSON_I_WANT,
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT,
+    HELP_SOMEONE_BLOCKING_MY_WAY,
+    HELP_I_CANT_GO_ON,
+    HELP_OUT_OF_THINGS_TO_DO,
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT,
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS,
+    HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT,
+    HELP_HOW_ARE_CAVES_DIFFERENT,
+    HELP_HOW_DO_I_PROGRESS,
+    HELP_WHEN_CAN_I_USE_ITEM,
+    HELP_WHATS_A_BATTLE,
+    HELP_HOW_DO_I_PREPARE_FOR_BATTLE,
+    HELP_WHAT_IS_A_MONS_VITALITY,
+    HELP_MY_MONS_ARE_HURT,
+    HELP_WHAT_IS_STATUS_PROBLEM,
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT,
+    HELP_CANT_CATCH_MONS,
+    HELP_RAN_OUT_OF_POTIONS,
+    HELP_CAN_I_BUY_POKEBALLS,
+    HELP_WHATS_A_TRAINER,
+    HELP_HOW_DO_I_WIN_AGAINST_TRAINER,
+    HELP_WHERE_DO_MONS_APPEAR,
+    HELP_WHAT_ARE_MOVES,
+    HELP_WHAT_ARE_HIDDEN_MOVES,
+    HELP_WHAT_MOVES_SHOULD_I_USE,
+    HELP_WANT_TO_ADD_MORE_MOVES,
+    HELP_WANT_TO_MAKE_MON_STRONGER,
+    HELP_FOE_MONS_TOO_STRONG,
+    HELP_WHAT_DO_I_DO_IN_CAVE,
+    HELP_NOTHING_I_WANT_TO_KNOW,
+    HELP_WHATS_POKEMON_CENTER,
+    HELP_WHATS_POKEMON_MART,
+    HELP_WANT_TO_END_GAME,
+    HELP_WHATS_A_MON,
+    HELP_WHAT_IS_THAT_PERSON_LIKE,
+    HELP_WHAT_DOES_HIDDEN_MOVE_DO,
+    HELP_WHAT_DO_I_DO_IN_SAFARI,
+    HELP_WHAT_ARE_SAFARI_RULES,
+    HELP_WANT_TO_END_SAFARI,
+    HELP_WHAT_IS_A_GYM,
+};
+
+static const u8 *const sHelpSystemSpecializedQuestionTextPtrs[] = {
+    [HELP_NONE]                              = NULL,
+    [HELP_PLAYING_FOR_FIRST_TIME]            = Help_Text_PlayingForFirstTime,
+    [HELP_WHAT_SHOULD_I_BE_DOING]            = Help_Text_WhatShouldIBeDoing,
+    [HELP_CANT_GET_OUT_OF_ROOM]              = Help_Text_CantGetOutOfRoom,
+    [HELP_CANT_FIND_PERSON_I_WANT]           = Help_Text_CantFindPersonIWant,
+    [HELP_TALKED_TO_EVERYONE_NOW_WHAT]       = Help_Text_TalkedToEveryoneNowWhat,
+    [HELP_SOMEONE_BLOCKING_MY_WAY]           = Help_Text_SomeoneBlockingMyWay,
+    [HELP_I_CANT_GO_ON]                      = Help_Text_ICantGoOn,
+    [HELP_OUT_OF_THINGS_TO_DO]               = Help_Text_OutOfThingsToDo,
+    [HELP_WHAT_HAPPENED_TO_ITEM_I_GOT]       = Help_Text_WhatHappenedToItemIGot,
+    [HELP_WHAT_ARE_MY_ADVENTURE_BASICS]      = Help_Text_WhatAreMyAdventureBasics,
+    [HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT]   = Help_Text_HowAreRoadsForestsDifferent,
+    [HELP_HOW_ARE_CAVES_DIFFERENT]           = Help_Text_HowAreCavesDifferent,
+    [HELP_HOW_DO_I_PROGRESS]                 = Help_Text_HowDoIProgress,
+    [HELP_WHEN_CAN_I_USE_ITEM]               = Help_Text_WhenCanIUseItem,
+    [HELP_WHATS_A_BATTLE]                    = Help_Text_WhatsABattle,
+    [HELP_HOW_DO_I_PREPARE_FOR_BATTLE]       = Help_Text_HowDoIPrepareForBattle,
+    [HELP_WHAT_IS_A_MONS_VITALITY]           = Help_Text_WhatIsAMonsVitality,
+    [HELP_MY_MONS_ARE_HURT]                  = Help_Text_MyMonsAreHurt,
+    [HELP_WHAT_IS_STATUS_PROBLEM]            = Help_Text_WhatIsStatusProblem,
+    [HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT] = Help_Text_WhatHappensIfAllMyMonsFaint,
+    [HELP_CANT_CATCH_MONS]                   = Help_Text_CantCatchMons,
+    [HELP_RAN_OUT_OF_POTIONS]                = Help_Text_RanOutOfPotions,
+    [HELP_CAN_I_BUY_POKEBALLS]               = Help_Text_CanIBuyPokeBalls,
+    [HELP_WHATS_A_TRAINER]                   = Help_Text_WhatsATrainer,
+    [HELP_HOW_DO_I_WIN_AGAINST_TRAINER]      = Help_Text_HowDoIWinAgainstTrainer,
+    [HELP_WHERE_DO_MONS_APPEAR]              = Help_Text_WhereDoMonsAppear,
+    [HELP_WHAT_ARE_MOVES]                    = Help_Text_WhatAreMoves,
+    [HELP_WHAT_ARE_HIDDEN_MOVES]             = Help_Text_WhatAreHiddenMoves,
+    [HELP_WHAT_MOVES_SHOULD_I_USE]           = Help_Text_WhatMovesShouldIUse,
+    [HELP_WANT_TO_ADD_MORE_MOVES]            = Help_Text_WantToAddMoreMoves,
+    [HELP_WANT_TO_MAKE_MON_STRONGER]         = Help_Text_WantToMakeMonStronger,
+    [HELP_FOE_MONS_TOO_STRONG]               = Help_Text_FoeMonsTooStrong,
+    [HELP_WHAT_DO_I_DO_IN_CAVE]              = Help_Text_WhatDoIDoInCave,
+    [HELP_NOTHING_I_WANT_TO_KNOW]            = Help_Text_NothingIWantToKnow,
+    [HELP_WHATS_POKEMON_CENTER]              = Help_Text_WhatsPokemonCenter,
+    [HELP_WHATS_POKEMON_MART]                = Help_Text_WhatsPokemonMart,
+    [HELP_WANT_TO_END_GAME]                  = Help_Text_WantToEndGame,
+    [HELP_WHATS_A_MON]                       = Help_Text_WhatsAMon,
+    [HELP_WHAT_IS_THAT_PERSON_LIKE]          = Help_Text_WhatIsThatPersonLike,
+    [HELP_WHAT_DOES_HIDDEN_MOVE_DO]          = Help_Text_WhatDoesHiddenMoveDo,
+    [HELP_WHAT_DO_I_DO_IN_SAFARI]            = Help_Text_WhatDoIDoInSafari,
+    [HELP_WHAT_ARE_SAFARI_RULES]             = Help_Text_WhatAreSafariRules,
+    [HELP_WANT_TO_END_SAFARI]                = Help_Text_WantToEndSafari,
+    [HELP_WHAT_IS_A_GYM]                     = Help_Text_WhatIsAGym
+};
+
+static const u8 *const sHelpSystemSpecializedAnswerTextPtrs[] = {
+    [HELP_NONE]                              = NULL,
+    [HELP_PLAYING_FOR_FIRST_TIME]            = Help_Text_AnswerPlayingForFirstTime,
+    [HELP_WHAT_SHOULD_I_BE_DOING]            = Help_Text_AnswerWhatShouldIBeDoing,
+    [HELP_CANT_GET_OUT_OF_ROOM]              = Help_Text_AnswerCantGetOutOfRoom,
+    [HELP_CANT_FIND_PERSON_I_WANT]           = Help_Text_AnswerCantFindPersonIWant,
+    [HELP_TALKED_TO_EVERYONE_NOW_WHAT]       = Help_Text_AnswerTalkedToEveryoneNowWhat,
+    [HELP_SOMEONE_BLOCKING_MY_WAY]           = Help_Text_AnswerSomeoneBlockingMyWay,
+    [HELP_I_CANT_GO_ON]                      = Help_Text_AnswerICantGoOn,
+    [HELP_OUT_OF_THINGS_TO_DO]               = Help_Text_AnswerOutOfThingsToDo,
+    [HELP_WHAT_HAPPENED_TO_ITEM_I_GOT]       = Help_Text_AnswerWhatHappenedToItemIGot,
+    [HELP_WHAT_ARE_MY_ADVENTURE_BASICS]      = Help_Text_AnswerWhatAreMyAdventureBasics,
+    [HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT]   = Help_Text_AnswerHowAreRoadsForestsDifferent,
+    [HELP_HOW_ARE_CAVES_DIFFERENT]           = Help_Text_AnswerHowAreCavesDifferent,
+    [HELP_HOW_DO_I_PROGRESS]                 = Help_Text_AnswerHowDoIProgress,
+    [HELP_WHEN_CAN_I_USE_ITEM]               = Help_Text_AnswerWhenCanIUseItem,
+    [HELP_WHATS_A_BATTLE]                    = Help_Text_AnswerWhatsABattle,
+    [HELP_HOW_DO_I_PREPARE_FOR_BATTLE]       = Help_Text_AnswerHowDoIPrepareForBattle,
+    [HELP_WHAT_IS_A_MONS_VITALITY]           = Help_Text_AnswerWhatIsAMonsVitality,
+    [HELP_MY_MONS_ARE_HURT]                  = Help_Text_AnswerMyMonsAreHurt,
+    [HELP_WHAT_IS_STATUS_PROBLEM]            = Help_Text_AnswerWhatIsStatusProblem,
+    [HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT] = Help_Text_AnswerWhatHappensIfAllMyMonsFaint,
+    [HELP_CANT_CATCH_MONS]                   = Help_Text_AnswerCantCatchMons,
+    [HELP_RAN_OUT_OF_POTIONS]                = Help_Text_AnswerRanOutOfPotions,
+    [HELP_CAN_I_BUY_POKEBALLS]               = Help_Text_AnswerCanIBuyPokeBalls,
+    [HELP_WHATS_A_TRAINER]                   = Help_Text_AnswerWhatsATrainer,
+    [HELP_HOW_DO_I_WIN_AGAINST_TRAINER]      = Help_Text_AnswerHowDoIWinAgainstTrainer,
+    [HELP_WHERE_DO_MONS_APPEAR]              = Help_Text_AnswerWhereDoMonsAppear,
+    [HELP_WHAT_ARE_MOVES]                    = Help_Text_AnswerWhatAreMoves,
+    [HELP_WHAT_ARE_HIDDEN_MOVES]             = Help_Text_AnswerWhatAreHiddenMoves,
+    [HELP_WHAT_MOVES_SHOULD_I_USE]           = Help_Text_AnswerWhatMovesShouldIUse,
+    [HELP_WANT_TO_ADD_MORE_MOVES]            = Help_Text_AnswerWantToAddMoreMoves,
+    [HELP_WANT_TO_MAKE_MON_STRONGER]         = Help_Text_AnswerWantToMakeMonStronger,
+    [HELP_FOE_MONS_TOO_STRONG]               = Help_Text_AnswerFoeMonsTooStrong,
+    [HELP_WHAT_DO_I_DO_IN_CAVE]              = Help_Text_AnswerWhatDoIDoInCave,
+    [HELP_NOTHING_I_WANT_TO_KNOW]            = Help_Text_AnswerNothingIWantToKnow,
+    [HELP_WHATS_POKEMON_CENTER]              = Help_Text_AnswerWhatsPokemonCenter,
+    [HELP_WHATS_POKEMON_MART]                = Help_Text_AnswerWhatsPokemonMart,
+    [HELP_WANT_TO_END_GAME]                  = Help_Text_AnswerWantToEndGame,
+    [HELP_WHATS_A_MON]                       = Help_Text_AnswerWhatsAMon,
+    [HELP_WHAT_IS_THAT_PERSON_LIKE]          = Help_Text_AnswerWhatIsThatPersonLike,
+    [HELP_WHAT_DOES_HIDDEN_MOVE_DO]          = Help_Text_AnswerWhatDoesHiddenMoveDo,
+    [HELP_WHAT_DO_I_DO_IN_SAFARI]            = Help_Text_AnswerWhatDoIDoInSafari,
+    [HELP_WHAT_ARE_SAFARI_RULES]             = Help_Text_AnswerWhatAreSafariRules,
+    [HELP_WANT_TO_END_SAFARI]                = Help_Text_AnswerWantToEndSafari,
+    [HELP_WHAT_IS_A_GYM]                     = Help_Text_AnswerWhatIsAGym
+};
+
+// Submenu IDs for TOPIC_HOW_TO_DO
+enum
+{
+    HELP_USING_POKEDEX = 1,
+    HELP_USING_POKEMON,
+    HELP_USING_SUMMARY,
+    HELP_USING_SWITCH,
+    HELP_USING_ITEM,
+    HELP_USING_BAG,
+    HELP_USING_AN_ITEM,
+    HELP_USING_KEYITEM,
+    HELP_USING_POKEBALL,
+    HELP_USING_PLAYER,
+    HELP_USING_SAVE,
+    HELP_USING_OPTION,
+    HELP_USING_POTION,
+    HELP_USING_TOWN_MAP,
+    HELP_USING_TM,
+    HELP_USING_HM,
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE,
+    HELP_RIDING_BICYCLE,
+    HELP_ENTERING_NAME,
+    HELP_USING_PC,
+    HELP_USING_BILLS_PC,
+    HELP_USING_WITHDRAW,
+    HELP_USING_DEPOSIT,
+    HELP_USING_MOVE,
+    HELP_MOVING_ITEMS,
+    HELP_USING_PLAYERS_PC,
+    HELP_USING_WITHDRAW_ITEM,
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX,
+    HELP_USING_PROF_OAKS_PC,
+    HELP_OPENING_MENU,
+    HELP_USING_FIGHT,
+    HELP_USING_POKEMON2,
+    HELP_USING_SHIFT,
+    HELP_USING_SUMMARY2,
+    HELP_USING_BAG2,
+    HELP_READING_POKEDEX,
+    HELP_USING_HOME_PC,
+    HELP_USING_ITEM_STORAGE,
+    HELP_USING_WITHDRAW_ITEM2,
+    HELP_USING_DEPOSIT_ITEM2,
+    HELP_USING_MAILBOX2,
+    HELP_USING_RUN,
+    HELP_REGISTER_KEY_ITEM,
+    HELP_USING_BALL,
+    HELP_USING_BAIT,
+    HELP_USING_ROCK,
+    HELP_USING_HALL_OF_FAME,
+};
+
+static const u8 *const sHelpSystemMenuTopicTextPtrs[] = {
+    [HELP_NONE]                         = NULL,
+    [HELP_USING_POKEDEX]                = Help_Text_UsingPokedex,
+    [HELP_USING_POKEMON]                = Help_Text_UsingPokemon,
+    [HELP_USING_SUMMARY]                = Help_Text_UsingSummary,
+    [HELP_USING_SWITCH]                 = Help_Text_UsingSwitch,
+    [HELP_USING_ITEM]                   = Help_Text_UsingItem,
+    [HELP_USING_BAG]                    = Help_Text_UsingBag,
+    [HELP_USING_AN_ITEM]                = Help_Text_UsingAnItem,
+    [HELP_USING_KEYITEM]                = Help_Text_UsingKeyItem,
+    [HELP_USING_POKEBALL]               = Help_Text_UsingPokeBall,
+    [HELP_USING_PLAYER]                 = Help_Text_UsingPlayer,
+    [HELP_USING_SAVE]                   = Help_Text_UsingSave,
+    [HELP_USING_OPTION]                 = Help_Text_UsingOption,
+    [HELP_USING_POTION]                 = Help_Text_UsingPotion,
+    [HELP_USING_TOWN_MAP]               = Help_Text_UsingTownMap,
+    [HELP_USING_TM]                     = Help_Text_UsingTM,
+    [HELP_USING_HM]                     = Help_Text_UsingHM,
+    [HELP_USING_MOVE_OUTSIDE_OF_BATTLE] = Help_Text_UsingMoveOutsideOfBattle,
+    [HELP_RIDING_BICYCLE]               = Help_Text_RidingBicycle,
+    [HELP_ENTERING_NAME]                = Help_Text_EnteringName,
+    [HELP_USING_PC]                     = Help_Text_UsingPC,
+    [HELP_USING_BILLS_PC]               = Help_Text_UsingBillsPC,
+    [HELP_USING_WITHDRAW]               = Help_Text_UsingWithdraw,
+    [HELP_USING_DEPOSIT]                = Help_Text_UsingDeposit,
+    [HELP_USING_MOVE]                   = Help_Text_UsingMove,
+    [HELP_MOVING_ITEMS]                 = Help_Text_MovingItems,
+    [HELP_USING_PLAYERS_PC]             = Help_Text_UsingPlayersPC,
+    [HELP_USING_WITHDRAW_ITEM]          = Help_Text_UsingWithdrawItem,
+    [HELP_USING_DEPOSIT_ITEM]           = Help_Text_UsingDepositItem,
+    [HELP_USING_MAILBOX]                = Help_Text_UsingMailbox,
+    [HELP_USING_PROF_OAKS_PC]           = Help_Text_UsingProfOaksPC,
+    [HELP_OPENING_MENU]                 = Help_Text_OpeningMenu,
+    [HELP_USING_FIGHT]                  = Help_Text_UsingFight,
+    [HELP_USING_POKEMON2]               = Help_Text_UsingPokemon2,
+    [HELP_USING_SHIFT]                  = Help_Text_UsingShift,
+    [HELP_USING_SUMMARY2]               = Help_Text_UsingSummary2,
+    [HELP_USING_BAG2]                   = Help_Text_UsingBag2,
+    [HELP_READING_POKEDEX]              = Help_Text_ReadingPokedex,
+    [HELP_USING_HOME_PC]                = Help_Text_UsingHomePC,
+    [HELP_USING_ITEM_STORAGE]           = Help_Text_UsingItemStorage,
+    [HELP_USING_WITHDRAW_ITEM2]         = Help_Text_UsingWithdrawItem2,
+    [HELP_USING_DEPOSIT_ITEM2]          = Help_Text_UsingDepositItem2,
+    [HELP_USING_MAILBOX2]               = Help_Text_UsingMailbox2,
+    [HELP_USING_RUN]                    = Help_Text_UsingRun,
+    [HELP_REGISTER_KEY_ITEM]            = Help_Text_RegisterKeyItem,
+    [HELP_USING_BALL]                   = Help_Text_UsingBall,
+    [HELP_USING_BAIT]                   = Help_Text_UsingBait,
+    [HELP_USING_ROCK]                   = Help_Text_UsingRock,
+    [HELP_USING_HALL_OF_FAME]           = Help_Text_UsingHallOfFame
+};
+
+static const u8 *const sHelpSystemHowToUseMenuTextPtrs[] = {
+    [HELP_NONE]                         = NULL,
+    [HELP_USING_POKEDEX]                = Help_Text_HowToUsePokedex,
+    [HELP_USING_POKEMON]                = Help_Text_HowToUsePokemon,
+    [HELP_USING_SUMMARY]                = Help_Text_HowToUseSummary,
+    [HELP_USING_SWITCH]                 = Help_Text_HowToUseSwitch,
+    [HELP_USING_ITEM]                   = Help_Text_HowToUseItem,
+    [HELP_USING_BAG]                    = Help_Text_HowToUseBag,
+    [HELP_USING_AN_ITEM]                = Help_Text_HowToUseAnItem,
+    [HELP_USING_KEYITEM]                = Help_Text_HowToUseKeyItem,
+    [HELP_USING_POKEBALL]               = Help_Text_HowToUsePokeBall,
+    [HELP_USING_PLAYER]                 = Help_Text_HowToUsePlayer,
+    [HELP_USING_SAVE]                   = Help_Text_HowToUseSave,
+    [HELP_USING_OPTION]                 = Help_Text_HowToUseOption,
+    [HELP_USING_POTION]                 = Help_Text_HowToUsePotion,
+    [HELP_USING_TOWN_MAP]               = Help_Text_HowToUseTownMap,
+    [HELP_USING_TM]                     = Help_Text_HowToUseTM,
+    [HELP_USING_HM]                     = Help_Text_HowToUseHM,
+    [HELP_USING_MOVE_OUTSIDE_OF_BATTLE] = Help_Text_HowToUseMoveOutsideOfBattle,
+    [HELP_RIDING_BICYCLE]               = Help_Text_HowToRideBicycle,
+    [HELP_ENTERING_NAME]                = Help_Text_HowToEnterName,
+    [HELP_USING_PC]                     = Help_Text_HowToUsePC,
+    [HELP_USING_BILLS_PC]               = Help_Text_HowToUseBillsPC,
+    [HELP_USING_WITHDRAW]               = Help_Text_HowToUseWithdraw,
+    [HELP_USING_DEPOSIT]                = Help_Text_HowToUseDeposit,
+    [HELP_USING_MOVE]                   = Help_Text_HowToUseMove,
+    [HELP_MOVING_ITEMS]                 = Help_Text_HowToMoveItems,
+    [HELP_USING_PLAYERS_PC]             = Help_Text_HowToUsePlayersPC,
+    [HELP_USING_WITHDRAW_ITEM]          = Help_Text_HowToUseWithdrawItem,
+    [HELP_USING_DEPOSIT_ITEM]           = Help_Text_HowToUseDepositItem,
+    [HELP_USING_MAILBOX]                = Help_Text_HowToUseMailbox,
+    [HELP_USING_PROF_OAKS_PC]           = Help_Text_HowToUseProfOaksPC,
+    [HELP_OPENING_MENU]                 = Help_Text_HowToOpenMenu,
+    [HELP_USING_FIGHT]                  = Help_Text_HowToUseFight,
+    [HELP_USING_POKEMON2]               = Help_Text_HowToUsePokemon2,
+    [HELP_USING_SHIFT]                  = Help_Text_HowToUseShift,
+    [HELP_USING_SUMMARY2]               = Help_Text_HowToUseSummary2,
+    [HELP_USING_BAG2]                   = Help_Text_HowToUseBag2,
+    [HELP_READING_POKEDEX]              = Help_Text_HowToReadPokedex,
+    [HELP_USING_HOME_PC]                = Help_Text_HowToUseHomePC,
+    [HELP_USING_ITEM_STORAGE]           = Help_Text_HowToUseItemStorage,
+    [HELP_USING_WITHDRAW_ITEM2]         = Help_Text_HowToUseWithdrawItem2,
+    [HELP_USING_DEPOSIT_ITEM2]          = Help_Text_HowToUseDepositItem2,
+    [HELP_USING_MAILBOX2]               = Help_Text_HowToUseMailbox2,
+    [HELP_USING_RUN]                    = Help_Text_HowToUseRun,
+    [HELP_REGISTER_KEY_ITEM]            = Help_Text_HowToRegisterKeyItem,
+    [HELP_USING_BALL]                   = Help_Text_HowToUseBall,
+    [HELP_USING_BAIT]                   = Help_Text_HowToUseBait,
+    [HELP_USING_ROCK]                   = Help_Text_HowToUseRock,
+    [HELP_USING_HALL_OF_FAME]           = Help_Text_HowToUseHallOfFame
+};
+
+// Submenu IDs for TOPIC_TERMS
+enum
+{
+    HELP_TERM_HP = 1,
+    HELP_TERM_EXP,
+    HELP_TERM_MOVES,
+    HELP_TERM_ATTACK,
+    HELP_TERM_DEFENSE,
+    HELP_TERM_SPATK,
+    HELP_TERM_SPDEF,
+    HELP_TERM_SPEED,
+    HELP_TERM_LEVEL,
+    HELP_TERM_TYPE,
+    HELP_TERM_OT,
+    HELP_TERM_ITEM,
+    HELP_TERM_ABILITY,
+    HELP_TERM_MONEY,
+    HELP_TERM_MOVE_TYPE,
+    HELP_TERM_NATURE,
+    HELP_TERM_ID_NO,
+    HELP_TERM_PP,
+    HELP_TERM_POWER,
+    HELP_TERM_ACCURACY,
+    HELP_TERM_FNT,
+    HELP_TERM_ITEMS,
+    HELP_TERM_KEYITEMS,
+    HELP_TERM_POKEBALLS,
+    HELP_TERM_POKEDEX,
+    HELP_TERM_PLAY_TIME,
+    HELP_TERM_BADGES,
+    HELP_TERM_TEXT_SPEED,
+    HELP_TERM_BATTLE_SCENE,
+    HELP_TERM_BATTLE_STYLE,
+    HELP_TERM_SOUND,
+    HELP_TERM_BUTTON_MODE,
+    HELP_TERM_FRAME,
+    HELP_TERM_CANCEL,
+    HELP_TERM_TM,
+    HELP_TERM_HM,
+    HELP_TERM_HM_MOVE,
+    HELP_TERM_EVOLUTION,
+    HELP_TERM_STATUS_PROBLEM,
+    HELP_TERM_POKEMON,
+    HELP_TERM_ID_NO2,
+    HELP_TERM_MONEY2,
+    HELP_TERM_BADGES2,
+};
+
+static const u8 *const sHelpSystemTermTextPtrs[] = {
+    [HELP_NONE]                = NULL,
+    [HELP_TERM_HP]             = Help_Text_HP,
+    [HELP_TERM_EXP]            = Help_Text_EXP,
+    [HELP_TERM_MOVES]          = Help_Text_Moves,
+    [HELP_TERM_ATTACK]         = Help_Text_Attack,
+    [HELP_TERM_DEFENSE]        = Help_Text_Defense,
+    [HELP_TERM_SPATK]          = Help_Text_SpAtk,
+    [HELP_TERM_SPDEF]          = Help_Text_SpDef,
+    [HELP_TERM_SPEED]          = Help_Text_Speed,
+    [HELP_TERM_LEVEL]          = Help_Text_Level,
+    [HELP_TERM_TYPE]           = Help_Text_Type,
+    [HELP_TERM_OT]             = Help_Text_OT,
+    [HELP_TERM_ITEM]           = Help_Text_Item,
+    [HELP_TERM_ABILITY]        = Help_Text_Ability,
+    [HELP_TERM_MONEY]          = Help_Text_Money,
+    [HELP_TERM_MOVE_TYPE]      = Help_Text_MoveType,
+    [HELP_TERM_NATURE]         = Help_Text_Nature,
+    [HELP_TERM_ID_NO]          = Help_Text_IDNo,
+    [HELP_TERM_PP]             = Help_Text_PP,
+    [HELP_TERM_POWER]          = Help_Text_Power,
+    [HELP_TERM_ACCURACY]       = Help_Text_Accuracy,
+    [HELP_TERM_FNT]            = Help_Text_FNT,
+    [HELP_TERM_ITEMS]          = Help_Text_Items,
+    [HELP_TERM_KEYITEMS]       = Help_Text_KeyItems,
+    [HELP_TERM_POKEBALLS]      = Help_Text_PokeBalls,
+    [HELP_TERM_POKEDEX]        = Help_Text_Pokedex,
+    [HELP_TERM_PLAY_TIME]      = Help_Text_PlayTime,
+    [HELP_TERM_BADGES]         = Help_Text_Badges,
+    [HELP_TERM_TEXT_SPEED]     = Help_Text_TextSpeed,
+    [HELP_TERM_BATTLE_SCENE]   = Help_Text_BattleScene,
+    [HELP_TERM_BATTLE_STYLE]   = Help_Text_BattleStyle,
+    [HELP_TERM_SOUND]          = Help_Text_Sound,
+    [HELP_TERM_BUTTON_MODE]    = Help_Text_ButtonMode,
+    [HELP_TERM_FRAME]          = Help_Text_Frame,
+    [HELP_TERM_CANCEL]         = Help_Text_Cancel2,
+    [HELP_TERM_TM]             = Help_Text_TM,
+    [HELP_TERM_HM]             = Help_Text_HM,
+    [HELP_TERM_HM_MOVE]        = Help_Text_HMMove,
+    [HELP_TERM_EVOLUTION]      = Help_Text_Evolution,
+    [HELP_TERM_STATUS_PROBLEM] = Help_Text_StatusProblem,
+    [HELP_TERM_POKEMON]        = Help_Text_Pokemon,
+    [HELP_TERM_ID_NO2]         = Help_Text_IDNo2,
+    [HELP_TERM_MONEY2]         = Help_Text_Money2,
+    [HELP_TERM_BADGES2]        = Help_Text_Badges2
+};
+
+static const u8 *const sHelpSystemTermDefinitionsTextPtrs[] = {
+    [HELP_NONE]                = NULL,
+    [HELP_TERM_HP]             = Help_Text_DefineHP,
+    [HELP_TERM_EXP]            = Help_Text_DefineEXP,
+    [HELP_TERM_MOVES]          = Help_Text_DefineMoves,
+    [HELP_TERM_ATTACK]         = Help_Text_DefineAttack,
+    [HELP_TERM_DEFENSE]        = Help_Text_DefineDefense,
+    [HELP_TERM_SPATK]          = Help_Text_DefineSpAtk,
+    [HELP_TERM_SPDEF]          = Help_Text_DefineSpDef,
+    [HELP_TERM_SPEED]          = Help_Text_DefineSpeed,
+    [HELP_TERM_LEVEL]          = Help_Text_DefineLevel,
+    [HELP_TERM_TYPE]           = Help_Text_DefineType,
+    [HELP_TERM_OT]             = Help_Text_DefineOT,
+    [HELP_TERM_ITEM]           = Help_Text_DefineItem,
+    [HELP_TERM_ABILITY]        = Help_Text_DefineAbility,
+    [HELP_TERM_MONEY]          = Help_Text_DefineMoney,
+    [HELP_TERM_MOVE_TYPE]      = Help_Text_DefineMoveType,
+    [HELP_TERM_NATURE]         = Help_Text_DefineNature,
+    [HELP_TERM_ID_NO]          = Help_Text_DefineIDNo,
+    [HELP_TERM_PP]             = Help_Text_DefinePP,
+    [HELP_TERM_POWER]          = Help_Text_DefinePower,
+    [HELP_TERM_ACCURACY]       = Help_Text_DefineAccuracy,
+    [HELP_TERM_FNT]            = Help_Text_DefineFNT,
+    [HELP_TERM_ITEMS]          = Help_Text_DefineItems,
+    [HELP_TERM_KEYITEMS]       = Help_Text_DefineKeyItems,
+    [HELP_TERM_POKEBALLS]      = Help_Text_DefinePokeBalls,
+    [HELP_TERM_POKEDEX]        = Help_Text_DefinePokedex,
+    [HELP_TERM_PLAY_TIME]      = Help_Text_DefinePlayTime,
+    [HELP_TERM_BADGES]         = Help_Text_DefineBadges,
+    [HELP_TERM_TEXT_SPEED]     = Help_Text_DefineTextSpeed,
+    [HELP_TERM_BATTLE_SCENE]   = Help_Text_DefineBattleScene,
+    [HELP_TERM_BATTLE_STYLE]   = Help_Text_DefineBattleStyle,
+    [HELP_TERM_SOUND]          = Help_Text_DefineSound,
+    [HELP_TERM_BUTTON_MODE]    = Help_Text_DefineButtonMode,
+    [HELP_TERM_FRAME]          = Help_Text_DefineFrame,
+    [HELP_TERM_CANCEL]         = Help_Text_DefineCancel2,
+    [HELP_TERM_TM]             = Help_Text_DefineTM,
+    [HELP_TERM_HM]             = Help_Text_DefineHM,
+    [HELP_TERM_HM_MOVE]        = Help_Text_DefineHMMove,
+    [HELP_TERM_EVOLUTION]      = Help_Text_DefineEvolution,
+    [HELP_TERM_STATUS_PROBLEM] = Help_Text_DefineStatusProblem,
+    [HELP_TERM_POKEMON]        = Help_Text_DefinePokemon,
+    [HELP_TERM_ID_NO2]         = Help_Text_DefineIDNo2,
+    [HELP_TERM_MONEY2]         = Help_Text_DefineMoney2,
+    [HELP_TERM_BADGES2]        = Help_Text_DefineBadges2
+};
+
+// Submenu IDs for TOPIC_ABOUT_GAME
+enum
+{
+    HELP_THE_HELP_SYSTEM = 1,
+    HELP_THE_GAME,
+    HELP_WIRELESS_ADAPTER,
+    HELP_GAME_FUNDAMENTALS_1,
+    HELP_GAME_FUNDAMENTALS_2,
+    HELP_GAME_FUNDAMENTALS_3,
+    HELP_WHAT_ARE_POKEMON,
+};
+
+static const u8 *const sHelpSystemGeneralTopicTextPtrs[] = {
+    [HELP_NONE]                = NULL,
+    [HELP_THE_HELP_SYSTEM]     = Help_Text_TheHelpSystem,
+    [HELP_THE_GAME]            = Help_Text_TheGame,
+    [HELP_WIRELESS_ADAPTER]    = Help_Text_WirelessAdapter,
+    [HELP_GAME_FUNDAMENTALS_1] = Help_Text_GameFundamentals1,
+    [HELP_GAME_FUNDAMENTALS_2] = Help_Text_GameFundamentals2,
+    [HELP_GAME_FUNDAMENTALS_3] = Help_Text_GameFundamentals3,
+    [HELP_WHAT_ARE_POKEMON]    = Help_Text_WhatArePokemon
+};
+
+static const u8 *const sHelpSystemGeneralTopicDescriptionTextPtrs[] = {
+    [HELP_NONE]                = NULL,
+    [HELP_THE_HELP_SYSTEM]     = Help_Text_DescTheHelpSystem,
+    [HELP_THE_GAME]            = Help_Text_DescTheGame,
+    [HELP_WIRELESS_ADAPTER]    = Help_Text_DescWirelessAdapter,
+    [HELP_GAME_FUNDAMENTALS_1] = Help_Text_DescGameFundamentals1,
+    [HELP_GAME_FUNDAMENTALS_2] = Help_Text_DescGameFundamentals2,
+    [HELP_GAME_FUNDAMENTALS_3] = Help_Text_DescGameFundamentals3,
+    [HELP_WHAT_ARE_POKEMON]    = Help_Text_DescWhatArePokemon
+};
+
+// An enum for the type matchups isn't necessary, when used they're always used in their entirety
+// Macro below is used to reference the entire group at once
+#define HELP_TYPE_MATCHUPS  \
+    1,                      \
+    2, 3,                   \
+    4, 5,                   \
+    6, 7,                   \
+    8, 9,                   \
+    10, 11,                 \
+    12, 13,                 \
+    14, 15,                 \
+    16, 17,                 \
+    18, 19,                 \
+    20, 21,                 \
+    22, 23,                 \
+    24, 25,                 \
+    26, 27,                 \
+    28, 29,                 \
+    30, 31,                 \
+    32, 33,                 \
+    34, 35                  \
+
+static const u8 *const sHelpSystemTypeMatchupTextPtrs[] = {
+    [HELP_NONE] = NULL,
+    [1]  = Help_Text_UsingTypeMatchupList,
+    [2]  = Help_Text_OwnMoveDark,
+    [3]  = Help_Text_OwnPokemonDark,
+    [4]  = Help_Text_OwnMoveRock,
+    [5]  = Help_Text_OwnPokemonRock,
+    [6]  = Help_Text_OwnMovePsychic,
+    [7]  = Help_Text_OwnPokemonPsychic,
+    [8]  = Help_Text_OwnMoveFighting,
+    [9]  = Help_Text_OwnPokemonFighting,
+    [10] = Help_Text_OwnMoveGrass,
+    [11] = Help_Text_OwnPokemonGrass,
+    [12] = Help_Text_OwnMoveGhost,
+    [13] = Help_Text_OwnPokemonGhost,
+    [14] = Help_Text_OwnMoveIce,
+    [15] = Help_Text_OwnPokemonIce,
+    [16] = Help_Text_OwnMoveGround,
+    [17] = Help_Text_OwnPokemonGround,
+    [18] = Help_Text_OwnMoveElectric,
+    [19] = Help_Text_OwnPokemonElectric,
+    [20] = Help_Text_OwnMovePoison,
+    [21] = Help_Text_OwnPokemonPoison,
+    [22] = Help_Text_OwnMoveDragon,
+    [23] = Help_Text_OwnPokemonDragon,
+    [24] = Help_Text_OwnMoveNormal,
+    [25] = Help_Text_OwnPokemonNormal,
+    [26] = Help_Text_OwnMoveSteel,
+    [27] = Help_Text_OwnPokemonSteel,
+    [28] = Help_Text_OwnMoveFlying,
+    [29] = Help_Text_OwnPokemonFlying,
+    [30] = Help_Text_OwnMoveFire,
+    [31] = Help_Text_OwnPokemonFire,
+    [32] = Help_Text_OwnMoveWater,
+    [33] = Help_Text_OwnPokemonWater,
+    [34] = Help_Text_OwnMoveBug,
+    [35] = Help_Text_OwnPokemonBug
+};
+
+static const u8 *const sHelpSystemTypeMatchupDescriptionTextPtrs[] = {
+    [HELP_NONE] = NULL,
+    [1]  = Help_Text_HowToUseTypeMatchupList,
+    [2]  = Help_Text_TypeMatchupOwnMoveDark,
+    [3]  = Help_Text_TypeMatchupOwnPokemonDark,
+    [4]  = Help_Text_TypeMatchupOwnMoveRock,
+    [5]  = Help_Text_TypeMatchupOwnPokemonRock,
+    [6]  = Help_Text_TypeMatchupOwnMovePsychic,
+    [7]  = Help_Text_TypeMatchupOwnPokemonPsychic,
+    [8]  = Help_Text_TypeMatchupOwnMoveFighting,
+    [9]  = Help_Text_TypeMatchupOwnPokemonFighting,
+    [10] = Help_Text_TypeMatchupOwnMoveGrass,
+    [11] = Help_Text_TypeMatchupOwnPokemonGrass,
+    [12] = Help_Text_TypeMatchupOwnMoveGhost,
+    [13] = Help_Text_TypeMatchupOwnPokemonGhost,
+    [14] = Help_Text_TypeMatchupOwnMoveIce,
+    [15] = Help_Text_TypeMatchupOwnPokemonIce,
+    [16] = Help_Text_TypeMatchupOwnMoveGround,
+    [17] = Help_Text_TypeMatchupOwnPokemonGround,
+    [18] = Help_Text_TypeMatchupOwnMoveElectric,
+    [19] = Help_Text_TypeMatchupOwnPokemonElectric,
+    [20] = Help_Text_TypeMatchupOwnMovePoison,
+    [21] = Help_Text_TypeMatchupOwnPokemonPoison,
+    [22] = Help_Text_TypeMatchupOwnMoveDragon,
+    [23] = Help_Text_TypeMatchupOwnPokemonDragon,
+    [24] = Help_Text_TypeMatchupOwnMoveNormal,
+    [25] = Help_Text_TypeMatchupOwnPokemonNormal,
+    [26] = Help_Text_TypeMatchupOwnMoveSteel,
+    [27] = Help_Text_TypeMatchupOwnPokemonSteel,
+    [28] = Help_Text_TypeMatchupOwnMoveFlying,
+    [29] = Help_Text_TypeMatchupOwnPokemonFlying,
+    [30] = Help_Text_TypeMatchupOwnMoveFire,
+    [31] = Help_Text_TypeMatchupOwnPokemonFire,
+    [32] = Help_Text_TypeMatchupOwnMoveWater,
+    [33] = Help_Text_TypeMatchupOwnPokemonWater,
+    [34] = Help_Text_TypeMatchupOwnMoveBug,
+    [35] = Help_Text_TypeMatchupOwnPokemonBug
+};
+
+static const u8 sAboutGame_TitleScreen[] = {
+    HELP_THE_HELP_SYSTEM, 
+    HELP_THE_GAME, 
+    HELP_WIRELESS_ADAPTER, 
+    HELP_END
+};
+
+static const u8 sAboutGame_NewGame[] = {
+    HELP_THE_HELP_SYSTEM, 
+    HELP_THE_GAME, 
+    HELP_WIRELESS_ADAPTER, 
+    HELP_END
+};
+
+static const u8 sHowTo_NamingScreen[] = {
+    HELP_ENTERING_NAME, 
+    HELP_END
+};
+
+static const u8 sAboutGame_NamingScreen[] = {
+    HELP_THE_HELP_SYSTEM, 
+    HELP_THE_GAME, 
+    HELP_WIRELESS_ADAPTER, 
+    HELP_END
+};
+
+static const u8 sHowTo_Pokedex[] = {
+    HELP_USING_POKEDEX, 
+    HELP_READING_POKEDEX, 
+    HELP_END
+};
+
+static const u8 sHowTo_PartyMenu[] = {
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY,
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE,
+    HELP_END
+};
+
+static const u8 sTerms_PartyMenu[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_END
+};
+
+static const u8 sHowTo_PokemonInfo[] = {
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_END
+};
+
+static const u8 sTerms_PokemonInfo[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ID_NO, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_NATURE, 
+    HELP_END
+};
+
+static const u8 sTerms_PokemonSkills[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_EXP, 
+    HELP_TERM_ABILITY, 
+    HELP_END
+};
+
+static const u8 sTerms_PokemonMoves[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_END
+};
+
+static const u8 sHowTo_Bag[] = {
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_RIDING_BICYCLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Bag[] = {
+    HELP_TERM_ITEMS, 
+    HELP_TERM_KEYITEMS, 
+    HELP_TERM_POKEBALLS, 
+    HELP_END
+};
+
+static const u8 sHowTo_TrainerCardFront[] = {
+    HELP_USING_PLAYER, 
+    HELP_END
+};
+
+static const u8 sTerms_TrainerCardFront[] = {
+    HELP_TERM_ID_NO, 
+    HELP_TERM_MONEY, 
+    HELP_TERM_POKEDEX, 
+    HELP_TERM_PLAY_TIME, 
+    HELP_TERM_BADGES, 
+    HELP_END
+};
+
+static const u8 sHowTo_TrainerCardBack[] = {
+    HELP_USING_PLAYER, 
+    HELP_END
+};
+
+static const u8 sHowTo_Save[] = {
+    HELP_USING_SAVE, 
+    HELP_END
+};
+
+static const u8 sTerms_Save[] = {
+    HELP_TERM_BADGES2, 
+    HELP_TERM_POKEDEX, 
+    HELP_TERM_PLAY_TIME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Options[] = {
+    HELP_USING_OPTION, 
+    HELP_END
+};
+
+static const u8 sTerms_Options[] = {
+    HELP_TERM_TEXT_SPEED, 
+    HELP_TERM_BATTLE_SCENE, 
+    HELP_TERM_BATTLE_STYLE, 
+    HELP_TERM_SOUND, 
+    HELP_TERM_BUTTON_MODE, 
+    HELP_TERM_FRAME, 
+    HELP_TERM_CANCEL, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_PlayersHouse[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_CANT_GET_OUT_OF_ROOM, 
+    HELP_CANT_FIND_PERSON_I_WANT, 
+    HELP_END
+};
+
+static const u8 sAboutGame_PlayersHouse[] = {
+    HELP_THE_HELP_SYSTEM, 
+    HELP_THE_GAME, 
+    HELP_WIRELESS_ADAPTER, 
+    HELP_WHAT_ARE_POKEMON, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_OaksLab[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_CANT_FIND_PERSON_I_WANT, 
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_OaksLab[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM,
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_OaksLab[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_POKEMON, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_PokeCenter[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT, 
+    HELP_SOMEONE_BLOCKING_MY_WAY, 
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_PokeCenter[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_USING_PC, 
+    HELP_END
+};
+
+static const u8 sTerms_PokeCenter[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_POKEMON, 
+    HELP_END
+};
+
+static const u8 sAboutGame_PokeCenter[] = {
+    HELP_WIRELESS_ADAPTER, 
+    HELP_WHAT_ARE_POKEMON, 
+    HELP_GAME_FUNDAMENTALS_1, 
+    HELP_GAME_FUNDAMENTALS_2, 
+    HELP_GAME_FUNDAMENTALS_3, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_Mart[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT, 
+    HELP_SOMEONE_BLOCKING_MY_WAY, 
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Mart[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Mart[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_MONEY, 
+    HELP_TERM_ITEMS, 
+    HELP_TERM_KEYITEMS, 
+    HELP_TERM_POKEBALLS, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_Gym[] = {
+    HELP_SOMEONE_BLOCKING_MY_WAY, 
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Gym[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Gym[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sTypeMatchups_Gym[] = {
+    HELP_TYPE_MATCHUPS,
+    HELP_END
+};
+
+static const u8 sWhatToDo_Indoors[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_CANT_FIND_PERSON_I_WANT, 
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT, 
+    HELP_SOMEONE_BLOCKING_MY_WAY, 
+    HELP_I_CANT_GO_ON, 
+    HELP_HOW_DO_I_PROGRESS, 
+    HELP_WHAT_IS_THAT_PERSON_LIKE, 
+    HELP_OUT_OF_THINGS_TO_DO, 
+    HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT, 
+    HELP_WHAT_DO_I_DO_IN_CAVE, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_IS_A_GYM, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WHEN_CAN_I_USE_ITEM, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_CAN_I_BUY_POKEBALLS, 
+    HELP_WHATS_A_BATTLE, 
+    HELP_HOW_DO_I_PREPARE_FOR_BATTLE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_WHERE_DO_MONS_APPEAR, 
+    HELP_CANT_CATCH_MONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_WHATS_A_TRAINER, 
+    HELP_HOW_DO_I_WIN_AGAINST_TRAINER, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WANT_TO_ADD_MORE_MOVES, 
+    HELP_WHAT_ARE_HIDDEN_MOVES, 
+    HELP_WHAT_DOES_HIDDEN_MOVE_DO, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Indoors[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_SUMMARY, 
+    HELP_USING_SWITCH, 
+    HELP_USING_ITEM, 
+    HELP_USING_BAG, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_KEYITEM, 
+    HELP_REGISTER_KEY_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_POTION, 
+    HELP_USING_TOWN_MAP, 
+    HELP_USING_TM, 
+    HELP_USING_HM, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Indoors[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_ABILITY,
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_Overworld[] = {
+    HELP_WHAT_SHOULD_I_BE_DOING, 
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_CANT_FIND_PERSON_I_WANT, 
+    HELP_TALKED_TO_EVERYONE_NOW_WHAT, 
+    HELP_SOMEONE_BLOCKING_MY_WAY, 
+    HELP_I_CANT_GO_ON, 
+    HELP_HOW_DO_I_PROGRESS, 
+    HELP_WHAT_IS_THAT_PERSON_LIKE, 
+    HELP_OUT_OF_THINGS_TO_DO, 
+    HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT, 
+    HELP_WHAT_DO_I_DO_IN_CAVE, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_IS_A_GYM, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WHEN_CAN_I_USE_ITEM, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_CAN_I_BUY_POKEBALLS, 
+    HELP_WHATS_A_BATTLE, 
+    HELP_HOW_DO_I_PREPARE_FOR_BATTLE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_WHERE_DO_MONS_APPEAR, 
+    HELP_CANT_CATCH_MONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_WHATS_A_TRAINER, 
+    HELP_HOW_DO_I_WIN_AGAINST_TRAINER, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WANT_TO_ADD_MORE_MOVES, 
+    HELP_WHAT_ARE_HIDDEN_MOVES, 
+    HELP_WHAT_DOES_HIDDEN_MOVE_DO, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Overworld[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_BAG, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Overworld[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_FNT, 
+    HELP_TERM_POKEMON, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_Dungeon[] = {
+    HELP_WHAT_ARE_MY_ADVENTURE_BASICS, 
+    HELP_I_CANT_GO_ON, 
+    HELP_HOW_DO_I_PROGRESS, 
+    HELP_WHAT_IS_THAT_PERSON_LIKE, 
+    HELP_OUT_OF_THINGS_TO_DO, 
+    HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT, 
+    HELP_WHAT_DO_I_DO_IN_CAVE, 
+    HELP_WHATS_POKEMON_CENTER, 
+    HELP_WHATS_POKEMON_MART, 
+    HELP_WHAT_IS_A_GYM, 
+    HELP_WHAT_HAPPENED_TO_ITEM_I_GOT, 
+    HELP_WHEN_CAN_I_USE_ITEM, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_WHATS_A_BATTLE, 
+    HELP_HOW_DO_I_PREPARE_FOR_BATTLE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_WHERE_DO_MONS_APPEAR, 
+    HELP_CANT_CATCH_MONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_WHATS_A_TRAINER, 
+    HELP_HOW_DO_I_WIN_AGAINST_TRAINER, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WANT_TO_ADD_MORE_MOVES, 
+    HELP_WHAT_ARE_HIDDEN_MOVES, 
+    HELP_WHAT_DOES_HIDDEN_MOVE_DO, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Dungeon[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_BAG, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Dungeon[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_Surfing[] = {
+    HELP_I_CANT_GO_ON, 
+    HELP_WHAT_IS_THAT_PERSON_LIKE, 
+    HELP_OUT_OF_THINGS_TO_DO, 
+    HELP_WHAT_IS_A_GYM, 
+    HELP_CANT_CATCH_MONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_WHATS_A_TRAINER, 
+    HELP_HOW_DO_I_WIN_AGAINST_TRAINER, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WANT_TO_ADD_MORE_MOVES, 
+    HELP_WHAT_ARE_HIDDEN_MOVES, 
+    HELP_WHAT_DOES_HIDDEN_MOVE_DO, 
+    HELP_WANT_TO_END_GAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_Surfing[] = {
+    HELP_OPENING_MENU, 
+    HELP_USING_POKEDEX, 
+    HELP_USING_POKEMON, 
+    HELP_USING_BAG, 
+    HELP_USING_PLAYER, 
+    HELP_USING_SAVE, 
+    HELP_USING_OPTION, 
+    HELP_USING_MOVE_OUTSIDE_OF_BATTLE, 
+    HELP_END
+};
+
+static const u8 sTerms_Surfing[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP,
+    HELP_TERM_EXP, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_WildBattle[] = {
+    HELP_WHATS_A_BATTLE, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WHAT_MOVES_SHOULD_I_USE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_CANT_CATCH_MONS, 
+    HELP_CAN_I_BUY_POKEBALLS, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_END
+};
+
+static const u8 sHowTo_WildBattle[] = {
+    HELP_USING_FIGHT, 
+    HELP_USING_POKEMON2, 
+    HELP_USING_SHIFT, 
+    HELP_USING_SUMMARY2, 
+    HELP_USING_BAG2, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_POKEBALL, 
+    HELP_USING_RUN, 
+    HELP_END
+};
+
+static const u8 sTerms_WildBattle[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_TERM_STATUS_PROBLEM, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sTypeMatchups_WildBattle[] = {
+    HELP_TYPE_MATCHUPS,
+    HELP_END
+};
+
+static const u8 sWhatToDo_TrainerBattleSingle[] = {
+    HELP_WHATS_A_BATTLE, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WHAT_MOVES_SHOULD_I_USE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT,
+    HELP_END
+};
+
+static const u8 sHowTo_TrainerBattleSingle[] = {
+    HELP_USING_FIGHT, 
+    HELP_USING_POKEMON2, 
+    HELP_USING_SHIFT, 
+    HELP_USING_SUMMARY2, 
+    HELP_USING_BAG2, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_RUN, 
+    HELP_END
+};
+
+static const u8 sTerms_TrainerBattleSingle[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_TERM_STATUS_PROBLEM, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sTypeMatchups_TrainerBattleSingle[] = {
+    HELP_TYPE_MATCHUPS, 
+    HELP_END
+};
+
+static const u8 sWhatToDo_TrainerBattleDouble[] = {
+    HELP_WHATS_A_BATTLE, 
+    HELP_WHAT_ARE_MOVES, 
+    HELP_WHAT_MOVES_SHOULD_I_USE, 
+    HELP_WHAT_IS_A_MONS_VITALITY, 
+    HELP_MY_MONS_ARE_HURT, 
+    HELP_RAN_OUT_OF_POTIONS, 
+    HELP_WANT_TO_MAKE_MON_STRONGER, 
+    HELP_FOE_MONS_TOO_STRONG, 
+    HELP_WHAT_IS_STATUS_PROBLEM, 
+    HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT, 
+    HELP_END
+};
+
+static const u8 sHowTo_TrainerBattleDouble[] = {
+    HELP_USING_FIGHT, 
+    HELP_USING_POKEMON2, 
+    HELP_USING_SHIFT, 
+    HELP_USING_SUMMARY2, 
+    HELP_USING_BAG2, 
+    HELP_USING_AN_ITEM, 
+    HELP_USING_RUN, 
+    HELP_END
+};
+
+static const u8 sTerms_TrainerBattleDouble[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_TERM_STATUS_PROBLEM, 
+    HELP_TERM_FNT, 
+    HELP_END
+};
+
+static const u8 sTypeMatchups_TrainerBattleDouble[] = {
+    HELP_TYPE_MATCHUPS,
+    HELP_END
+};
+
+static const u8 sWhatToDo_SafariBattle[] = {
+    HELP_WHAT_DO_I_DO_IN_SAFARI, 
+    HELP_WHAT_ARE_SAFARI_RULES, 
+    HELP_WANT_TO_END_SAFARI, 
+    HELP_END
+};
+
+static const u8 sHowTo_SafariBattle[] = {
+    HELP_USING_BALL, 
+    HELP_USING_BAIT, 
+    HELP_USING_ROCK, 
+    HELP_USING_RUN, 
+    HELP_END
+};
+
+static const u8 sTerms_SafariBattle[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_END
+};
+
+static const u8 sTypeMatchups_SafariBattle[] = {
+    HELP_TYPE_MATCHUPS,
+    HELP_END
+};
+
+static const u8 sHowTo_PC[] = {
+    HELP_USING_PC, 
+    HELP_USING_BILLS_PC, 
+    HELP_USING_WITHDRAW, 
+    HELP_USING_DEPOSIT, 
+    HELP_USING_MOVE, 
+    HELP_MOVING_ITEMS, 
+    HELP_USING_PLAYERS_PC, 
+    HELP_USING_WITHDRAW_ITEM, 
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX, 
+    HELP_USING_PROF_OAKS_PC, 
+    HELP_USING_HALL_OF_FAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_BillsPC[] = {
+    HELP_USING_PC, 
+    HELP_USING_BILLS_PC, 
+    HELP_USING_WITHDRAW, 
+    HELP_USING_DEPOSIT, 
+    HELP_USING_MOVE, 
+    HELP_MOVING_ITEMS, 
+    HELP_USING_PLAYERS_PC, 
+    HELP_USING_WITHDRAW_ITEM, 
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX, 
+    HELP_USING_PROF_OAKS_PC, 
+    HELP_USING_HALL_OF_FAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_PlayersPCItems[] = {
+    HELP_USING_PC, 
+    HELP_USING_BILLS_PC, 
+    HELP_USING_WITHDRAW, 
+    HELP_USING_DEPOSIT, 
+    HELP_USING_MOVE, 
+    HELP_MOVING_ITEMS, 
+    HELP_USING_PLAYERS_PC, 
+    HELP_USING_WITHDRAW_ITEM, 
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX, 
+    HELP_USING_PROF_OAKS_PC, 
+    HELP_USING_HALL_OF_FAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_PlayersPCMailbox[] = {
+    HELP_USING_PC, 
+    HELP_USING_BILLS_PC, 
+    HELP_USING_WITHDRAW, 
+    HELP_USING_DEPOSIT, 
+    HELP_USING_MOVE, 
+    HELP_MOVING_ITEMS, 
+    HELP_USING_PLAYERS_PC, 
+    HELP_USING_WITHDRAW_ITEM, 
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX, 
+    HELP_USING_PROF_OAKS_PC, 
+    HELP_USING_HALL_OF_FAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_PCMisc[] = {
+    HELP_USING_PC, 
+    HELP_USING_BILLS_PC, 
+    HELP_USING_WITHDRAW, 
+    HELP_USING_DEPOSIT, 
+    HELP_USING_MOVE, 
+    HELP_MOVING_ITEMS, 
+    HELP_USING_PLAYERS_PC, 
+    HELP_USING_WITHDRAW_ITEM, 
+    HELP_USING_DEPOSIT_ITEM,
+    HELP_USING_MAILBOX, 
+    HELP_USING_PROF_OAKS_PC, 
+    HELP_USING_HALL_OF_FAME, 
+    HELP_END
+};
+
+static const u8 sHowTo_BedroomPC[] = {
+    HELP_USING_HOME_PC, 
+    HELP_USING_ITEM_STORAGE, 
+    HELP_USING_WITHDRAW_ITEM2, 
+    HELP_USING_DEPOSIT_ITEM2, 
+    HELP_USING_MAILBOX2, 
+    HELP_END
+};
+
+static const u8 sHowTo_BedroomPCItems[] = {
+    HELP_USING_HOME_PC, 
+    HELP_USING_ITEM_STORAGE, 
+    HELP_USING_WITHDRAW_ITEM2, 
+    HELP_USING_DEPOSIT_ITEM2, 
+    HELP_USING_MAILBOX2, 
+    HELP_END
+};
+
+static const u8 sHowTo_BedroomPCMailbox[] = {
+    HELP_USING_HOME_PC, 
+    HELP_USING_ITEM_STORAGE, 
+    HELP_USING_WITHDRAW_ITEM2, 
+    HELP_USING_DEPOSIT_ITEM2, 
+    HELP_USING_MAILBOX2, 
+    HELP_END
+};
+
+static const u8 sTerms_Basic[] = {
+    HELP_TERM_LEVEL, 
+    HELP_TERM_HP, 
+    HELP_TERM_EXP, 
+    HELP_TERM_MOVES, 
+    HELP_TERM_TM, 
+    HELP_TERM_HM_MOVE, 
+    HELP_TERM_HM, 
+    HELP_TERM_ATTACK, 
+    HELP_TERM_DEFENSE, 
+    HELP_TERM_SPATK, 
+    HELP_TERM_SPDEF, 
+    HELP_TERM_SPEED, 
+    HELP_TERM_TYPE, 
+    HELP_TERM_OT, 
+    HELP_TERM_ITEM, 
+    HELP_TERM_ABILITY, 
+    HELP_TERM_MOVE_TYPE, 
+    HELP_TERM_NATURE, 
+    HELP_TERM_ID_NO, 
+    HELP_TERM_PP, 
+    HELP_TERM_POWER, 
+    HELP_TERM_ACCURACY, 
+    HELP_TERM_STATUS_PROBLEM, 
+    HELP_TERM_FNT, 
+    HELP_TERM_EVOLUTION, 
+    HELP_TERM_ITEMS, 
+    HELP_TERM_KEYITEMS, 
+    HELP_TERM_POKEBALLS, 
+    HELP_TERM_PLAY_TIME, 
+    HELP_TERM_MONEY, 
+    HELP_TERM_BADGES, 
+    HELP_END
+};
+
+
+// Cant get this to match as a 2D array but it probably should be one, [HELPCONTEXT_COUNT][TOPIC_COUNT - 1] (Excludes TOPIC_EXIT)
+static const u8 *const sHelpSystemSubmenuItemLists[HELPCONTEXT_COUNT * (TOPIC_COUNT - 1)] = {
+    NULL,                          NULL,                       NULL,                       NULL,                    NULL, // HELPCONTEXT_NONE
+    NULL,                          NULL,                       NULL,                       sAboutGame_TitleScreen,  NULL, // HELPCONTEXT_TITLE_SCREEN
+    NULL,                          NULL,                       NULL,                       sAboutGame_NewGame,      NULL, // HELPCONTEXT_NEW_GAME
+    NULL,                          sHowTo_NamingScreen,        NULL,                       sAboutGame_NamingScreen, NULL, // HELPCONTEXT_NAMING_SCREEN
+    NULL,                          sHowTo_Pokedex,             NULL,                       NULL,                    NULL, // HELPCONTEXT_POKEDEX
+    NULL,                          sHowTo_PartyMenu,           sTerms_PartyMenu,           NULL,                    NULL, // HELPCONTEXT_PARTY_MENU
+    NULL,                          sHowTo_PokemonInfo,         sTerms_PokemonInfo,         NULL,                    NULL, // HELPCONTEXT_POKEMON_INFO
+    NULL,                          NULL,                       sTerms_PokemonSkills,       NULL,                    NULL, // HELPCONTEXT_POKEMON_SKILLS
+    NULL,                          NULL,                       sTerms_PokemonMoves,        NULL,                    NULL, // HELPCONTEXT_POKEMON_MOVES
+    NULL,                          sHowTo_Bag,                 sTerms_Bag,                 NULL,                    NULL, // HELPCONTEXT_BAG
+    NULL,                          sHowTo_TrainerCardFront,    sTerms_TrainerCardFront,    NULL,                    NULL, // HELPCONTEXT_TRAINER_CARD_FRONT
+    NULL,                          sHowTo_TrainerCardBack,     NULL,                       NULL,                    NULL, // HELPCONTEXT_TRAINER_CARD_BACK
+    NULL,                          sHowTo_Save,                sTerms_Save,                NULL,                    NULL, // HELPCONTEXT_SAVE
+    NULL,                          sHowTo_Options,             sTerms_Options,             NULL,                    NULL, // HELPCONTEXT_OPTIONS
+    sWhatToDo_PlayersHouse,        NULL,                       NULL,                       sAboutGame_PlayersHouse, NULL, // HELPCONTEXT_PLAYERS_HOUSE
+    sWhatToDo_OaksLab,             sHowTo_OaksLab,             sTerms_OaksLab,             NULL,                    NULL, // HELPCONTEXT_OAKS_LAB
+    sWhatToDo_PokeCenter,          sHowTo_PokeCenter,          sTerms_PokeCenter,          sAboutGame_PokeCenter,   NULL, // HELPCONTEXT_POKECENTER
+    sWhatToDo_Mart,                sHowTo_Mart,                sTerms_Mart,                NULL,                    NULL, // HELPCONTEXT_MART
+    sWhatToDo_Gym,                 sHowTo_Gym,                 sTerms_Gym,                 NULL,                    sTypeMatchups_Gym, // HELPCONTEXT_GYM
+    sWhatToDo_Indoors,             sHowTo_Indoors,             sTerms_Indoors,             NULL,                    NULL, // HELPCONTEXT_INDOORS
+    sWhatToDo_Overworld,           sHowTo_Overworld,           sTerms_Overworld,           NULL,                    NULL, // HELPCONTEXT_OVERWORLD
+    sWhatToDo_Dungeon,             sHowTo_Dungeon,             sTerms_Dungeon,             NULL,                    NULL, // HELPCONTEXT_DUNGEON
+    sWhatToDo_Surfing,             sHowTo_Surfing,             sTerms_Surfing,             NULL,                    NULL, // HELPCONTEXT_SURFING
+    sWhatToDo_WildBattle,          sHowTo_WildBattle,          sTerms_WildBattle,          NULL,                    sTypeMatchups_WildBattle, // HELPCONTEXT_WILD_BATTLE
+    sWhatToDo_TrainerBattleSingle, sHowTo_TrainerBattleSingle, sTerms_TrainerBattleSingle, NULL,                    sTypeMatchups_TrainerBattleSingle, // HELPCONTEXT_TRAINER_BATTLE_SINGLE
+    sWhatToDo_TrainerBattleDouble, sHowTo_TrainerBattleDouble, sTerms_TrainerBattleDouble, NULL,                    sTypeMatchups_TrainerBattleDouble, // HELPCONTEXT_TRAINER_BATTLE_DOUBLE
+    sWhatToDo_SafariBattle,        sHowTo_SafariBattle,        sTerms_SafariBattle,        NULL,                    sTypeMatchups_SafariBattle, // HELPCONTEXT_SAFARI_BATTLE
+    NULL,                          sHowTo_PC,                  NULL,                       NULL,                    NULL, // HELPCONTEXT_PC
+    NULL,                          sHowTo_BillsPC,             NULL,                       NULL,                    NULL, // HELPCONTEXT_BILLS_PC
+    NULL,                          sHowTo_PlayersPCItems,      NULL,                       NULL,                    NULL, // HELPCONTEXT_PLAYERS_PC_ITEMS
+    NULL,                          sHowTo_PlayersPCMailbox,    NULL,                       NULL,                    NULL, // HELPCONTEXT_PLAYERS_PC_MAILBOX
+    NULL,                          sHowTo_PCMisc,              NULL,                       NULL,                    NULL, // HELPCONTEXT_PC_MISC
+    NULL,                          sHowTo_BedroomPC,           NULL,                       NULL,                    NULL, // HELPCONTEXT_BEDROOM_PC
+    NULL,                          sHowTo_BedroomPCItems,      NULL,                       NULL,                    NULL, // HELPCONTEXT_BEDROOM_PC_ITEMS
+    NULL,                          sHowTo_BedroomPCMailbox,    NULL,                       NULL,                    NULL, // HELPCONTEXT_BEDROOM_PC_MAILBOX
+    NULL,                          NULL,                       NULL,                       NULL,                    NULL  // HELPCONTEXT_UNUSED
 };
 
 static const u16 unref_845BCB0[] = INCBIN_U16("graphics/help_system/unk_845BCB0.bin");
 
-static const u8 gUnknown_845C4B0[] = {
-    3, 0, 1, 2, 4, 5
-};
-
-static const u8 gUnknown_845C4B6[][6] = {
-    {0, 0, 0, 0, 0, 1},
-    {0, 0, 0, 1, 0, 1},
-    {0, 0, 0, 1, 0, 1},
-    {0, 1, 0, 1, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {0, 0, 1, 0, 0, 1},
-    {0, 0, 1, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {0, 1, 1, 0, 0, 1},
-    {1, 0, 0, 1, 0, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 1, 0, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 0, 1, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 0, 0, 1},
-    {1, 1, 1, 0, 1, 1},
-    {1, 1, 1, 0, 1, 1},
-    {1, 1, 1, 0, 1, 1},
-    {1, 1, 1, 0, 1, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 1, 0, 0, 0, 1},
-    {0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0}
+static const u8 sHelpSystemContextTopicOrder[TOPIC_COUNT] = {
+    TOPIC_ABOUT_GAME, 
+    TOPIC_WHAT_TO_DO, 
+    TOPIC_HOW_TO_DO, 
+    TOPIC_TERMS, 
+    TOPIC_TYPE_MATCHUP, 
+    TOPIC_EXIT
+};
+
+#define CONTEXT_TOPIC_FLAGS(whatToDo, howToDo, terms, aboutGame, typeMatchup, exit)     \
+    {                                                                                   \
+        [TOPIC_WHAT_TO_DO]   = whatToDo,                                                \
+        [TOPIC_HOW_TO_DO]    = howToDo,                                                 \
+        [TOPIC_TERMS]        = terms,                                                   \
+        [TOPIC_ABOUT_GAME]   = aboutGame,                                               \
+        [TOPIC_TYPE_MATCHUP] = typeMatchup,                                             \
+        [TOPIC_EXIT]         = exit                                                     \
+    }                                                                                   \
+
+static const bool8 sHelpSystemContextTopicFlags[HELPCONTEXT_COUNT + 1][TOPIC_COUNT] = {
+    [HELPCONTEXT_NONE]                  = CONTEXT_TOPIC_FLAGS(FALSE, FALSE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_TITLE_SCREEN]          = CONTEXT_TOPIC_FLAGS(FALSE, FALSE, FALSE,  TRUE, FALSE,  TRUE),
+    [HELPCONTEXT_NEW_GAME]              = CONTEXT_TOPIC_FLAGS(FALSE, FALSE, FALSE,  TRUE, FALSE,  TRUE),
+    [HELPCONTEXT_NAMING_SCREEN]         = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE,  TRUE, FALSE,  TRUE),
+    [HELPCONTEXT_POKEDEX]               = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_PARTY_MENU]            = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_POKEMON_INFO]          = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_POKEMON_SKILLS]        = CONTEXT_TOPIC_FLAGS(FALSE, FALSE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_POKEMON_MOVES]         = CONTEXT_TOPIC_FLAGS(FALSE, FALSE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_BAG]                   = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_TRAINER_CARD_FRONT]    = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_TRAINER_CARD_BACK]     = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_SAVE]                  = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_OPTIONS]               = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_PLAYERS_HOUSE]         = CONTEXT_TOPIC_FLAGS( TRUE, FALSE, FALSE,  TRUE, FALSE,  TRUE),
+    [HELPCONTEXT_OAKS_LAB]              = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_POKECENTER]            = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE,  TRUE, FALSE,  TRUE),
+    [HELPCONTEXT_MART]                  = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_GYM]                   = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE,  TRUE,  TRUE),
+    [HELPCONTEXT_INDOORS]               = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_OVERWORLD]             = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_DUNGEON]               = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_SURFING]               = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_WILD_BATTLE]           = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE,  TRUE,  TRUE),
+    [HELPCONTEXT_TRAINER_BATTLE_SINGLE] = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE,  TRUE,  TRUE),
+    [HELPCONTEXT_TRAINER_BATTLE_DOUBLE] = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE,  TRUE,  TRUE),
+    [HELPCONTEXT_SAFARI_BATTLE]         = CONTEXT_TOPIC_FLAGS( TRUE,  TRUE,  TRUE, FALSE,  TRUE,  TRUE),
+    [HELPCONTEXT_PC]                    = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_BILLS_PC]              = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_PLAYERS_PC_ITEMS]      = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_PLAYERS_PC_MAILBOX]    = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_PC_MISC]               = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_BEDROOM_PC]            = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_BEDROOM_PC_ITEMS]      = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_BEDROOM_PC_MAILBOX]    = CONTEXT_TOPIC_FLAGS(FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE),
+    [HELPCONTEXT_UNUSED]                = {},
+    [HELPCONTEXT_COUNT]                 = {}
 };
 
 static const u16 sMartMaps[] = {
@@ -878,41 +1744,45 @@ static const u8 sDungeonMaps[][3] = {
     { MAP_GROUP(SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER), MAP_NUM(SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER), 7 }
 };
 
-void HelpSystem_SetSomeVariable(u8 a0)
+void SetHelpContextDontCheckBattle(u8 contextId)
 {
-    sSomeVariable = a0;
+    sHelpSystemContextId = contextId;
 }
 
-void HelpSystem_SetSomeVariable2(u8 a0)
+void SetHelpContext(u8 contextId)
 {
-    switch (sSomeVariable)
+    switch (sHelpSystemContextId)
     {
-    case 23:
-    case 24:
-    case 25:
-    case 26:
-        if (a0 == 9 || a0 == 5 || a0 == 6 || a0 == 7 || a0 == 8)
+    case HELPCONTEXT_WILD_BATTLE:
+    case HELPCONTEXT_TRAINER_BATTLE_SINGLE:
+    case HELPCONTEXT_TRAINER_BATTLE_DOUBLE:
+    case HELPCONTEXT_SAFARI_BATTLE:
+        if (contextId == HELPCONTEXT_BAG 
+         || contextId == HELPCONTEXT_PARTY_MENU 
+         || contextId == HELPCONTEXT_POKEMON_INFO 
+         || contextId == HELPCONTEXT_POKEMON_SKILLS 
+         || contextId == HELPCONTEXT_POKEMON_MOVES)
             break;
         // fallthrough
     default:
-        sSomeVariable = a0;
+        sHelpSystemContextId = contextId;
         break;
     }
 }
 
-void Special_SetSomeVariable(void)
+void Script_SetHelpContext(void)
 {
-    sSomeVariable = gSpecialVar_0x8004;
+    sHelpSystemContextId = gSpecialVar_0x8004;
 }
 
-void HelpSystem_BackupSomeVariable(void)
+void BackupHelpContext(void)
 {
-    gSomeVariableBackup = sSomeVariable;
+    gHelpContextIdBackup = sHelpSystemContextId;
 }
 
-void HelpSystem_RestoreSomeVariable(void)
+void RestoreHelpContext(void)
 {
-    sSomeVariable = gSomeVariableBackup;
+    sHelpSystemContextId = gHelpContextIdBackup;
 }
 
 static bool32 IsInMartMap(void)
@@ -943,7 +1813,7 @@ static bool8 IsInDungeonMap(void)
 {
     u8 i, j;
 
-    for (i = 0; i < 16; i++)
+    for (i = 0; i < NELEMS(sDungeonMaps); i++)
     {
         for (j = 0; j < sDungeonMaps[i][2]; j++)
         {
@@ -959,42 +1829,52 @@ static bool8 IsInDungeonMap(void)
     return FALSE;
 }
 
-void sub_812B35C(void)
+#define IN_PLAYERS_HOUSE \
+    ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_1F) \
+  && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_1F))     \
+ || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_2F)  \
+  && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_2F)))    \
+
+ #define IN_OAKS_LAB \
+    (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PROFESSOR_OAKS_LAB) \
+  && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PROFESSOR_OAKS_LAB))    \
+
+void SetHelpContextForMap(void)
 {
-    sub_812B4B8();
+    HelpSystem_EnableToggleWithRButton();
     if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
-        HelpSystem_SetSomeVariable2(0x16);
+        SetHelpContext(HELPCONTEXT_SURFING);
     else if (IsInDungeonMap())
-        HelpSystem_SetSomeVariable2(0x15);
-    else if (is_light_level_8_or_9(gMapHeader.mapType))
+        SetHelpContext(HELPCONTEXT_DUNGEON);
+    else if (IsMapTypeIndoors(gMapHeader.mapType))
     {
-        if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_1F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_1F)) || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_2F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_2F)))
-            HelpSystem_SetSomeVariable2(0x0E);
-        else if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PROFESSOR_OAKS_LAB) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PROFESSOR_OAKS_LAB))
-            HelpSystem_SetSomeVariable2(0x0F);
+        if (IN_PLAYERS_HOUSE)
+            SetHelpContext(HELPCONTEXT_PLAYERS_HOUSE);
+        else if (IN_OAKS_LAB)
+            SetHelpContext(HELPCONTEXT_OAKS_LAB);
         else if (IsCurMapPokeCenter() == TRUE)
-            HelpSystem_SetSomeVariable2(0x10);
+            SetHelpContext(HELPCONTEXT_POKECENTER);
         else if (IsInMartMap() == TRUE)
-            HelpSystem_SetSomeVariable2(0x11);
+            SetHelpContext(HELPCONTEXT_MART);
         else if (IsInGymMap() == TRUE)
-            HelpSystem_SetSomeVariable2(0x12);
+            SetHelpContext(HELPCONTEXT_GYM);
         else
-            HelpSystem_SetSomeVariable2(0x13);
+            SetHelpContext(HELPCONTEXT_INDOORS);
     }
     else
-        HelpSystem_SetSomeVariable2(0x14);
+        SetHelpContext(HELPCONTEXT_OVERWORLD);
 }
 
-bool8 sub_812B40C(void)
+bool8 HelpSystem_UpdateHasntSeenIntro(void)
 {
-    if (gUnknown_203B0EE == 1)
+    if (sSeenHelpSystemIntro == TRUE)
         return FALSE;
 
     if (gSaveFileStatus != SAVE_STATUS_EMPTY && gSaveFileStatus != SAVE_STATUS_INVALID && FlagGet(FLAG_SYS_SAW_HELP_SYSTEM_INTRO))
         return FALSE;
 
     FlagSet(FLAG_SYS_SAW_HELP_SYSTEM_INTRO);
-    gUnknown_203B0EE = 1;
+    sSeenHelpSystemIntro = TRUE;
     return TRUE;
 }
 
@@ -1015,323 +1895,326 @@ void HelpSystem_Enable(void)
     if (gQuestLogState != 2 && gQuestLogState != 3)
     {
         gHelpSystemEnabled = TRUE;
-        sub_812B4B8();
+        HelpSystem_EnableToggleWithRButton();
     }
 }
 
-void sub_812B4AC(void)
+void HelpSystem_DisableToggleWithRButton(void)
 {
-    gUnknown_203F175 = 1;
+    gHelpSystemToggleWithRButtonDisabled = TRUE;
 }
 
-void sub_812B4B8(void)
+void HelpSystem_EnableToggleWithRButton(void)
 {
-    gUnknown_203F175 = 0;
+    gHelpSystemToggleWithRButtonDisabled = FALSE;
 }
 
-static void sub_812B4C4(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void ResetHelpSystemListMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    a0->sub.items = a1;
-    a0->sub.totalItems = 1;
-    a0->sub.maxShowed = 1;
-    a0->sub.left = 1;
-    a0->sub.top = 4;
+    helpListMenu->sub.items = listMenuItemsBuffer;
+    helpListMenu->sub.totalItems = 1;
+    helpListMenu->sub.maxShowed = 1;
+    helpListMenu->sub.left = 1;
+    helpListMenu->sub.top = 4;
 }
 
-static void sub_812B4D8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void BuildAndPrintMainTopicsListMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    sub_812B4C4(a0, a1);
-    sub_812B520(a0, a1);
-    sub_812BF74(gUnknown_841DFAC);
-    HelpSystem_InitListMenuController(a0, 0, gUnknown_3005E9C[2]);
-    sub_812BF9C(a0, a1);
+    ResetHelpSystemListMenu(helpListMenu, listMenuItemsBuffer);
+    BuildMainTopicsListAndMoveToH00(helpListMenu, listMenuItemsBuffer);
+    PrintTextOnPanel2Row52RightAlign(gUnknown_841DFAC);
+    HelpSystem_InitListMenuController(helpListMenu, 0, gHelpSystemState[2]);
+    PrintHelpSystemTopicMouseoverDescription(helpListMenu, listMenuItemsBuffer);
     sub_813BDA4(1);
     sub_813BD5C(1);
 }
 
-static void sub_812B520(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void BuildMainTopicsListAndMoveToH00(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
     u8 i;
-    u8 r4 = 0;
-    for (i = 0; i < 6; i++)
+    u8 totalItems = 0;
+    for (i = 0; i < TOPIC_COUNT; i++)
     {
-        if (gUnknown_845C4B6[sSomeVariable][gUnknown_845C4B0[i]] == 1)
+        if (sHelpSystemContextTopicFlags[sHelpSystemContextId][sHelpSystemContextTopicOrder[i]] == TRUE)
         {
-            a1[r4].label = gUnknown_845B080[gUnknown_845C4B0[i]];
-            a1[r4].index = gUnknown_845C4B0[i];
-            r4++;
+            listMenuItemsBuffer[totalItems].label = sHelpSystemTopicPtrs[sHelpSystemContextTopicOrder[i]];
+            listMenuItemsBuffer[totalItems].index = sHelpSystemContextTopicOrder[i];
+            totalItems++;
         }
     }
-    a1[r4 - 1].index = -2;
-    a0->sub.totalItems = r4;
-    a0->sub.maxShowed = r4;
-    a0->sub.left = 0;
+    listMenuItemsBuffer[totalItems - 1].index = -2;
+    helpListMenu->sub.totalItems = totalItems;
+    helpListMenu->sub.maxShowed = totalItems;
+    helpListMenu->sub.left = 0;
 }
 
-static void sub_812B5A8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void BuildAndPrintSubmenuList(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
     sub_813BDE8(0);
     sub_813BFC0(0);
     sub_813BE78(1);
-    sub_812B4C4(a0, a1);
-    sub_812B614(a0, a1);
-    sub_812BF74(gUnknown_841DFC9);
-    HelpSystem_InitListMenuController(a0, a0->field_0C, a0->field_0D);
-    HelpSystem_PrintTextAt(gUnknown_845B080[gUnknown_3005E9C[1]], 0, 0);
+    ResetHelpSystemListMenu(helpListMenu, listMenuItemsBuffer);
+    SetHelpSystemSubmenuItems(helpListMenu, listMenuItemsBuffer);
+    PrintTextOnPanel2Row52RightAlign(gUnknown_841DFC9);
+    HelpSystem_InitListMenuController(helpListMenu, helpListMenu->itemsAbove, helpListMenu->cursorPos);
+    HelpSystem_PrintTextAt(sHelpSystemTopicPtrs[gHelpSystemState[1]], 0, 0);
     sub_813BDA4(1);
     sub_813BD5C(1);
 }
 
-static void sub_812B614(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void SetHelpSystemSubmenuItems(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    u8 r6 = 0;
-    const u8 * r3 = gUnknown_845B9E0[sSomeVariable * 5 + gUnknown_3005E9C[1]];
+    u8 totalItems = 0;
+    const u8 * submenuItems = sHelpSystemSubmenuItemLists[sHelpSystemContextId * 5 + gHelpSystemState[1]]; // accessing as 2D array
     u8 i;
-    for (i = 0; r3[i] != 0xFF; i++)
+    for (i = 0; submenuItems[i] != HELP_END; i++)
     {
-        if (sub_812B780(r3[i]) == TRUE)
+        if (IsHelpSystemSubmenuEnabled(submenuItems[i]) == TRUE)
         {
-            if (gUnknown_3005E9C[1] == 0)
-                a1[r6].label = gUnknown_845B0B0[r3[i]];
-            else if (gUnknown_3005E9C[1] == 1)
-                a1[r6].label = gUnknown_845B218[r3[i]];
-            else if (gUnknown_3005E9C[1] == 2)
-                a1[r6].label = gUnknown_845B3A0[r3[i]];
-            else if (gUnknown_3005E9C[1] == 3)
-                a1[r6].label = gUnknown_845B500[r3[i]];
-            else
-                a1[r6].label = gUnknown_845B540[r3[i]];
-            a1[r6].index = r3[i];
-            r6++;
+            if (gHelpSystemState[1] == TOPIC_WHAT_TO_DO)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedQuestionTextPtrs[submenuItems[i]];
+            else if (gHelpSystemState[1] == TOPIC_HOW_TO_DO)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemMenuTopicTextPtrs[submenuItems[i]];
+            else if (gHelpSystemState[1] == TOPIC_TERMS)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemTermTextPtrs[submenuItems[i]];
+            else if (gHelpSystemState[1] == TOPIC_ABOUT_GAME)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemGeneralTopicTextPtrs[submenuItems[i]];
+            else // TOPIC_TYPE_MATCHUP
+                listMenuItemsBuffer[totalItems].label = sHelpSystemTypeMatchupTextPtrs[submenuItems[i]];
+            listMenuItemsBuffer[totalItems].index = submenuItems[i];
+            totalItems++;
         }
     }
-    if (sub_812B754() == TRUE)
+    if (HelpSystem_ShouldShowBasicTerms() == TRUE)
     {
-        for (i = 0, r3 = gUnknown_845B9BE; r3[i] != 0xFF; i++)
+        for (i = 0, submenuItems = sTerms_Basic; submenuItems[i] != HELP_END; i++)
         {
-            a1[r6].label = gUnknown_845B3A0[r3[i]];
-            a1[r6].index = r3[i];
-            r6++;
+            listMenuItemsBuffer[totalItems].label = sHelpSystemTermTextPtrs[submenuItems[i]];
+            listMenuItemsBuffer[totalItems].index = submenuItems[i];
+            totalItems++;
         }
     }
-    a1[r6].label = gUnknown_81B2E6F;
-    a1[r6].index = -2;
-    r6++;
-    a0->sub.totalItems = r6;
-    a0->sub.maxShowed = 7;
-    a0->sub.left = 0;
-    a0->sub.top = 21;
+    listMenuItemsBuffer[totalItems].label = Help_Text_Cancel;
+    listMenuItemsBuffer[totalItems].index = -2;
+    totalItems++;
+    helpListMenu->sub.totalItems = totalItems;
+    helpListMenu->sub.maxShowed = 7;
+    helpListMenu->sub.left = 0;
+    helpListMenu->sub.top = 21;
 }
 
-static bool8 sub_812B754(void)
+static bool8 HelpSystem_ShouldShowBasicTerms(void)
 {
-    if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && gUnknown_3005E9C[1] == 2)
+    if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && gHelpSystemState[1] == TOPIC_TERMS)
         return TRUE;
     return FALSE;
 }
 
-static bool8 sub_812B780(u8 id)
+static bool8 IsHelpSystemSubmenuEnabled(u8 id)
 {
     u8 i = 0;
 
-    if (gUnknown_3005E9C[1] == 0)
+    if (gHelpSystemState[1] == TOPIC_WHAT_TO_DO)
     {
         switch (id)
         {
-        case 1:
-        case 2:
-        case 3:
-        case 5:
-        case 8:
-        case 34:
-        case 38:
-        case 41:
-        case 42:
-        case 43:
+        case HELP_PLAYING_FOR_FIRST_TIME:
+        case HELP_WHAT_SHOULD_I_BE_DOING:
+        case HELP_CANT_GET_OUT_OF_ROOM:
+        case HELP_TALKED_TO_EVERYONE_NOW_WHAT:
+        case HELP_OUT_OF_THINGS_TO_DO:
+        case HELP_NOTHING_I_WANT_TO_KNOW:
+        case HELP_WHATS_A_MON:
+        case HELP_WHAT_DO_I_DO_IN_SAFARI:
+        case HELP_WHAT_ARE_SAFARI_RULES:
+        case HELP_WANT_TO_END_SAFARI:
             return TRUE;
-        case 4:
+        case HELP_CANT_FIND_PERSON_I_WANT:
             return FlagGet(FLAG_VISITED_OAKS_LAB);
-        case 6:
-        case 10:
-        case 16:
-        case 19:
-        case 22:
-        case 35:
-        case 36:
+        case HELP_SOMEONE_BLOCKING_MY_WAY:
+        case HELP_WHAT_ARE_MY_ADVENTURE_BASICS:
+        case HELP_HOW_DO_I_PREPARE_FOR_BATTLE:
+        case HELP_WHAT_IS_STATUS_PROBLEM:
+        case HELP_RAN_OUT_OF_POTIONS:
+        case HELP_WHATS_POKEMON_CENTER:
+        case HELP_WHATS_POKEMON_MART:
             return FlagGet(FLAG_WORLD_MAP_VIRIDIAN_CITY);
-        case 7:
+        case HELP_I_CANT_GO_ON:
             return FlagGet(FLAG_WORLD_MAP_VERMILION_CITY);
-        case 11:
-        case 24:
+        case HELP_HOW_ARE_ROADS_FORESTS_DIFFERENT:
+        case HELP_WHATS_A_TRAINER:
             return FlagGet(FLAG_WORLD_MAP_VIRIDIAN_FOREST);
-        case 9:
-        case 13:
-        case 14:
-        case 15:
-        case 17:
-        case 18:
-        case 20:
-        case 26:
-        case 29:
-        case 31:
-        case 37:
+        case HELP_WHAT_HAPPENED_TO_ITEM_I_GOT:
+        case HELP_WHEN_CAN_I_USE_ITEM:
+        case HELP_HOW_DO_I_PROGRESS:
+        case HELP_WHATS_A_BATTLE:
+        case HELP_WHAT_IS_A_MONS_VITALITY:
+        case HELP_MY_MONS_ARE_HURT:
+        case HELP_WHAT_HAPPENS_IF_ALL_MY_MONS_FAINT:
+        case HELP_WHERE_DO_MONS_APPEAR:
+        case HELP_WHAT_MOVES_SHOULD_I_USE:
+        case HELP_WANT_TO_MAKE_MON_STRONGER:
+        case HELP_WANT_TO_END_GAME:
             return FlagGet(FLAG_SYS_POKEMON_GET);
-        case 21:
-        case 23:
+        case HELP_CANT_CATCH_MONS:
+        case HELP_CAN_I_BUY_POKEBALLS:
             return FlagGet(FLAG_SYS_POKEDEX_GET);
-        case 12:
-        case 25:
-        case 27:
-        case 30:
-        case 32:
-        case 33:
+        case HELP_HOW_ARE_CAVES_DIFFERENT:
+        case HELP_WHAT_DO_I_DO_IN_CAVE:
+        case HELP_HOW_DO_I_WIN_AGAINST_TRAINER:
+        case HELP_FOE_MONS_TOO_STRONG:
+        case HELP_WHAT_ARE_MOVES:
+        case HELP_WANT_TO_ADD_MORE_MOVES:
             return FlagGet(FLAG_BADGE01_GET);
-        case 28:
-        case 40:
-            return sub_812BB10();
-        case 39:
+        case HELP_WHAT_ARE_HIDDEN_MOVES:
+        case HELP_WHAT_DOES_HIDDEN_MOVE_DO:
+            return HasGottenAtLeastOneHM();
+        case HELP_WHAT_IS_THAT_PERSON_LIKE:
             return FlagGet(FLAG_GOT_FAME_CHECKER);
-        case 44:
+        case HELP_WHAT_IS_A_GYM:
             return FlagGet(FLAG_WORLD_MAP_PEWTER_CITY);
         }
         return FALSE;
     }
-    if (gUnknown_3005E9C[1] == 1)
+    if (gHelpSystemState[1] == TOPIC_HOW_TO_DO)
     {
         switch (id)
         {
-        case 06:
-        case 10:
-        case 11:
-        case 12:
-        case 19:
-        case 20:
-        case 21:
-        case 22:
-        case 23:
-        case 24:
-        case 25:
-        case 26:
-        case 27:
-        case 28:
-        case 29:
-        case 31:
-        case 36:
-        case 38:
-        case 39:
-        case 40:
-        case 41:
-        case 42:
-        case 45:
-        case 46:
-        case 47:
+        case HELP_USING_BAG:
+        case HELP_USING_PLAYER:
+        case HELP_USING_SAVE:
+        case HELP_USING_OPTION:
+        case HELP_ENTERING_NAME:
+        case HELP_USING_PC:
+        case HELP_USING_BILLS_PC:
+        case HELP_USING_WITHDRAW:
+        case HELP_USING_DEPOSIT:
+        case HELP_USING_MOVE:
+        case HELP_MOVING_ITEMS:
+        case HELP_USING_PLAYERS_PC:
+        case HELP_USING_WITHDRAW_ITEM:
+        case HELP_USING_DEPOSIT_ITEM:
+        case HELP_USING_MAILBOX:
+        case HELP_OPENING_MENU:
+        case HELP_USING_BAG2:
+        case HELP_USING_HOME_PC:
+        case HELP_USING_ITEM_STORAGE:
+        case HELP_USING_WITHDRAW_ITEM2:
+        case HELP_USING_DEPOSIT_ITEM2:
+        case HELP_USING_MAILBOX2:
+        case HELP_USING_BALL:
+        case HELP_USING_BAIT:
+        case HELP_USING_ROCK:
             return TRUE;
-        case 1:
-        case 30:
-        case 37:
+        case HELP_USING_POKEDEX:
+        case HELP_USING_PROF_OAKS_PC:
+        case HELP_READING_POKEDEX:
             return FlagGet(FLAG_SYS_POKEDEX_GET);
-        case 14:
+        case HELP_USING_TOWN_MAP:
             return CheckBagHasItem(ITEM_TOWN_MAP, 1);
-        case 2:
-        case 3:
-        case 5:
-        case 7:
-        case 8:
-        case 9:
-        case 13:
-        case 32:
-        case 33:
-        case 35:
-        case 43:
-        case 44:
+        case HELP_USING_POKEMON:
+        case HELP_USING_SUMMARY:
+        case HELP_USING_ITEM:
+        case HELP_USING_AN_ITEM:
+        case HELP_USING_KEYITEM:
+        case HELP_USING_POKEBALL:
+        case HELP_USING_POTION:
+        case HELP_USING_FIGHT:
+        case HELP_USING_POKEMON2:
+        case HELP_USING_SUMMARY2:
+        case HELP_USING_RUN:
+        case HELP_REGISTER_KEY_ITEM:
             return FlagGet(FLAG_SYS_POKEMON_GET);
-        case 4:
-        case 34:
+        case HELP_USING_SWITCH:
+        case HELP_USING_SHIFT:
+            // Only show if player has caught mon after starter
             if (GetKantoPokedexCount(1) > 1)
                 return TRUE;
             return FALSE;
-        case 15:
+        case HELP_USING_TM:
             return FlagGet(FLAG_BADGE01_GET);
-        case 16:
-        case 17:
-            return sub_812BB10();
-        case 18:
+        case HELP_USING_HM:
+        case HELP_USING_MOVE_OUTSIDE_OF_BATTLE:
+            return HasGottenAtLeastOneHM();
+        case HELP_RIDING_BICYCLE:
             return FlagGet(FLAG_GOT_BICYCLE);
-        case 48:
+        case HELP_USING_HALL_OF_FAME:
             return FlagGet(FLAG_SYS_GAME_CLEAR);
         }
         return FALSE;
     }
-    if (gUnknown_3005E9C[1] == 2)
+    if (gHelpSystemState[1] == TOPIC_TERMS)
     {
-        if (sub_812B754() == TRUE)
+        if (HelpSystem_ShouldShowBasicTerms() == TRUE)
         {
-            for (i = 0; gUnknown_845B9BE[i] != 0xFF; i++)
+            // After defeating Brock, all basic terms are added
+            // This checks to make sure they arent added twice
+            for (i = 0; sTerms_Basic[i] != HELP_END; i++)
             {
-                if (gUnknown_845B9BE[i] == id)
+                if (sTerms_Basic[i] == id)
                     return FALSE;
             }
         }
         switch (id)
         {
-        case 14:
-        case 17:
-        case 22:
-        case 23:
-        case 24:
-        case 25:
-        case 26:
-        case 27:
-        case 28:
-        case 29:
-        case 30:
-        case 31:
-        case 32:
-        case 33:
-        case 34:
-        case 35:
-        case 38:
+        case HELP_TERM_MONEY:
+        case HELP_TERM_ID_NO:
+        case HELP_TERM_ITEMS:
+        case HELP_TERM_KEYITEMS:
+        case HELP_TERM_POKEBALLS:
+        case HELP_TERM_POKEDEX:
+        case HELP_TERM_PLAY_TIME:
+        case HELP_TERM_BADGES:
+        case HELP_TERM_TEXT_SPEED:
+        case HELP_TERM_BATTLE_SCENE:
+        case HELP_TERM_BATTLE_STYLE:
+        case HELP_TERM_SOUND:
+        case HELP_TERM_BUTTON_MODE:
+        case HELP_TERM_FRAME:
+        case HELP_TERM_CANCEL:
+        case HELP_TERM_TM:
+        case HELP_TERM_EVOLUTION:
             return TRUE;
-        case 1:
-        case 2:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-        case 8:
-        case 9:
-        case 10:
-        case 11:
-        case 12:
-        case 13:
-        case 16:
-        case 19:
-        case 20:
-        case 21:
+        case HELP_TERM_HP:
+        case HELP_TERM_EXP:
+        case HELP_TERM_ATTACK:
+        case HELP_TERM_DEFENSE:
+        case HELP_TERM_SPATK:
+        case HELP_TERM_SPDEF:
+        case HELP_TERM_SPEED:
+        case HELP_TERM_LEVEL:
+        case HELP_TERM_TYPE:
+        case HELP_TERM_OT:
+        case HELP_TERM_ITEM:
+        case HELP_TERM_ABILITY:
+        case HELP_TERM_NATURE:
+        case HELP_TERM_POWER:
+        case HELP_TERM_ACCURACY:
+        case HELP_TERM_FNT:
             return FlagGet(FLAG_SYS_POKEMON_GET);
-        case 36:
-        case 37:
-            return sub_812BB10();
-        case 3:
-        case 15:
-        case 18:
-        case 39:
+        case HELP_TERM_HM:
+        case HELP_TERM_HM_MOVE:
+            return HasGottenAtLeastOneHM();
+        case HELP_TERM_MOVES:
+        case HELP_TERM_MOVE_TYPE:
+        case HELP_TERM_PP:
+        case HELP_TERM_STATUS_PROBLEM:
             return FlagGet(FLAG_WORLD_MAP_VIRIDIAN_FOREST);
         }
         return TRUE;
     }
-    if (gUnknown_3005E9C[1] == 3)
+    if (gHelpSystemState[1] == TOPIC_ABOUT_GAME)
     {
         switch (id)
         {
-        case 5:
+        case HELP_GAME_FUNDAMENTALS_2:
             return FlagGet(FLAG_BADGE01_GET);
-        case 6:
+        case HELP_GAME_FUNDAMENTALS_3:
             return FlagGet(FLAG_BADGE02_GET);
         }
         return TRUE;
     }
-    if (gUnknown_3005E9C[1] == 4)
+    if (gHelpSystemState[1] == TOPIC_TYPE_MATCHUP)
     {
         return TRUE;
     }
@@ -1339,7 +2222,7 @@ static bool8 sub_812B780(u8 id)
     return FALSE;
 }
 
-static bool8 sub_812BB10(void)
+static bool8 HasGottenAtLeastOneHM(void)
 {
     if (FlagGet(FLAG_GOT_HM01) == TRUE)
         return TRUE;
@@ -1358,117 +2241,117 @@ static bool8 sub_812BB10(void)
     return FALSE;
 }
 
-bool8 sub_812BB9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 RunHelpMenuSubroutine(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    switch (a0->field_0E)
+    switch (helpListMenu->state)
     {
     case  8:
-        return sub_812BC54(a0, a1);
+        return HelpSystemSubroutine_PrintWelcomeMessage(helpListMenu, listMenuItemsBuffer);
     case  9:
-        return sub_812BC80(a0, a1);
+        return HelpSystemSubroutine_WelcomeWaitButton(helpListMenu, listMenuItemsBuffer);
     case 10:
-        return sub_812BCA8(a0, a1);
+        return HelpSystemSubroutine_WelcomeEndGotoMenu(helpListMenu, listMenuItemsBuffer);
     case  0:
-        return sub_812BCD0(a0, a1);
+        return HelpSystemSubroutine_MenuInputHandlerMain(helpListMenu, listMenuItemsBuffer);
     case  1:
-        return sub_812BD2C(a0, a1);
+        return HelpMenuSubroutine_InitSubmenu(helpListMenu, listMenuItemsBuffer);
     case  2:
-        return sub_812BD64(a0, a1);
+        return HelpMenuSubroutine_ReturnFromSubmenu(helpListMenu, listMenuItemsBuffer);
     case  3:
-        return sub_812BD98(a0, a1);
+        return HelpMenuSubroutine_SubmenuInputHandler(helpListMenu, listMenuItemsBuffer);
     case  4:
-        return sub_812BE10(a0, a1);
+        return HelpMenuSubroutine_HelpItemPrint(helpListMenu, listMenuItemsBuffer);
     case  5:
-        return sub_812BEEC(a0, a1);
+        return HelpMenuSubroutine_ReturnFromHelpItem(helpListMenu, listMenuItemsBuffer);
     case  6:
-        return sub_812BF18(a0, a1);
+        return HelpMenuSubroutine_HelpItemWaitButton(helpListMenu, listMenuItemsBuffer);
     }
     return FALSE;
 }
 
-bool8 sub_812BC54(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpSystemSubroutine_PrintWelcomeMessage(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    sub_812BF74(gUnknown_841DFA5);
-    sub_812BF5C();
+    PrintTextOnPanel2Row52RightAlign(gUnknown_841DFA5);
+    PrintWelcomeMessageOnPanel1();
     sub_813BDA4(1);
     sub_813BD5C(1);
-    a0->field_0E = 9;
+    helpListMenu->state = 9;
     return TRUE;
 }
 
-bool8 sub_812BC80(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpSystemSubroutine_WelcomeWaitButton(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
     if (JOY_NEW(A_BUTTON))
     {
         PlaySE(SE_SELECT);
-        a0->field_0E = 10;
+        helpListMenu->state = 10;
     }
     return TRUE;
 }
 
-bool8 sub_812BCA8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpSystemSubroutine_WelcomeEndGotoMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    gUnknown_3005E9C[2] = 0;
-    sub_812BF94(a0);
-    sub_812B4D8(a0, a1);
-    a0->field_0E = 0;
+    gHelpSystemState[2] = 0;
+    ResetHelpSystemCursor(helpListMenu);
+    BuildAndPrintMainTopicsListMenu(helpListMenu, listMenuItemsBuffer);
+    helpListMenu->state = 0;
     return TRUE;
 }
 
-bool8 sub_812BCD0(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpSystemSubroutine_MenuInputHandlerMain(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    s32 v0 = HelpSystem_GetMenuInput();
-    switch (v0)
+    s32 input = HelpSystem_GetMenuInput();
+    switch (input)
     {
     case -6:
     case -2:
         return FALSE;
     case -5:
     case -4:
-        sub_812BF9C(a0, a1);
+        PrintHelpSystemTopicMouseoverDescription(helpListMenu, listMenuItemsBuffer);
         break;
     case -3:
     case -1:
         break;
     default:
-        gUnknown_3005E9C[1] = v0;
-        a0->field_0E = 1;
+        gHelpSystemState[1] = input;
+        helpListMenu->state = 1;
         break;
     }
     return TRUE;
 }
 
-bool8 sub_812BD2C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_InitSubmenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    gUnknown_3005E9C[0] = 1;
-    gUnknown_3005E9C[2] = a0->field_0D;
-    sub_812BF94(a0);
-    sub_812B5A8(a0, a1);
+    gHelpSystemState[0] = 1;
+    gHelpSystemState[2] = helpListMenu->cursorPos;
+    ResetHelpSystemCursor(helpListMenu);
+    BuildAndPrintSubmenuList(helpListMenu, listMenuItemsBuffer);
     sub_813C75C();
     HelpSystem_SetInputDelay(2);
-    a0->field_0E = 3;
+    helpListMenu->state = 3;
     return TRUE;
 }
 
-bool8 sub_812BD64(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_ReturnFromSubmenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
     sub_813C004(0, 0);
     sub_813C004(1, 0);
-    gUnknown_3005E9C[0] = 0;
-    sub_812B4D8(a0, a1);
-    a0->field_0E = 0;
+    gHelpSystemState[0] = 0;
+    BuildAndPrintMainTopicsListMenu(helpListMenu, listMenuItemsBuffer);
+    helpListMenu->state = 0;
     return TRUE;
 }
 
-bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_SubmenuInputHandler(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    s32 v0 = HelpSystem_GetMenuInput();
-    switch (v0)
+    s32 input = HelpSystem_GetMenuInput();
+    switch (input)
     {
     case -6:
         return FALSE;
     case -2:
-        a0->field_0E = 2;
+        helpListMenu->state = 2;
         break;
     case -5:
     case -4:
@@ -1476,69 +2359,69 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
     case -1:
         break;
     default:
-        gUnknown_3005E9C[3] = v0;
-        a0->field_0E = 4;
+        gHelpSystemState[3] = input;
+        helpListMenu->state = 4;
         break;
     }
     return TRUE;
 }
 
-void sub_812BDEC(void)
+void HelpSystem_PrintTopicLabel(void)
 {
-    HelpSystem_PrintTextAt(gUnknown_845B080[gUnknown_3005E9C[1]], 0, 0);
+    HelpSystem_PrintTextAt(sHelpSystemTopicPtrs[gHelpSystemState[1]], 0, 0);
 }
 
-bool8 sub_812BE10(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_HelpItemPrint(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    gUnknown_3005E9C[0] = 2;
+    gHelpSystemState[0] = 2;
     sub_813BDA4(0);
     HelpSystem_FillPanel1();
-    sub_812BF74(gUnknown_841DFBE);
+    PrintTextOnPanel2Row52RightAlign(gUnknown_841DFBE);
     sub_813BDE8(1);
     sub_813BEE4(1);
 
-    if (gUnknown_3005E9C[1] == 0)
+    if (gHelpSystemState[1] == TOPIC_WHAT_TO_DO)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B0B0[gUnknown_3005E9C[3]], gUnknown_845B164[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemSpecializedQuestionTextPtrs[gHelpSystemState[3]], sHelpSystemSpecializedAnswerTextPtrs[gHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 1)
+    else if (gHelpSystemState[1] == TOPIC_HOW_TO_DO)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B218[gUnknown_3005E9C[3]], gUnknown_845B2DC[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemMenuTopicTextPtrs[gHelpSystemState[3]], sHelpSystemHowToUseMenuTextPtrs[gHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 2)
+    else if (gHelpSystemState[1] == TOPIC_TERMS)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B3A0[gUnknown_3005E9C[3]], gUnknown_845B450[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemTermTextPtrs[gHelpSystemState[3]], sHelpSystemTermDefinitionsTextPtrs[gHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 3)
+    else if (gHelpSystemState[1] == TOPIC_ABOUT_GAME)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B500[gUnknown_3005E9C[3]], gUnknown_845B520[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemGeneralTopicTextPtrs[gHelpSystemState[3]], sHelpSystemGeneralTopicDescriptionTextPtrs[gHelpSystemState[3]]);
     }
-    else
+    else // TOPIC_TYPE_MATCHUP
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B540[gUnknown_3005E9C[3]], gUnknown_845B5D0[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemTypeMatchupTextPtrs[gHelpSystemState[3]], sHelpSystemTypeMatchupDescriptionTextPtrs[gHelpSystemState[3]]);
     }
     sub_813BDA4(1);
     sub_813BD5C(1);
-    a0->field_0E = 6;
+    helpListMenu->state = 6;
     return TRUE;
 }
 
-bool8 sub_812BEEC(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_ReturnFromHelpItem(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    gUnknown_3005E9C[0] = 1;
-    sub_812B5A8(a0, a1);
+    gHelpSystemState[0] = 1;
+    BuildAndPrintSubmenuList(helpListMenu, listMenuItemsBuffer);
     sub_813C75C();
     HelpSystem_SetInputDelay(2);
-    a0->field_0E = 3;
+    helpListMenu->state = 3;
     return TRUE;
 }
 
-bool8 sub_812BF18(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+bool8 HelpMenuSubroutine_HelpItemWaitButton(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
     if (JOY_NEW(B_BUTTON) || JOY_NEW(A_BUTTON))
     {
         PlaySE(SE_SELECT);
-        a0->field_0E = 5;
+        helpListMenu->state = 5;
         return TRUE;
     }
     if (JOY_NEW(L_BUTTON | R_BUTTON))
@@ -1546,13 +2429,13 @@ bool8 sub_812BF18(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
     return TRUE;
 }
 
-static void sub_812BF5C(void)
+static void PrintWelcomeMessageOnPanel1(void)
 {
     HelpSystem_FillPanel1();
-    HelpSystem_PrintTextAt(gUnknown_81B2FC9, 0, 0);
+    HelpSystem_PrintTextAt(Help_Text_Greetings, 0, 0);
 }
 
-static void sub_812BF74(const u8 * str)
+static void PrintTextOnPanel2Row52RightAlign(const u8 * str)
 {
     HelpSystem_FillPanel2();
     HelpSystem_PrintTextRightAlign_Row52(str);
@@ -1560,21 +2443,21 @@ static void sub_812BF74(const u8 * str)
 
 u8 sub_812BF88(void)
 {
-    return gUnknown_3005E9C[0];
+    return gHelpSystemState[0];
 }
 
-static void sub_812BF94(struct HelpSystemListMenu * a0)
+static void ResetHelpSystemCursor(struct HelpSystemListMenu * helpListMenu)
 {
-    a0->field_0C = 0;
-    a0->field_0D = 0;
+    helpListMenu->itemsAbove = 0;
+    helpListMenu->cursorPos = 0;
 }
 
-static void sub_812BF9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
+static void PrintHelpSystemTopicMouseoverDescription(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer)
 {
-    s32 index = a1[a0->field_0C + a0->field_0D].index;
+    s32 index = listMenuItemsBuffer[helpListMenu->itemsAbove + helpListMenu->cursorPos].index;
     if (index == -2)
-        HelpSystem_PrintText_813C584(gUnknown_845B098[5]);
+        HelpSystem_PrintText_813C584(sHelpSystemTopicMouseoverDescriptionPtrs[5]);
     else
-        HelpSystem_PrintText_813C584(gUnknown_845B098[index]);
+        HelpSystem_PrintText_813C584(sHelpSystemTopicMouseoverDescriptionPtrs[index]);
     sub_813BE30(1);
 }
diff --git a/src/hof_pc.c b/src/hof_pc.c
index 76fd06abf..173625774 100644
--- a/src/hof_pc.c
+++ b/src/hof_pc.c
@@ -5,7 +5,6 @@
 #include "script.h"
 #include "script_menu.h"
 #include "task.h"
-#include "hall_of_fame.h"
 #include "bg.h"
 #include "window.h"
 
@@ -40,7 +39,7 @@ static void ReshowPCMenuAfterHallOfFamePC(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
-    ScrSpecial_CreatePCMenu();
+    CreatePCMenu();
     ScriptMenu_DisplayPCStartupPrompt();
     BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK);
     CreateTask(Task_WaitForPaletteFade, 10);
diff --git a/src/ice.c b/src/ice.c
index 4ed6e0ece..6843538f9 100644
--- a/src/ice.c
+++ b/src/ice.c
@@ -1,10 +1,8 @@
 #include "global.h"
 #include "battle_anim.h"
 #include "bg.h"
-#include "field_weather.h"
 #include "gpu_regs.h"
 #include "graphics.h"
-#include "main.h"
 #include "palette.h"
 #include "random.h"
 #include "sprite.h"
diff --git a/src/intro.c b/src/intro.c
index cee1c8fec..837d4f905 100644
--- a/src/intro.c
+++ b/src/intro.c
@@ -1431,7 +1431,7 @@ static void sub_80EDB70(struct IntroSequenceData * this)
 {
     this->field_0018->pos1.x += this->field_0018->pos2.x;
     this->field_0018->pos1.y += this->field_0018->pos2.y;
-    sub_8007FFC(this->field_0018, 0, 0x2A);
+    obj_pos2_update_enable(this->field_0018, 0, 0x2A);
     this->field_0018->callback = SpriteCallbackDummy;
     StartSpriteAffineAnim(this->field_0018, 1);
 }
@@ -1448,7 +1448,7 @@ static void sub_80EDBAC(struct IntroSequenceData * this)
     {
         StartSpriteAffineAnim(this->field_0028[i], 1);
         this->field_0028[i]->callback = nullsub_83;
-        sub_8007FFC(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]);
+        obj_pos2_update_enable(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]);
     }
 }
 
diff --git a/src/item.c b/src/item.c
index d1f732b4d..296ba8ec7 100644
--- a/src/item.c
+++ b/src/item.c
@@ -12,6 +12,8 @@
 #include "constants/items.h"
 #include "constants/maps.h"
 
+EWRAM_DATA struct BagPocket gBagPockets[NUM_BAG_POCKETS] = {};
+
 void SortAndCompactBagPocket(struct BagPocket * pocket);
 
 // Item descriptions and data
diff --git a/src/item_menu.c b/src/item_menu.c
index ffba2eae9..4131e7fd5 100644
--- a/src/item_menu.c
+++ b/src/item_menu.c
@@ -5,7 +5,7 @@
 #include "berry_pouch.h"
 #include "decompress.h"
 #include "event_scripts.h"
-#include "event_object_80688E4.h"
+#include "event_object_movement.h"
 #include "field_player_avatar.h"
 #include "graphics.h"
 #include "help_system.h"
@@ -496,9 +496,9 @@ static bool8 LoadBagMenuGraphics(void)
         break;
     case 19:
         if (gBagMenuState.location == ITEMMENULOCATION_ITEMPC)
-            HelpSystem_SetSomeVariable2(29);
+            SetHelpContext(HELPCONTEXT_PLAYERS_PC_ITEMS);
         else
-            HelpSystem_SetSomeVariable2(9);
+            SetHelpContext(HELPCONTEXT_BAG);
         gPaletteFade.bufferTransferDisabled = FALSE;
         gMain.state++;
         break;
@@ -740,7 +740,7 @@ static void bag_menu_print_cursor(u8 y, u8 colorIdx)
     }
     else
     {
-        BagPrintTextOnWindow(0, 2, gFameCheckerText_ListMenuCursor, 1, y, 0, 0, 0, colorIdx);
+        BagPrintTextOnWindow(0, 2, gText_SelectorArrow2, 1, y, 0, 0, 0, colorIdx);
     }
 }
 
@@ -1434,7 +1434,7 @@ static void OpenContextMenu(u8 taskId)
     Menu_InitCursor(r6, 2, 0, 2, GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT) + 2, sContextMenuNumItems, 0);
     r4 = ShowBagWindow(6, 0);
     CopyItemName(gSpecialVar_ItemId, gStringVar1);
-    StringExpandPlaceholders(gStringVar4, gOtherText_StrVar1);
+    StringExpandPlaceholders(gStringVar4, gText_Var1IsSelected);
     BagPrintTextOnWindow(r4, 2, gStringVar4, 0, 2, 1, 0, 0, 1);
 }
 
diff --git a/src/item_pc.c b/src/item_pc.c
index 7c7abdce3..46419f2f3 100644
--- a/src/item_pc.c
+++ b/src/item_pc.c
@@ -361,7 +361,7 @@ static bool8 ItemPc_DoGfxSetup(void)
         gMain.state++;
         break;
     case 17:
-        HelpSystem_SetSomeVariable2(29);
+        SetHelpContext(HELPCONTEXT_PLAYERS_PC_ITEMS);
         gMain.state++;
         break;
     case 18:
@@ -577,7 +577,7 @@ static void ItemPc_PrintOrRemoveCursorAt(u8 y, u8 colorIdx)
     }
     else
     {
-        ItemPc_AddTextPrinterParameterized(0, 2, gFameCheckerText_ListMenuCursor, 0, y, 0, 0, 0, colorIdx);
+        ItemPc_AddTextPrinterParameterized(0, 2, gText_SelectorArrow2, 0, y, 0, 0, 0, colorIdx);
     }
 }
 
@@ -848,7 +848,7 @@ static void Task_ItemPcSubmenuInit(u8 taskId)
     PrintTextArray(4, 2, 8, 2, GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT) + 2, 3, sItemPcSubmenuOptions);
     Menu_InitCursor(4, 2, 0, 2, GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT) + 2, 3, 0);
     CopyItemName(ItemPc_GetItemIdBySlotId(data[1]), gStringVar1);
-    StringExpandPlaceholders(gStringVar4, gOtherText_StrVar1);
+    StringExpandPlaceholders(gStringVar4, gText_Var1IsSelected);
     ItemPc_AddTextPrinterParameterized(windowId, 2, gStringVar4, 0, 2, 1, 0, 0, 1);
     ScheduleBgCopyTilemapToVram(0);
     gTasks[taskId].func = Task_ItemPcSubmenuRun;
diff --git a/src/item_use.c b/src/item_use.c
index 57771754a..6f81ee0e3 100644
--- a/src/item_use.c
+++ b/src/item_use.c
@@ -19,7 +19,6 @@
 #include "mail.h"
 #include "main.h"
 #include "malloc.h"
-#include "event_object_80688E4.h"
 #include "event_object_lock.h"
 #include "metatile_behavior.h"
 #include "new_menu_helpers.h"
@@ -42,7 +41,7 @@
 #include "constants/maps.h"
 #include "constants/moves.h"
 #include "constants/songs.h"
-#include "constants/map_types.h"
+#include "constants/field_weather.h"
 
 static EWRAM_DATA void (*sItemUseOnFieldCB)(u8 taskId) = NULL;
 
@@ -172,7 +171,7 @@ static void sub_80A103C(u8 taskId)
 
 static void sub_80A1084(void)
 {
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(sub_80A109C, 8);
 }
 
@@ -225,7 +224,7 @@ static bool8 sub_80A1194(void)
 {
     FreezeObjectEvents();
     ScriptContext2_Enable();
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(sub_80A11C0, 10);
     gUnknown_2031DE0 = 0;
     return TRUE;
@@ -458,7 +457,7 @@ void FieldUseFunc_TmCase(u8 taskId)
     else
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = Task_InitTMCaseFromField;
     }
 }
@@ -489,7 +488,7 @@ void FieldUseFunc_BerryPouch(u8 taskId)
     else
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = Task_InitBerryPouchFromField;
     }
 }
@@ -532,7 +531,7 @@ void FieldUseFunc_TeachyTv(u8 taskId)
     else
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = Task_InitTeachyTvFromField;
     }
 }
@@ -648,7 +647,7 @@ static void sub_80A1C08(u8 taskId)
 void sub_80A1C44(u8 taskId)
 {
     ResetInitialPlayerAvatarState();
-    sub_8085620();
+    StartEscapeRopeFieldEffect();
     DestroyTask(taskId);
 }
 
@@ -662,7 +661,7 @@ void FieldUseFunc_TownMap(u8 taskId)
     else
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = sub_80A1CC0;
     }
 }
@@ -694,7 +693,7 @@ void FieldUseFunc_FameChecker(u8 taskId)
     else
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = sub_80A1D68;
     }
 }
diff --git a/src/itemfinder.c b/src/itemfinder.c
index 370fce841..5d6950acc 100644
--- a/src/itemfinder.c
+++ b/src/itemfinder.c
@@ -10,7 +10,6 @@
 #include "field_player_avatar.h"
 #include "field_specials.h"
 #include "fieldmap.h"
-#include "itemfinder.h"
 #include "constants/songs.h"
 
 static void Task_NoResponse_CleanUp(u8 taskId);
diff --git a/src/keyboard_text.c b/src/keyboard_text.c
new file mode 100644
index 000000000..5db1a6aaa
--- /dev/null
+++ b/src/keyboard_text.c
@@ -0,0 +1,61 @@
+#include "global.h"
+
+// easy_chat_3
+const u8 gUnknown_847A8D8[] = _("{CLEAR 11}A{CLEAR 6}B{CLEAR 6}C{CLEAR 26}D{CLEAR 6}E{CLEAR 6}F{CLEAR 26}others");
+const u8 gUnknown_847A8FA[] = _("{CLEAR 11}G{CLEAR 6}H{CLEAR 6}I{CLEAR 26}J{CLEAR 6}K{CLEAR 6}L");
+const u8 gUnknown_847A913[] = _("{CLEAR 11}M{CLEAR 6}N{CLEAR 6}O{CLEAR 26}P{CLEAR 6}Q{CLEAR 6}R{CLEAR 6}S{CLEAR 26} ");
+const u8 gUnknown_847A934[] = _("{CLEAR 11}T{CLEAR 6}U{CLEAR 6}V{CLEAR 26}W{CLEAR 6}X{CLEAR 6}Y{CLEAR 6}Z{CLEAR 26} ");
+
+// naming_screen
+const u8 gText_NamingScreenKeyboard_abcdef[] = _("{CLEAR 11}a{CLEAR 6}b{CLEAR 6}c{CLEAR 26}d{CLEAR 6}e{CLEAR 6}f{CLEAR 6} {CLEAR 26}.");
+const u8 gText_NamingScreenKeyboard_ghijkl[] = _("{CLEAR 11}g{CLEAR 6}h{CLEAR 7}i{CLEAR 27}j{CLEAR 6}k{CLEAR 6}l{CLEAR 7} {CLEAR 26},");
+const u8 gText_NamingScreenKeyboard_mnopqrs[] = _("{CLEAR 11}m{CLEAR 6}n{CLEAR 7}o{CLEAR 26}p{CLEAR 6}q{CLEAR 7}r{CLEAR 6}s{CLEAR 27} ");
+const u8 gText_NamingScreenKeyboard_tuvwxyz[] = _("{CLEAR 12}t{CLEAR 6}u{CLEAR 6}v{CLEAR 26}w{CLEAR 6}x{CLEAR 6}y{CLEAR 6}z{CLEAR 26} ");
+const u8 gText_NamingScreenKeyboard_ABCDEF[] = _("{CLEAR 11}A{CLEAR 6}B{CLEAR 6}C{CLEAR 26}D{CLEAR 6}E{CLEAR 6}F{CLEAR 6} {CLEAR 26}.");
+const u8 gText_NamingScreenKeyboard_GHIJKL[] = _("{CLEAR 11}G{CLEAR 6}H{CLEAR 6}I{CLEAR 26}J{CLEAR 6}K{CLEAR 6}L{CLEAR 6} {CLEAR 26},");
+const u8 gText_NamingScreenKeyboard_MNOPQRS[] = _("{CLEAR 11}M{CLEAR 6}N{CLEAR 6}O{CLEAR 26}P{CLEAR 6}Q{CLEAR 6}R{CLEAR 6}S{CLEAR 26} ");
+const u8 gText_NamingScreenKeyboard_TUVWXYZ[] = _("{CLEAR 11}T{CLEAR 6}U{CLEAR 6}V{CLEAR 26}W{CLEAR 6}X{CLEAR 6}Y{CLEAR 6}Z{CLEAR 26} ");
+const u8 gText_NamingScreenKeyboard_01234[] = _("{CLEAR 11}0{CLEAR 16}1{CLEAR 16}2{CLEAR 16}3{CLEAR 16}4{CLEAR 16} ");
+const u8 gText_NamingScreenKeyboard_56789[] = _("{CLEAR 11}5{CLEAR 16}6{CLEAR 16}7{CLEAR 16}8{CLEAR 16}9{CLEAR 16} ");
+const u8 gText_NamingScreenKeyboard_Symbols1[] = _("{CLEAR 11}!{CLEAR 16}?{CLEAR 16}♂{CLEAR 16}♀{CLEAR 16}/{CLEAR 16}-");
+const u8 gText_NamingScreenKeyboard_Symbols2[] = _("{CLEAR 11}…{CLEAR 16}“{CLEAR 16}”{CLEAR 18}‘{CLEAR 18}'{CLEAR 18} ");
+
+// union_room_chat
+const u8 gText_UnionRoomChatKeyboard_ABCDE[] = _("ABCDE");
+const u8 gText_UnionRoomChatKeyboard_FGHIJ[] = _("FGHIJ");
+const u8 gText_UnionRoomChatKeyboard_KLMNO[] = _("KLMNO");
+const u8 gText_UnionRoomChatKeyboard_PQRST[] = _("PQRST");
+const u8 gText_UnionRoomChatKeyboard_UVWXY[] = _("UVWXY");
+const u8 gText_UnionRoomChatKeyboard_Z[] = _("Z    ");
+const u8 gText_UnionRoomChatKeyboard_01234Upper[] = _("01234");
+const u8 gText_UnionRoomChatKeyboard_56789Upper[] = _("56789");
+const u8 gText_UnionRoomChatKeyboard_PunctuationUpper[] = _(".,!? ");
+const u8 gText_UnionRoomChatKeyboard_SymbolsUpper[] = _("-/&… ");
+const u8 gText_UnionRoomChatKeyboard_abcde[] = _("abcde");
+const u8 gText_UnionRoomChatKeyboard_fghij[] = _("fghij");
+const u8 gText_UnionRoomChatKeyboard_klmno[] = _("klmno");
+const u8 gText_UnionRoomChatKeyboard_pqrst[] = _("pqrst");
+const u8 gText_UnionRoomChatKeyboard_uvwxy[] = _("uvwxy");
+const u8 gText_UnionRoomChatKeyboard_z[] = _("z    ");
+const u8 gText_UnionRoomChatKeyboard_01234Lower[] = _("01234");
+const u8 gText_UnionRoomChatKeyboard_56789Lower[] = _("56789");
+const u8 gText_UnionRoomChatKeyboard_PunctuationLower[] = _(".,!? ");
+const u8 gText_UnionRoomChatKeyboard_SymbolsLower[] = _("-/&… ");
+const u8 gText_BlankString_847AB39[] = _("");
+const u8 gText_BlankString_847AB3A[] = _("");
+const u8 gText_BlankString_847AB3B[] = _("");
+const u8 gText_BlankString_847AB3C[] = _("");
+const u8 gText_BlankString_847AB3D[] = _("");
+const u8 gText_BlankString_847AB3E[] = _("");
+const u8 gText_BlankString_847AB3F[] = _("");
+const u8 gText_BlankString_847AB40[] = _("");
+const u8 gText_UnionRoomChatKeyboard_Emoji1[] = _("{EXTRA 245}{EXTRA 246}{EXTRA 247}{EXTRA 248}{EXTRA 254}");
+const u8 gText_UnionRoomChatKeyboard_Emoji2[] = _("{EXTRA 249}{EXTRA 250}{EXTRA 252}{EXTRA 251}{EXTRA 253}");
+const u8 gText_UnionRoomChatKeyboard_Emoji3[] = _("{EXTRA 236}{EXTRA 237}{EXTRA 238}{EXTRA 235}{EXTRA 234}");
+const u8 gText_UnionRoomChatKeyboard_Emoji4[] = _("♂♀{EXTRA 212}{EXTRA 213}{EXTRA 211}");
+const u8 gText_UnionRoomChatKeyboard_Emoji5[] = _("{EXTRA 216}{EXTRA 217}{EXTRA 242}{EXTRA 243}{EXTRA 244}");
+const u8 gText_UnionRoomChatKeyboard_Emoji6[] = _("{EXTRA 218}{EXTRA 241}{EXTRA 224}{EXTRA 226}{EXTRA 227}");
+const u8 gText_UnionRoomChatKeyboard_Emoji7[] = _("{EXTRA 240}{EXTRA 239}{EXTRA 225}{EXTRA 214}{EXTRA 215}");
+const u8 gText_UnionRoomChatKeyboard_Emoji8[] = _("{EXTRA 228}{EXTRA 229}{EXTRA 230}{EXTRA 231}{EXTRA 232}");
+const u8 gText_UnionRoomChatKeyboard_Emoji9[] = _("{EXTRA 233}{EXTRA 220}{EXTRA 221}{EXTRA 222}{EXTRA 209}");
+const u8 gText_UnionRoomChatKeyboard_Emoji10[] = _("{EXTRA 210}{EXTRA 208}ょ: ");
diff --git a/src/learn_move.c b/src/learn_move.c
index e22922528..8a2f5781b 100644
--- a/src/learn_move.c
+++ b/src/learn_move.c
@@ -309,7 +309,7 @@ static void MoveRelearnerLoadBgGfx(void)
         FillBgTilemapBufferRect(0, 0x000, 0, 0, 30, 20, 0xF);
         SetBgTilemapBuffer(1, sMoveRelearner->bg1TilemapBuffer);
         TextWindow_SetUserSelectedFrame(0, 1, 0xE0);
-        sub_8107D38(0xD0, 1);
+        ListMenuLoadStdPalAt(0xD0, 1);
         LoadPalette(gUnknown_8E97DDC, 0x00, 0x20);
         DecompressAndLoadBgGfxUsingHeap(1, gUnknown_8E97DFC, 0, 0, 0);
         CopyToBgTilemapBuffer(1, gUnknown_8E97EC4, 0, 0);
diff --git a/src/librfu_intr.c b/src/librfu_intr.c
new file mode 100644
index 000000000..23962a937
--- /dev/null
+++ b/src/librfu_intr.c
@@ -0,0 +1,402 @@
+#include "global.h"
+#include "librfu.h"
+
+static void sio32intr_clock_master(void);
+static void sio32intr_clock_slave(void);
+static u16 handshake_wait(u16 slot);
+static void STWI_set_timer_in_RAM(u8 count);
+static void STWI_stop_timer_in_RAM(void);
+static void STWI_init_slave(void);
+static void Callback_Dummy_M(int reqCommandId, int error, void (*callbackM)());
+static void Callback_Dummy_S(u16 reqCommandId, void (*callbackS)(u16));
+static void Callback_Dummy_ID(void (*callbackId)(void));
+
+void IntrSIO32(void)
+{
+    if (gSTWIStatus->state == 10)
+    {
+        if (gSTWIStatus->callbackID != NULL)
+            Callback_Dummy_ID(gSTWIStatus->callbackID);
+    }
+    else
+    {
+        if (gSTWIStatus->msMode == AGB_CLK_MASTER)
+            sio32intr_clock_master();
+        else
+            sio32intr_clock_slave();
+    }
+}
+
+static void sio32intr_clock_master(void)
+{
+    u32 regSIODATA32;
+    u32 ackLen;
+
+    STWI_set_timer_in_RAM(80);
+    regSIODATA32 = REG_SIODATA32;
+
+    if (gSTWIStatus->state == 0) // master send req
+    {
+        if (regSIODATA32 == 0x80000000)
+        {
+            if (gSTWIStatus->reqNext <= gSTWIStatus->reqLength)
+            {
+                REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket->rfuPacket8.data)[gSTWIStatus->reqNext];
+                gSTWIStatus->reqNext++;
+            }
+            else
+            {
+                gSTWIStatus->state = 1; // master wait ack
+                REG_SIODATA32 = 0x80000000;
+            }
+        }
+        else
+        {
+            STWI_stop_timer_in_RAM();
+            STWI_set_timer_in_RAM(130);
+            return;
+        }
+    }
+    else if (gSTWIStatus->state == 1) // master wait ack
+    {
+        if ((regSIODATA32 & 0xFFFF0000) == 0x99660000)
+        {
+            gSTWIStatus->ackNext = 0;
+            ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->ackNext] = regSIODATA32;
+            gSTWIStatus->ackNext++;
+            gSTWIStatus->ackActiveCommand = regSIODATA32;
+            gSTWIStatus->ackLength = ackLen = regSIODATA32 >> 8;
+            if ((ackLen = gSTWIStatus->ackLength) >= gSTWIStatus->ackNext)
+            {
+                gSTWIStatus->state = 2; // master receive ack
+                REG_SIODATA32 = 0x80000000;
+            }
+            else
+            {
+                gSTWIStatus->state = 3; // master done ack
+            }
+        }
+        else
+        {
+            STWI_stop_timer_in_RAM();
+            STWI_set_timer_in_RAM(130);
+            return;
+        }
+    }
+    else if (gSTWIStatus->state == 2) // master receive ack
+    {
+        ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->ackNext] = regSIODATA32;
+        gSTWIStatus->ackNext++;
+        if (gSTWIStatus->ackLength < gSTWIStatus->ackNext)
+            gSTWIStatus->state = 3; // master done ack
+        else
+            REG_SIODATA32 = 0x80000000;
+    }
+
+    if (handshake_wait(1) == 1)
+        return;
+
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS | SIO_MULTI_SD;
+
+    if (handshake_wait(0) == 1)
+        return;
+
+    STWI_stop_timer_in_RAM();
+
+    if (gSTWIStatus->state == 3) // master done ack
+    {
+        if (
+            gSTWIStatus->ackActiveCommand == (0x80 | ID_MS_CHANGE_REQ)
+         || gSTWIStatus->ackActiveCommand == (0x80 | ID_DATA_TX_AND_CHANGE_REQ)
+         || gSTWIStatus->ackActiveCommand == (0x80 | ID_UNK35_REQ)
+         || gSTWIStatus->ackActiveCommand == (0x80 | ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)
+        )
+        {
+
+            gSTWIStatus->msMode = AGB_CLK_SLAVE;
+            REG_SIODATA32 = 0x80000000;
+            REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS;
+            REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE;
+            gSTWIStatus->state = 5; // slave receive req init
+        }
+        else
+        {
+            if (gSTWIStatus->ackActiveCommand == 0xEE)
+            {
+                REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+                gSTWIStatus->state = 4; // error
+                gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION;
+            }
+            else
+            {
+                REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+                gSTWIStatus->state = 4; // error
+            }
+        }
+        gSTWIStatus->sending = 0;
+        if (gSTWIStatus->callbackM != NULL)
+            Callback_Dummy_M(gSTWIStatus->reqActiveCommand, gSTWIStatus->error, gSTWIStatus->callbackM);
+    }
+    else
+    {
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS | SIO_ENABLE;
+    }
+}
+
+static void sio32intr_clock_slave(void)
+{
+    u32 regSIODATA32;
+    u32 r0;
+    register u32 reqLen asm("r2");
+
+    gSTWIStatus->timerActive = 0;
+    STWI_set_timer_in_RAM(100);
+    if (handshake_wait(0) == 1)
+        return;
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_MULTI_SD;
+    regSIODATA32 = REG_SIODATA32;
+    if (gSTWIStatus->state == 5) // slave receive req init
+    {
+        ((u32*)gSTWIStatus->rxPacket)[0] = regSIODATA32;
+        gSTWIStatus->reqNext = 1;
+        r0 = 0x99660000;
+        if ((regSIODATA32 >> 16) == (r0 >> 16))
+        {
+            gSTWIStatus->reqLength = reqLen = regSIODATA32 >> 8;
+            gSTWIStatus->reqActiveCommand = regSIODATA32;
+            if (gSTWIStatus->reqLength == 0)
+            {
+                if (
+                    gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ
+                 || gSTWIStatus->reqActiveCommand == ID_DATA_READY_AND_CHANGE_REQ
+                 || gSTWIStatus->reqActiveCommand == ID_DISCONNECTED_AND_CHANGE_REQ
+                 || gSTWIStatus->reqActiveCommand == ID_UNK36_REQ
+                )
+                {
+                    gSTWIStatus->ackActiveCommand = gSTWIStatus->reqActiveCommand + 0x80;
+                    ((u32*)gSTWIStatus->txPacket)[0] = 0x99660000 + gSTWIStatus->ackActiveCommand;
+                    gSTWIStatus->ackLength = 0;
+                }
+                else
+                {
+                    ((u32*)gSTWIStatus->txPacket)[0] = 0x996601EE;
+                    if (gSTWIStatus->reqActiveCommand >= 0x10 && gSTWIStatus->reqActiveCommand <= 0x3D)
+                    {
+                        ((u32*)gSTWIStatus->txPacket)[1] = 1;
+                    }
+                    else
+                    {
+                        ((u32*)gSTWIStatus->txPacket)[1] = 2;
+                    }
+                    gSTWIStatus->ackLength = 1;
+                    gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION;
+                }
+                REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[0];
+                gSTWIStatus->ackNext = 1;
+                gSTWIStatus->state = 7; // slave send ack
+            }
+            else
+            {
+                REG_SIODATA32 = 0x80000000;
+                gSTWIStatus->reqNext = 1;
+                gSTWIStatus->state = 6; // slave receive req
+            }
+        }
+        else
+        {
+            STWI_stop_timer_in_RAM();
+            STWI_set_timer_in_RAM(100);
+            return;
+        }
+    }
+    else if (gSTWIStatus->state == 6) // slave receive req
+    {
+        ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->reqNext] = regSIODATA32;
+        gSTWIStatus->reqNext++;
+        if (gSTWIStatus->reqLength < gSTWIStatus->reqNext)
+        {
+            if (
+                gSTWIStatus->reqActiveCommand == ID_DATA_READY_AND_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_DISCONNECTED_AND_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_UNK36_REQ
+            )
+            {
+                gSTWIStatus->ackActiveCommand = gSTWIStatus->reqActiveCommand + 0x80;
+                ((u32*)gSTWIStatus->txPacket)[0] = 0x99660000 | gSTWIStatus->ackActiveCommand;
+                gSTWIStatus->ackLength = 0;
+            }
+            else
+            {
+                ((u32*)gSTWIStatus->txPacket)[0] = 0x996601EE;
+                if (gSTWIStatus->reqActiveCommand >= 0x10 && gSTWIStatus->reqActiveCommand <= 0x3D)
+                {
+                    ((u32*)gSTWIStatus->txPacket)[1] = 1;
+                }
+                else
+                {
+                    ((u32*)gSTWIStatus->txPacket)[1] = 2;
+                }
+                gSTWIStatus->ackLength = 1;
+                gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION;
+            }
+            REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[0];
+            gSTWIStatus->ackNext = 1;
+            gSTWIStatus->state = 7; // slave send ack
+        }
+        else
+        {
+            REG_SIODATA32 = 0x80000000;
+        }
+    }
+    else if (gSTWIStatus->state == 7) // slave send ack
+    {
+        if (regSIODATA32 == 0x80000000)
+        {
+            if (gSTWIStatus->ackLength < gSTWIStatus->ackNext)
+            {
+                gSTWIStatus->state = 8; // slave done ack
+            }
+            else
+            {
+                REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[gSTWIStatus->ackNext];
+                gSTWIStatus->ackNext++;
+            }
+        }
+        else
+        {
+            STWI_stop_timer_in_RAM();
+            STWI_set_timer_in_RAM(100);
+            return;
+        }
+    }
+    if (handshake_wait(1) == 1)
+        return;
+    if (gSTWIStatus->state == 8) // slave done ack
+    {
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS;
+        STWI_stop_timer_in_RAM();
+        if (gSTWIStatus->error == ERR_REQ_CMD_ACK_REJECTION)
+        {
+            STWI_init_slave();
+            if (gSTWIStatus->callbackS != NULL)
+            {
+                Callback_Dummy_S(0x1EE, gSTWIStatus->callbackS);
+            }
+        }
+        else
+        {
+            REG_SIODATA32 = 0;
+            REG_SIOCNT = 0;
+            REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+            gSTWIStatus->msMode = AGB_CLK_MASTER;
+            gSTWIStatus->state = 0; // master send req
+            if (gSTWIStatus->callbackS != NULL)
+            {
+                Callback_Dummy_S((gSTWIStatus->reqLength << 8) | (gSTWIStatus->reqActiveCommand), gSTWIStatus->callbackS);
+            }
+        }
+    }
+    else
+    {
+        REG_IME = 0;
+        if (REG_TM0CNT_H & TIMER_ENABLE)
+        {
+            if ((REG_TM0CNT_H & 0x03) == TIMER_1CLK)
+            {
+                while (REG_TM0CNT_L > 0xFF9B);
+            }
+            else
+            {
+                while (REG_TM0CNT_L > 0xFFFE);
+            }
+        }
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS;
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE;
+        REG_IME = 1;
+    }
+}
+
+static u16 handshake_wait(u16 slot)
+{
+    do
+    {
+        if ((gSTWIStatus->timerActive & 0xFF) == 1)
+        {
+            gSTWIStatus->timerActive = 0;
+            return 1;
+        }
+    } while ((REG_SIOCNT & SIO_MULTI_SI) != (slot << SIO_MULTI_SI_SHIFT));
+    return 0;
+}
+
+static void STWI_set_timer_in_RAM(u8 count)
+{
+    vu16* regTMCNTL = (vu16*)(REG_ADDR_TMCNT_L + gSTWIStatus->timerSelect * 4);
+    vu16* regTMCNTH = (vu16*)(REG_ADDR_TMCNT_H + gSTWIStatus->timerSelect * 4);
+    REG_IME = 0;
+    switch (count)
+    {
+    case 50:
+        *regTMCNTL = 0xFCCB;
+        gSTWIStatus->timerState = 1;
+        break;
+    case 80:
+        *regTMCNTL = 0xFAE0;
+        gSTWIStatus->timerState = 2;
+        break;
+    case 100:
+        *regTMCNTL = 0xF996;
+        gSTWIStatus->timerState = 3;
+        break;
+    case 130:
+        *regTMCNTL = 0xF7AD;
+        gSTWIStatus->timerState = 4;
+        break;
+    }
+    *regTMCNTH = TIMER_ENABLE | TIMER_64CLK | TIMER_256CLK | TIMER_INTR_ENABLE;
+    REG_IF = INTR_FLAG_TIMER0 << gSTWIStatus->timerSelect;
+    REG_IME = 1;
+}
+
+static void STWI_stop_timer_in_RAM(void)
+{
+    gSTWIStatus->timerState = 0;
+    REG_TMCNT_L(gSTWIStatus->timerSelect) = 0;
+    REG_TMCNT_H(gSTWIStatus->timerSelect) = 0;
+}
+
+static void STWI_init_slave(void)
+{
+    gSTWIStatus->state = 5; // slave receive req init
+    gSTWIStatus->msMode = AGB_CLK_SLAVE;
+    gSTWIStatus->reqLength = 0;
+    gSTWIStatus->reqNext = 0;
+    gSTWIStatus->reqActiveCommand = 0;
+    gSTWIStatus->ackLength = 0;
+    gSTWIStatus->ackNext = 0;
+    gSTWIStatus->ackActiveCommand = 0;
+    gSTWIStatus->timerState = 0;
+    gSTWIStatus->timerActive = 0;
+    gSTWIStatus->error = 0;
+    gSTWIStatus->recoveryCount = 0;
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE;
+}
+
+NAKED
+static void Callback_Dummy_M(int reqCommandId, int error, void (*callbackM)())
+{
+    asm("bx r2");
+}
+
+NAKED
+static void Callback_Dummy_S(u16 reqCommandId, void (*callbackS)(u16))
+{
+    asm("bx r1");
+}
+
+NAKED
+static void Callback_Dummy_ID(void (*callbackId)(void))
+{
+    asm("bx r0");
+}
diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c
index dccd342f2..582060f78 100644
--- a/src/librfu_rfu.c
+++ b/src/librfu_rfu.c
@@ -2,54 +2,54 @@
 
 struct LLSFStruct
 {
-    u8 unk00;
-    u8 unk01;
-    u8 unk02;
-    u8 unk03;
-    u8 unk04;
-    u8 unk05;
-    u8 unk06;
-    u8 unk07;
-    u8 unk08;
-    u8 unk09;
-    u8 unk0A;
-    u8 unk0B;
-    u8 unk0C;
-    u16 unk0E;
+    u8 frameSize;
+    u8 recvFirstShift;
+    u8 connSlotFlagShift;
+    u8 slotStateShift;
+    u8 ackShift;
+    u8 phaseShit;
+    u8 nShift;
+    u8 recvFirstMask;
+    u8 connSlotFlagMask;
+    u8 slotStateMask;
+    u8 ackMask;
+    u8 phaseMask;
+    u8 nMask;
+    u16 framesMask;
 };
 
 struct RfuLocalStruct
 {
-    u8 unk00;
-    u8 unk01;
-    u8 unk02;
-    u8 unk03;
-    u8 unk04;
-    u8 unk05;
-    u16 unk06;
+    u8 recvFirst;
+    u8 connSlotFlag;
+    u8 slotState;
+    u8 ack;
+    u8 phase;
+    u8 n;
+    u16 frame;
 };
 
-static void rfu_CB_defaultCallback(u8, u16);
-static void rfu_CB_reset(u8, u16);
-static void rfu_CB_configGameData(u8, u16);
-static void rfu_CB_stopMode(u8, u16);
-static void rfu_CB_startSearchChild(u8, u16);
-static void rfu_CB_pollAndEndSearchChild(u8, u16);
-static void rfu_CB_startSearchParent(u8, u16);
-static void rfu_CB_pollSearchParent(u8, u16);
-static void rfu_CB_pollConnectParent(u8, u16);
-static void rfu_CB_pollConnectParent(u8, u16);
-static void rfu_CB_disconnect(u8, u16);
-static void rfu_CB_CHILD_pollConnectRecovery(u8, u16);
-static void rfu_CB_sendData(UNUSED u8, u16);
-static void rfu_CB_sendData2(UNUSED u8, u16);
-static void rfu_CB_sendData3(u8, u16);
-static void rfu_CB_recvData(u8, u16);
-static void rfu_enableREQCallback(bool8);
+static void rfu_CB_defaultCallback(u8 reqCommand, u16 reqResult);
+static void rfu_CB_reset(u8 reqCommand, u16 reqResult);
+static void rfu_CB_configGameData(u8 reqCommand, u16 reqResult);
+static void rfu_CB_stopMode(u8 reqCommand, u16 reqResult);
+static void rfu_CB_startSearchChild(u8 reqCommand, u16 reqResult);
+static void rfu_CB_pollAndEndSearchChild(u8 reqCommand, u16 reqResult);
+static void rfu_CB_startSearchParent(u8 reqCommand, u16 reqResult);
+static void rfu_CB_pollSearchParent(u8 reqCommand, u16 reqResult);
+static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult);
+static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult);
+static void rfu_CB_disconnect(u8 reqCommand, u16 reqResult);
+static void rfu_CB_CHILD_pollConnectRecovery(u8 reqCommand, u16 reqResult);
+static void rfu_CB_sendData(UNUSED u8 reqCommand, u16 reqResult);
+static void rfu_CB_sendData2(UNUSED u8 reqCommand, u16 reqResult);
+static void rfu_CB_sendData3(u8 reqCommand, u16 reqResult);
+static void rfu_CB_recvData(u8 reqCommand, u16 reqResult);
+static void rfu_enableREQCallback(bool8 enable);
 static void rfu_STC_clearAPIVariables(void);
 static void rfu_STC_readChildList(void);
 static void rfu_STC_readParentCandidateList(void);
-static void rfu_STC_REQ_callback(u8, u16);
+static void rfu_STC_REQ_callback(u8 reqCommand, u16 reqResult);
 static void rfu_STC_removeLinkData(u8, u8);
 static void rfu_STC_fastCopy(const u8 **, u8 **, s32);
 static void rfu_STC_clearLinkStatus(u8);
@@ -74,63 +74,94 @@ struct RfuStatic *gRfuStatic;
 struct RfuFixed *gRfuFixed;
 
 static const struct LLSFStruct llsf_struct[2] = {
-  {
-    2, 14, 0, 10, 9, 5, 7, 2,
-    0, 15, 1, 3, 3, 0x1f
-  }, {
-    3, 22, 18, 14, 13, 9, 11, 3,
-    15, 15, 1, 3, 3, 0x7f
-  }
+    [MODE_CHILD] = {
+        .frameSize = 2,
+        .recvFirstShift = 14,
+        .connSlotFlagShift = 0,
+        .slotStateShift = 10,
+        .ackShift = 9,
+        .phaseShit = 5,
+        .nShift = 7,
+        .recvFirstMask = 2,
+        .connSlotFlagMask = 0,
+        .slotStateMask = 15,
+        .ackMask = 1,
+        .phaseMask = 3,
+        .nMask = 3,
+        .framesMask = 0x1f
+    },
+    [MODE_PARENT] = {
+        .frameSize = 3,
+        .recvFirstShift = 22,
+        .connSlotFlagShift = 18,
+        .slotStateShift = 14,
+        .ackShift = 13,
+        .phaseShit = 9,
+        .nShift = 11,
+        .recvFirstMask = 3,
+        .connSlotFlagMask = 15,
+        .slotStateMask = 15,
+        .ackMask = 1,
+        .phaseMask = 3,
+        .nMask = 3,
+        .framesMask = 0x7f
+    }
 };
 
-#ifdef EMERALD
-static const char lib_ver[] = "RFU_V1026";
-#else
-static const char lib_ver[] = "RFU_V1024";
-#endif
+#define xstr(s) str(s)
+#define str(s) #s
+const char version_string[] = "RFU_V" xstr(LIBRFU_VERSION);
 
 static const char str_checkMbootLL[] = "RFU-MBOOT";
 
-u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam)
+#define COPY(src, dst, iterator, size) do {         \
+    const u16 *_src = (const u16 *)(src);           \
+    u16 *_dst = (u16 *)(dst);                       \
+    (iterator) = (size);                            \
+    while ((iterator)-- != 0)                       \
+        *_dst++ = *_src++;                          \
+} while (0)
+
+u16 rfu_initializeAPI(u32 *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam)
 {
     u16 i;
     u16 *dst;
     const u16 *src;
-    u16 r3;
+    u16 buffByteSizeMax;
 
-    // is in EWRAM? 
-    if (((u32)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam)
+    // is in EWRAM?
+    if (((uintptr_t)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam)
         return ERR_RFU_API_BUFF_ADR;
-    // is not 4-byte aligned? 
+    // is not 4-byte aligned?
     if ((u32)APIBuffer & 3)
         return ERR_RFU_API_BUFF_ADR;
     if (copyInterruptToRam)
     {
         // An assert/debug print may have existed before, ie
         // printf("%s %u < %u", "somefile.c:12345", buffByteSize, num)
-        // to push this into r3?
-        r3 = sizeof(struct RfuAPIBuffer);
-        if (buffByteSize < r3)
+        // to push this into buffByteSizeMax?
+        buffByteSizeMax = RFU_API_BUFF_SIZE_RAM;
+        if (buffByteSize < buffByteSizeMax)
             return ERR_RFU_API_BUFF_SIZE;
     }
     if (!copyInterruptToRam)
     {
-        r3 = 0x504; // same issue as above
-        if (buffByteSize < r3)
+        buffByteSizeMax = RFU_API_BUFF_SIZE_ROM; // same issue as above
+        if (buffByteSize < buffByteSizeMax)
             return ERR_RFU_API_BUFF_SIZE;
     }
-    gRfuLinkStatus = &APIBuffer->linkStatus;
-    gRfuStatic = &APIBuffer->static_;
-    gRfuFixed = &APIBuffer->fixed;
-    gRfuSlotStatusNI[0] = &APIBuffer->NI[0];
-    gRfuSlotStatusUNI[0] = &APIBuffer->UNI[0];
+    gRfuLinkStatus = (void *)APIBuffer + 0;
+    gRfuStatic = (void *)APIBuffer + 0xb4; // + sizeof(*gRfuLinkStatus)
+    gRfuFixed = (void *)APIBuffer + 0xdc; // + sizeof(*gRfuStatic)
+    gRfuSlotStatusNI[0] = (void *)APIBuffer + 0x1bc; // + sizeof(*gRfuFixed)
+    gRfuSlotStatusUNI[0] = (void *)APIBuffer + 0x37c; // + sizeof(*gRfuSlotStatusNI[0])
     for (i = 1; i < RFU_CHILD_MAX; ++i)
     {
         gRfuSlotStatusNI[i] = &gRfuSlotStatusNI[i - 1][1];
         gRfuSlotStatusUNI[i] = &gRfuSlotStatusUNI[i - 1][1];
     }
-    // TODO: Is it possible to fix the following 2 statements? 
-    // It's equivalent to: 
+    // TODO: Is it possible to fix the following 2 statements?
+    // It's equivalent to:
     // gRfuFixed->STWIBuffer = &APIBuffer->intr;
     // STWI_init_all(&APIBuffer->intr, sioIntrTable_p, copyInterruptToRam);
     gRfuFixed->STWIBuffer = (struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1];
@@ -143,11 +174,21 @@ u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc
         gRfuSlotStatusUNI[i]->recvBuffer = NULL;
         gRfuSlotStatusUNI[i]->recvBufferSize = 0;
     }
-    src = (const u16 *)((u32)&rfu_STC_fastCopy & ~1);
-    dst = gRfuFixed->fastCopyBuffer;
     // rfu_REQ_changeMasterSlave is the function next to rfu_STC_fastCopy
-    for (r3 = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16), --r3; r3 != 0xFFFF; --r3)
+#if LIBRFU_VERSION < 1026
+    src = (const u16 *)((uintptr_t)&rfu_STC_fastCopy & ~1);
+    dst = gRfuFixed->fastCopyBuffer;
+    buffByteSizeMax = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16);
+    while (buffByteSizeMax-- != 0)
         *dst++ = *src++;
+#else
+    COPY(
+        (uintptr_t)&rfu_STC_fastCopy & ~1,
+        gRfuFixed->fastCopyBuffer,
+        buffByteSizeMax,
+        0x60 / sizeof(u16)
+        );
+#endif
     gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1;
     return 0;
 }
@@ -155,19 +196,19 @@ u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc
 static void rfu_STC_clearAPIVariables(void)
 {
     u16 IMEBackup = REG_IME;
-    u8 i, r4;
+    u8 i, flags;
 
     REG_IME = 0;
-    r4 = gRfuStatic->flags;
+    flags = gRfuStatic->flags;
     CpuFill16(0, gRfuStatic, sizeof(struct RfuStatic));
-    gRfuStatic->flags = r4 & 8;
+    gRfuStatic->flags = flags & 8;
     CpuFill16(0, gRfuLinkStatus, sizeof(struct RfuLinkStatus));
     gRfuLinkStatus->watchInterval = 4;
     gRfuStatic->nowWatchInterval = 0;
     gRfuLinkStatus->parentChild = MODE_NEUTRAL;
     rfu_clearAllSlot();
     gRfuStatic->SCStartFlag = 0;
-    for (i = 0; i < NELEMS(gRfuStatic->cidBak); ++i)
+    for (i = 0; i < RFU_CHILD_MAX; ++i)
         gRfuStatic->cidBak[i] = 0;
     REG_IME = IMEBackup;
 }
@@ -180,20 +221,20 @@ void rfu_REQ_PARENT_resumeRetransmitAndChange(void)
 
 u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag)
 {
-    struct RfuIntrStruct *buf;
+    u8 *buf;
 
     *ackFlag = 0;
     if (gRfuLinkStatus->parentChild != MODE_PARENT)
         return ERR_MODE_NOT_PARENT;
     buf = rfu_getSTWIRecvBuffer();
-    switch (buf->rxPacketAlloc.rfuPacket8.data[0])
+    switch (*buf)
     {
     case 40:
     case 54:
-        if (buf->rxPacketAlloc.rfuPacket8.data[1] == 0)
+        if (buf[1] == 0)
             *ackFlag = gRfuLinkStatus->connSlotFlag;
         else
-            *ackFlag = buf->rxPacketAlloc.rfuPacket8.data[4];
+            *ackFlag = buf[4];
         return 0;
     default:
         return ERR_REQ_CMD_ID;
@@ -205,9 +246,9 @@ void rfu_setTimerInterrupt(u8 timerNo, IntrFunc *timerIntrTable_p)
     STWI_init_timer(timerIntrTable_p, timerNo);
 }
 
-struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void)
+u8 *rfu_getSTWIRecvBuffer(void)
 {
-    return gRfuFixed->STWIBuffer;
+    return (u8 *)gRfuFixed->STWIBuffer;
 }
 
 void rfu_setMSCCallback(void (*callback)(u16 reqCommandId))
@@ -229,26 +270,26 @@ static void rfu_enableREQCallback(bool8 enable)
         gRfuStatic->flags &= 0xF7;
 }
 
-static void rfu_STC_REQ_callback(u8 r5, u16 reqResult)
+static void rfu_STC_REQ_callback(u8 reqCommand, u16 reqResult)
 {
     STWI_set_Callback_M(rfu_CB_defaultCallback);
     gRfuStatic->reqResult = reqResult;
     if (gRfuStatic->flags & 8)
-        gRfuFixed->reqCallback(r5, reqResult);
+        gRfuFixed->reqCallback(reqCommand, reqResult);
 }
 
-static void rfu_CB_defaultCallback(u8 r0, u16 reqResult)
+static void rfu_CB_defaultCallback(u8 reqCommand, u16 reqResult)
 {
-    s32 r5;
+    s32 bmSlotFlags;
     u8 i;
 
-    if (r0 == 0xFF)
+    if (reqCommand == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ)
     {
         if (gRfuStatic->flags & 8)
-            gRfuFixed->reqCallback(r0, reqResult);
-        r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+            gRfuFixed->reqCallback(reqCommand, reqResult);
+        bmSlotFlags = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
         for (i = 0; i < RFU_CHILD_MAX; ++i)
-            if ((r5 >> i) & 1)
+            if ((bmSlotFlags >> i) & 1)
                 rfu_STC_removeLinkData(i, 1);
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
     }
@@ -277,25 +318,39 @@ u16 rfu_getRFUStatus(u8 *rfuState)
     return 0;
 }
 
+/*
+ * RFU Multiboot images are loaded into IWRAM
+ * struct RfuMbootLL
+ * {
+ *   struct RfuLinkStatus status;
+ *   u8 filler_B4[0x3C];
+ *   char name[10];
+ *   u16 checksum;
+ * }
+ * Returns 1 if the packet to inherit is malformed.
+ */
 u16 rfu_MBOOT_CHILD_inheritanceLinkStatus(void)
 {
     const char *s1 = str_checkMbootLL;
     char *s2 = (char *)0x30000F0;
     u16 checksum;
-    u16 *r2;
+    u16 *mb_buff_iwram_p;
     u8 i;
 
+    // if (strcmp(s1, s2) != 0) return 1;
     while (*s1 != '\0')
         if (*s1++ != *s2++)
             return 1;
-    r2 = (u16 *)0x3000000;
+    mb_buff_iwram_p = (u16 *)0x3000000;
+
+    // The size of struct RfuLinkStatus is 180
     checksum = 0;
-    for (i = 0; i < 90; ++i)
-        checksum += *r2++;
+    for (i = 0; i < 180/2; ++i)
+        checksum += *mb_buff_iwram_p++;
     if (checksum != *(u16 *)0x30000FA)
         return 1;
     CpuCopy16((u16 *)0x3000000, gRfuLinkStatus, sizeof(struct RfuLinkStatus));
-    gRfuStatic->flags |= 0x80;
+    gRfuStatic->flags |= 0x80; // mboot
     return 0;
 }
 
@@ -305,14 +360,14 @@ void rfu_REQ_stopMode(void)
 
     if (REG_IME == 0)
     {
-        rfu_STC_REQ_callback(61, 6);
+        rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 6);
         gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE;
     }
     else
     {
         AgbRFU_SoftReset();
         rfu_STC_clearAPIVariables();
-        if (AgbRFU_checkID(8) == 0x8001)
+        if (AgbRFU_checkID(8) == RFU_ID)
         {
             timerReg = &REG_TMCNT(gSTWIStatus->timerSelect);
             *timerReg = 0;
@@ -326,29 +381,29 @@ void rfu_REQ_stopMode(void)
         else
         {
             REG_SIOCNT = SIO_MULTI_MODE;
-            rfu_STC_REQ_callback(61, 0);
+            rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 0);
         }
     }
 }
 
-static void rfu_CB_stopMode(u8 a1, u16 reqResult)
+static void rfu_CB_stopMode(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         REG_SIOCNT = SIO_MULTI_MODE;
-    rfu_STC_REQ_callback(a1, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u32 rfu_REQBN_softReset_and_checkID(void)
 {
-    u32 r2;
+    u32 id;
 
     if (REG_IME == 0)
         return ERR_ID_CHECK_IME_DISABLE;
     AgbRFU_SoftReset();
     rfu_STC_clearAPIVariables();
-    if ((r2 = AgbRFU_checkID(30)) == 0)
+    if ((id = AgbRFU_checkID(30)) == 0)
         REG_SIOCNT = SIO_MULTI_MODE;
-    return r2;
+    return id;
 }
 
 void rfu_REQ_reset(void)
@@ -357,11 +412,11 @@ void rfu_REQ_reset(void)
     STWI_send_ResetREQ();
 }
 
-static void rfu_CB_reset(u8 a1, u16 reqResult)
+static void rfu_CB_reset(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_clearAPIVariables();
-    rfu_STC_REQ_callback(a1, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
@@ -370,59 +425,59 @@ void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
     STWI_send_SystemConfigREQ((availSlotFlag & AVAIL_SLOT1) | 0x3C, maxMFrame, mcTimer);
     if (mcTimer == 0)
     {
-        gRfuStatic->unk_1a = 1;
+        gRfuStatic->linkEmergencyLimit = 1;
     }
     else
     {
         u16 IMEBackup = REG_IME;
 
         REG_IME = 0;
-        gRfuStatic->unk_1a = Div(600, mcTimer);
+        gRfuStatic->linkEmergencyLimit = Div(600, mcTimer);
         REG_IME = IMEBackup;
     }
 }
 
 void rfu_REQ_configGameData(u8 mbootFlag, u16 serialNo, const u8 *gname, const u8 *uname)
 {
-    u8 sp[16];
+    u8 packet[16];
     u8 i;
-    u8 r3;
+    u8 check_sum;
     const u8 *gnameBackup = gname;
     const u8 *unameBackup;
 
-    sp[0] = serialNo;
-    sp[1] = serialNo >> 8;
+    packet[0] = serialNo;
+    packet[1] = serialNo >> 8;
     if (mbootFlag != 0)
-        sp[1] = (serialNo >> 8) | 0x80;
+        packet[1] = (serialNo >> 8) | 0x80;
     for (i = 2; i < 15; ++i)
-        sp[i] = *gname++;
-    r3 = 0;
+        packet[i] = *gname++;
+    check_sum = 0;
     unameBackup = uname;
     for (i = 0; i < 8; ++i)
     {
-        r3 += *unameBackup++;
-        r3 += *gnameBackup++;
+        check_sum += *unameBackup++;
+        check_sum += *gnameBackup++;
     }
-    sp[15] = ~r3;
+    packet[15] = ~check_sum;
     if (mbootFlag != 0)
-        sp[14] = 0;
+        packet[14] = 0;
     STWI_set_Callback_M(rfu_CB_configGameData);
-    STWI_send_GameConfigREQ(sp, uname);
+    STWI_send_GameConfigREQ(packet, uname);
 }
 
-static void rfu_CB_configGameData(u8 ip, u16 r7)
+static void rfu_CB_configGameData(u8 reqCommand, u16 reqResult)
 {
-    s32 r2, r3;
-    u8 *r4;
+    s32 serialNo;
+    u8 *gname_uname_p;
     u8 i;
-    u8 *r1;
+    u8 *packet_p;
 
-    if (r7 == 0)
+    if (reqResult == 0)
     {
-        r1 = gSTWIStatus->txPacket->rfuPacket8.data;
-        r2 = gRfuLinkStatus->my.serialNo = r1[4];
-        gRfuLinkStatus->my.serialNo = (r1[5] << 8) | r2;
-        r4 = &r1[6];
+        packet_p = gSTWIStatus->txPacket->rfuPacket8.data;
+        serialNo = gRfuLinkStatus->my.serialNo = packet_p[4];
+        gRfuLinkStatus->my.serialNo = (packet_p[5] << 8) | serialNo;
+        gname_uname_p = &packet_p[6];
         if (gRfuLinkStatus->my.serialNo & 0x8000)
         {
             gRfuLinkStatus->my.serialNo = gRfuLinkStatus->my.serialNo ^ 0x8000;
@@ -433,47 +488,54 @@ static void rfu_CB_configGameData(u8 ip, u16 r7)
             gRfuLinkStatus->my.mbootFlag = 0;
         }
         for (i = 0; i < RFU_GAME_NAME_LENGTH; ++i)
-            gRfuLinkStatus->my.gname[i] = *r4++;
-        ++r4;
+            gRfuLinkStatus->my.gname[i] = *gname_uname_p++;
+        ++gname_uname_p;
         for (i = 0; i < RFU_USER_NAME_LENGTH; ++i)
-            gRfuLinkStatus->my.uname[i] = *r4++;
+            gRfuLinkStatus->my.uname[i] = *gname_uname_p++;
     }
-    rfu_STC_REQ_callback(ip, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_startSearchChild(void)
 {
-    u16 r1;
-    
+    u16 result;
+#if LIBRFU_VERSION >= 1026
+    u16 i;
+    for (i = 0; i < RFU_CHILD_MAX; i++)
+    {
+        gRfuStatic->lsFixedCount[i] = 0;
+    }
+#endif
+
     STWI_set_Callback_M(rfu_CB_defaultCallback);
     STWI_send_SystemStatusREQ();
-    r1 = STWI_poll_CommandEnd();
-    if (r1 == 0)
+    result = STWI_poll_CommandEnd();
+    if (result == 0)
     {
         if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
-            rfu_STC_clearLinkStatus(1);
+            rfu_STC_clearLinkStatus(MODE_PARENT);
     }
     else
     {
-        rfu_STC_REQ_callback(25, r1);
+        rfu_STC_REQ_callback(ID_SC_START_REQ, result);
     }
     STWI_set_Callback_M(rfu_CB_startSearchChild);
     STWI_send_SC_StartREQ();
 }
 
-static void rfu_CB_startSearchChild(u8 r3, u16 reqResult)
+static void rfu_CB_startSearchChild(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         gRfuStatic->SCStartFlag = 1;
-    rfu_STC_REQ_callback(r3, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
-static void rfu_STC_clearLinkStatus(u8 r4)
+static void rfu_STC_clearLinkStatus(u8 parentChild)
 {
     u8 i;
-    
+
     rfu_clearAllSlot();
-    if (r4 != 0)
+    if (parentChild != MODE_CHILD)
     {
         CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner));
         gRfuLinkStatus->findParentCount = 0;
@@ -498,11 +560,11 @@ void rfu_REQ_endSearchChild(void)
     STWI_send_SC_EndREQ();
 }
 
-static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult)
+static void rfu_CB_pollAndEndSearchChild(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_readChildList();
-    if (r4 == 26)
+    if (reqCommand == ID_SC_POLL_REQ)
     {
         if (gRfuLinkStatus->my.id == 0)
         {
@@ -512,60 +574,76 @@ static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult)
                 gRfuLinkStatus->my.id = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
         }
     }
-    else if (r4 == 27)
+    else if (reqCommand == ID_SC_END_REQ)
     {
         if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
             gRfuLinkStatus->my.id = 0;
         gRfuStatic->SCStartFlag = 0;
     }
-    rfu_STC_REQ_callback(r4, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 static void rfu_STC_readChildList(void)
 {
-    u32 r5;
-    u8 r8 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1];
-    u8 *r4;
+    u32 stwiParam;
+    u8 numSlots = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1];
+    u8 *data_p;
     u8 i;
-    u8 sp[4];
-    u8 r2;
+    u8 bm_slot_id;
+#if LIBRFU_VERSION < 1026
+    u8 true_slots[RFU_CHILD_MAX];
+#endif
 
-    if (r8 != 0)
+#if LIBRFU_VERSION < 1026
+    if (numSlots != 0)
     {
-        r5 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
+        stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
         STWI_set_Callback_M(rfu_CB_defaultCallback);
         STWI_send_LinkStatusREQ();
         if (STWI_poll_CommandEnd() == 0)
         {
-            r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
-            for (i = 0; i < NELEMS(sp); ++i)
-                sp[i] = *r4++;
+            data_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
+            for (i = 0; i < RFU_CHILD_MAX; ++i)
+                true_slots[i] = *data_p++;
         }
-        gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = r5;
+        gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = stwiParam;
     }
-    for (r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
-         r8 != 0;
-         r4 += 4)
+#endif
+    for (data_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
+         numSlots != 0;
+         data_p += 4)
     {
-        r2 = r4[2];
-        if (r2 < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1))
+        bm_slot_id = data_p[2];
+        if (bm_slot_id < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> bm_slot_id) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> bm_slot_id) & 1))
         {
-            if (sp[r2] != 0)
-                ++gRfuStatic->lsFixedCount[r2];
-            if (gRfuStatic->lsFixedCount[r2] >= 4)
+        #if LIBRFU_VERSION < 1026
+            if (true_slots[bm_slot_id] != 0)
+                ++gRfuStatic->lsFixedCount[bm_slot_id];
+            if (gRfuStatic->lsFixedCount[bm_slot_id] >= 4)
             {
-                gRfuStatic->lsFixedCount[r2] = 0;
-                gRfuLinkStatus->strength[r2] = 0xFF;
-                gRfuLinkStatus->connSlotFlag |= 1 << r2;
+                gRfuStatic->lsFixedCount[bm_slot_id] = 0;
+                gRfuLinkStatus->strength[bm_slot_id] = 255;
+                gRfuLinkStatus->connSlotFlag |= 1 << bm_slot_id;
                 ++gRfuLinkStatus->connCount;
-                gRfuLinkStatus->partner[r2].id = *(u16 *)r4;
-                gRfuLinkStatus->partner[r2].slot = r2;
+                gRfuLinkStatus->partner[bm_slot_id].id = *(u16 *)data_p;
+                gRfuLinkStatus->partner[bm_slot_id].slot = bm_slot_id;
                 gRfuLinkStatus->parentChild = MODE_PARENT;
                 gRfuStatic->flags &= 0x7F;
-                gRfuStatic->cidBak[r2] = gRfuLinkStatus->partner[r2].id;
+                gRfuStatic->cidBak[bm_slot_id] = gRfuLinkStatus->partner[bm_slot_id].id;
             }
+        #else
+            gRfuStatic->lsFixedCount[bm_slot_id] = 0xF0;
+            gRfuLinkStatus->strength[bm_slot_id] = 16;
+            gRfuLinkStatus->connSlotFlag |= 1 << bm_slot_id;
+            ++gRfuLinkStatus->connCount;
+            gRfuLinkStatus->partner[bm_slot_id].id = *(u16 *)data_p;
+            gRfuLinkStatus->partner[bm_slot_id].slot = bm_slot_id;
+            gRfuLinkStatus->parentChild = MODE_PARENT;
+            gRfuStatic->flags &= 0x7F;
+            gRfuStatic->cidBak[bm_slot_id] = gRfuLinkStatus->partner[bm_slot_id].id;
+        #endif
         }
-        --r8;
+        --numSlots;
     }
 }
 
@@ -575,11 +653,11 @@ void rfu_REQ_startSearchParent(void)
     STWI_send_SP_StartREQ();
 }
 
-static void rfu_CB_startSearchParent(u8 r5, u16 reqResult)
+static void rfu_CB_startSearchParent(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
-        rfu_STC_clearLinkStatus(0);
-    rfu_STC_REQ_callback(r5, reqResult);
+        rfu_STC_clearLinkStatus(MODE_CHILD);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_pollSearchParent(void)
@@ -588,11 +666,11 @@ void rfu_REQ_pollSearchParent(void)
     STWI_send_SP_PollingREQ();
 }
 
-static void rfu_CB_pollSearchParent(u8 r5, u16 reqResult)
+static void rfu_CB_pollSearchParent(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_readParentCandidateList();
-    rfu_STC_REQ_callback(r5, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_endSearchParent(void)
@@ -603,47 +681,47 @@ void rfu_REQ_endSearchParent(void)
 
 static void rfu_STC_readParentCandidateList(void)
 {
-    u8 r7, r6, r5, r4, r3;
-    u8 *r1, *r2;
-    struct RfuTgtData *r4_;
+    u8 numSlots, i, check_sum, my_check_sum, j;
+    u8 *uname_p, *packet_p;
+    struct RfuTgtData *target;
 
     CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner));
-    r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0];
-    r7 = r2[1];
-    r2 += 4;
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0];
+    numSlots = packet_p[1];
+    packet_p += 4;
     gRfuLinkStatus->findParentCount = 0;
-    for (r6 = 0; r6 < 4 && r7 != 0; ++r6)
-    {
-        r7 -= 7;
-        r1 = r2 + 6;
-        r2 += 19;
-        r5 = ~*r2;
-        ++r2;
-        r4 = 0;
-        for (r3 = 0; r3 < 8; ++r3)
+    for (i = 0; i < RFU_CHILD_MAX && numSlots != 0; ++i)
+    {
+        numSlots -= 7;
+        uname_p = packet_p + 6;
+        packet_p += 19;
+        check_sum = ~*packet_p;
+        ++packet_p;
+        my_check_sum = 0;
+        for (j = 0; j < 8; ++j)
         {
-            r4 += *r2++;
-            r4 += *r1++;
+            my_check_sum += *packet_p++;
+            my_check_sum += *uname_p++;
         }
-        if (r4 == r5)
+        if (my_check_sum == check_sum)
         {
-            r2 -= 28;
-            r4_ = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount];
-            r4_->id = *(u16 *)r2;
-            r2 += 2;
-            r4_->slot = *r2;
-            r2 += 2;
-            r4_->serialNo = *(u16 *)r2 & 0x7FFF;
-            if (*(u16 *)r2 & 0x8000)
-                r4_->mbootFlag = 1;
+            packet_p -= 28;
+            target = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount];
+            target->id = *(u16 *)packet_p;
+            packet_p += 2;
+            target->slot = *packet_p;
+            packet_p += 2;
+            target->serialNo = *(u16 *)packet_p & 0x7FFF;
+            if (*(u16 *)packet_p & 0x8000)
+                target->mbootFlag = 1;
             else
-                r4_->mbootFlag = 0;
-            r2 += 2;
-            for (r3 = 0; r3 < RFU_GAME_NAME_LENGTH; ++r3)
-                r4_->gname[r3] = *r2++;
-            ++r2;
-            for (r3 = 0; r3 < RFU_USER_NAME_LENGTH; ++r3)
-                r4_->uname[r3] = *r2++;
+                target->mbootFlag = 0;
+            packet_p += 2;
+            for (j = 0; j < RFU_GAME_NAME_LENGTH; ++j)
+                target->gname[j] = *packet_p++;
+            ++packet_p;
+            for (j = 0; j < RFU_USER_NAME_LENGTH; ++j)
+                target->uname[j] = *packet_p++;
             ++gRfuLinkStatus->findParentCount;
         }
     }
@@ -651,13 +729,13 @@ static void rfu_STC_readParentCandidateList(void)
 
 void rfu_REQ_startConnectParent(u16 pid)
 {
-    u16 r3 = 0;
+    u16 result = 0;
     u8 i;
     for (i = 0; i < RFU_CHILD_MAX && gRfuLinkStatus->partner[i].id != pid; ++i)
         ;
-    if (i == 4)
-        r3 = 256;
-    if (r3 == 0)
+    if (i == RFU_CHILD_MAX)
+        result = ERR_PID_NOT_FOUND;
+    if (result == 0)
     {
         gRfuStatic->tryPid = pid;
         STWI_set_Callback_M(rfu_STC_REQ_callback);
@@ -665,7 +743,7 @@ void rfu_REQ_startConnectParent(u16 pid)
     }
     else
     {
-        rfu_STC_REQ_callback(31, r3);
+        rfu_STC_REQ_callback(ID_CP_START_REQ, result);
     }
 }
 
@@ -675,70 +753,69 @@ void rfu_REQ_pollConnectParent(void)
     STWI_send_CP_PollingREQ();
 }
 
-static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28)
+static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult)
 {
     u16 id;
     u8 slot;
-    u8 r2, r5;
-    struct RfuTgtData *r9;
-    struct RfuTgtData sp;
+    u8 bm_slot_flag, i;
+    struct RfuTgtData *target_p;
+    struct RfuTgtData target_local;
 
-    if (sp28 == 0)
+    if (reqResult == 0)
     {
         id = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
         slot = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6];
         if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
         {
-            r2 = 1 << slot;
-            if (!(r2 & gRfuLinkStatus->connSlotFlag))
+            bm_slot_flag = 1 << slot;
+            if (!(bm_slot_flag & gRfuLinkStatus->connSlotFlag))
             {
-                gRfuLinkStatus->connSlotFlag |= r2;
-                gRfuLinkStatus->linkLossSlotFlag &= ~r2;
+                gRfuLinkStatus->connSlotFlag |= bm_slot_flag;
+                gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag;
                 gRfuLinkStatus->my.id = id;
                 ++gRfuLinkStatus->connCount;
                 gRfuLinkStatus->parentChild = MODE_CHILD;
                 gRfuStatic->flags |= 0x80;
-                for (r5 = 0; r5 < RFU_CHILD_MAX; ++r5)
+                for (i = 0; i < RFU_CHILD_MAX; ++i)
                 {
-                    if (gRfuLinkStatus->partner[r5].id == gRfuStatic->tryPid)
+                    if (gRfuLinkStatus->partner[i].id == gRfuStatic->tryPid)
                     {
                         if (gRfuLinkStatus->findParentCount != 0)
                         {
-                            r9 = &sp;
-                            CpuCopy16(&gRfuLinkStatus->partner[r5], &sp, sizeof(struct RfuTgtData));
+                            target_p = &target_local;
+                            CpuCopy16(&gRfuLinkStatus->partner[i], &target_local, sizeof(struct RfuTgtData));
                             CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner));
                             gRfuLinkStatus->findParentCount = 0;
                         }
                         else
                         {
-                            r9 = &gRfuLinkStatus->partner[r5];
+                            target_p = &gRfuLinkStatus->partner[i];
                         }
                         break;
                     }
                 }
-                if (r5 < RFU_CHILD_MAX)
+                if (i < RFU_CHILD_MAX)
                 {
-                    CpuCopy16(r9, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData));
+                    CpuCopy16(target_p, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData));
                     gRfuLinkStatus->partner[slot].slot = slot;
                 }
             }
         }
     }
-    rfu_STC_REQ_callback(sp24, sp28);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u16 rfu_getConnectParentStatus(u8 *status, u8 *connectSlotNo)
 {
-    u8 r0, *r2;
+    u8 *packet_p;
 
     *status = 0xFF;
-    r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-    r0 = r2[0] + 96;
-    if (r0 <= 1)
+    packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+    if (packet_p[0] == 0xa0 || packet_p[0] == 0xa1)
     {
-        r2 += 6;
-        *connectSlotNo = r2[0];
-        *status = r2[1];
+        packet_p += 6;
+        *connectSlotNo = packet_p[0];
+        *status = packet_p[1];
         return 0;
     }
     return ERR_REQ_CMD_ID;
@@ -754,28 +831,28 @@ void rfu_REQ_endConnectParent(void)
 
 u16 rfu_syncVBlank(void)
 {
-    u8 r3, r4;
-    s32 r5;
+    u8 masterSlave, i;
+    s32 bmSlotFlag;
 
     rfu_NI_checkCommFailCounter();
     if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
         return 0;
     if (gRfuStatic->nowWatchInterval != 0)
         --gRfuStatic->nowWatchInterval;
-    r3 = rfu_getMasterSlave();
+    masterSlave = rfu_getMasterSlave();
     if (!(gRfuStatic->flags & 2))
     {
-        if (r3 == 0)
+        if (masterSlave == AGB_CLK_SLAVE)
         {
             gRfuStatic->flags |= 4;
             gRfuStatic->watchdogTimer = 360;
         }
     }
-    else if (r3 != 0)
+    else if (masterSlave != AGB_CLK_SLAVE)
     {
         gRfuStatic->flags &= 0xFB;
     }
-    if (r3 != 0)
+    if (masterSlave != AGB_CLK_SLAVE)
         gRfuStatic->flags &= 0xFD;
     else
         gRfuStatic->flags |= 2;
@@ -784,10 +861,10 @@ u16 rfu_syncVBlank(void)
     if (gRfuStatic->watchdogTimer == 0)
     {
         gRfuStatic->flags &= 0xFB;
-        r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
-        for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
-            if ((r5 >> r4) & 1)
-                rfu_STC_removeLinkData(r4, 1);
+        bmSlotFlag = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
+            if ((bmSlotFlag >> i) & 1)
+                rfu_STC_removeLinkData(i, 1);
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
         return 1;
     }
@@ -797,13 +874,13 @@ u16 rfu_syncVBlank(void)
 
 u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason, u8 *parentBmLinkRecoverySlot)
 {
-    u8 sp08 = 0;
-    u8 sp0C = 0;
+    u8 reasonMaybe = 0;
+    u8 reqResult = 0;
     u8 i;
-    s32 sp10, sp14;
-    u8 *r2;
-    u8 r9, r6, r3, connSlotFlag, r0;
-    
+    s32 stwiCommand, stwiParam;
+    u8 *packet_p;
+    u8 to_req_disconnect, newLinkLossFlag, num_packets, connSlotFlag, to_disconnect;
+
     *bmLinkLossSlot = 0;
     *linkLossReason = REASON_DISCONNECTED;
     *parentBmLinkRecoverySlot = 0;
@@ -813,26 +890,30 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
         gRfuStatic->watchdogTimer = 360;
     if (gRfuStatic->nowWatchInterval == 0)
     {
+    #if LIBRFU_VERSION < 1026
         gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval;
-        sp08 = 1;
+    #else
+        gRfuStatic->nowWatchInterval = 4;
+    #endif
+        reasonMaybe = 1;
     }
-    if ((u8)reqCommandId == 41)
+    if ((u8)reqCommandId == ID_DISCONNECTED_AND_CHANGE_REQ)
     {
-        u8 *r1 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-        
-        *bmLinkLossSlot = r1[4];
-        *linkLossReason = r1[5];
+        u8 *packet_p_2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+
+        *bmLinkLossSlot = packet_p_2[4];
+        *linkLossReason = packet_p_2[5];
         if (*linkLossReason == REASON_LINK_LOSS)
             *bmLinkLossSlot = gRfuLinkStatus->connSlotFlag;
-        sp08 = 2;
+        reasonMaybe = 2;
     }
     else
     {
-        if (reqCommandId == 310)
+        if (reqCommandId == 0x0136)
         {
-            r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5];
-            r6 ^= gRfuLinkStatus->connSlotFlag;
-            *bmLinkLossSlot = r6 & gRfuLinkStatus->connSlotFlag;
+            newLinkLossFlag = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5];
+            newLinkLossFlag ^= gRfuLinkStatus->connSlotFlag;
+            *bmLinkLossSlot = newLinkLossFlag & gRfuLinkStatus->connSlotFlag;
             *linkLossReason = REASON_LINK_LOSS;
             for (i = 0; i < RFU_CHILD_MAX; ++i)
             {
@@ -843,33 +924,41 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
             }
         }
-        if (sp08 == 0)
+        if (reasonMaybe == 0)
             return 0;
     }
-    sp10 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command;
-    sp14 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
+    stwiCommand = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command;
+    stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
     STWI_set_Callback_M(rfu_CB_defaultCallback);
     STWI_send_LinkStatusREQ();
-    sp0C = STWI_poll_CommandEnd();
-    if (sp0C == 0)
+    reqResult = STWI_poll_CommandEnd();
+    if (reqResult == 0)
     {
-        r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
+        packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
         for (i = 0; i < RFU_CHILD_MAX; ++i)
-            gRfuLinkStatus->strength[i] = *r2++;
-        r9 = 0;
+            gRfuLinkStatus->strength[i] = *packet_p++;
+        to_req_disconnect = 0;
         i = 0;
     }
     else
     {
-        rfu_STC_REQ_callback(17, sp0C);
-        return sp0C;
+        rfu_STC_REQ_callback(ID_LINK_STATUS_REQ, reqResult);
+        return reqResult;
     }
     for (; i < RFU_CHILD_MAX; ++i)
     {
-        r6 = 1 << i;
-        if (sp0C == 0)
+    #if LIBRFU_VERSION >= 1026
+        if (gRfuStatic->lsFixedCount[i] != 0)
+        {
+            gRfuStatic->lsFixedCount[i] -= 4;
+            if (gRfuLinkStatus->strength[i] <= 15)
+                gRfuLinkStatus->strength[i] = 16;
+        }
+    #endif
+        newLinkLossFlag = 1 << i;
+        if (reqResult == 0)
         {
-            if (sp08 == 1 && (gRfuLinkStatus->connSlotFlag & r6))
+            if (reasonMaybe == 1 && (gRfuLinkStatus->connSlotFlag & newLinkLossFlag))
             {
                 if (gRfuLinkStatus->strength[i] == 0)
                 {
@@ -878,8 +967,8 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                         ++gRfuStatic->linkEmergencyFlag[i];
                         if (gRfuStatic->linkEmergencyFlag[i] > 3)
                         {
-                            *bmLinkLossSlot |= r6;
-                            *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                            *bmLinkLossSlot |= newLinkLossFlag;
+                            *linkLossReason = REASON_LINK_LOSS;
                         }
                     }
                     else
@@ -889,18 +978,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                         {
                             if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
                             {
-                                *bmLinkLossSlot |= r6;
-                                *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                                *bmLinkLossSlot |= newLinkLossFlag;
+                                *linkLossReason = REASON_LINK_LOSS;
                             }
                             else
                             {
-                                if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->unk_1a)
+                                if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->linkEmergencyLimit)
                                 {
                                     gRfuStatic->linkEmergencyFlag[i] = 0;
                                     STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag);
                                     STWI_poll_CommandEnd();
-                                    *bmLinkLossSlot |= r6;
-                                    *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                                    *bmLinkLossSlot |= newLinkLossFlag;
+                                    *linkLossReason = REASON_LINK_LOSS;
                                 }
                             }
                         }
@@ -908,18 +997,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
                 else
                 {
-                    gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? 
+                    gRfuStatic->linkEmergencyFlag[i] = 0;
                 }
             }
             if (gRfuLinkStatus->parentChild == MODE_PARENT && gRfuLinkStatus->strength[i] != 0)
             {
-                if (r6 & gRfuLinkStatus->linkLossSlotFlag)
+                if (newLinkLossFlag & gRfuLinkStatus->linkLossSlotFlag)
                 {
                     if (gRfuLinkStatus->strength[i] > 10)
                     {
-                        *parentBmLinkRecoverySlot |= r6;
-                        gRfuLinkStatus->connSlotFlag |= r6;
-                        gRfuLinkStatus->linkLossSlotFlag &= ~r6;
+                        *parentBmLinkRecoverySlot |= newLinkLossFlag;
+                        gRfuLinkStatus->connSlotFlag |= newLinkLossFlag;
+                        gRfuLinkStatus->linkLossSlotFlag &= ~newLinkLossFlag;
                         ++gRfuLinkStatus->connCount;
                         gRfuStatic->linkEmergencyFlag[i] = 0;
                     }
@@ -930,19 +1019,19 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
                 else
                 {
-                    if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r6))
+                    if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & newLinkLossFlag))
                     {
                         STWI_send_SlotStatusREQ();
                         STWI_poll_CommandEnd();
-                        r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-                        r3 = r2[1] - 1;
-                        for (r2 += 8; r3 != 0; r2 += 4, --r3)
+                        packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+                        num_packets = packet_p[1] - 1;
+                        for (packet_p += 8; num_packets != 0; packet_p += 4, --num_packets)
                         {
-                            u16 r4 = *(u16 *)r2;
+                            u16 cid = *(u16 *)packet_p;
 
-                            if (r2[2] == i && r4 == gRfuStatic->cidBak[i])
+                            if (packet_p[2] == i && cid == gRfuStatic->cidBak[i])
                             {
-                                r9 |= 1 << i;
+                                to_req_disconnect |= 1 << i;
                                 break;
                             }
                         }
@@ -951,46 +1040,49 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
             }
         }
         connSlotFlag = gRfuLinkStatus->connSlotFlag;
-        r0 = *bmLinkLossSlot;
-        r0 &= connSlotFlag;
-        if (r6 & r0)
+        to_disconnect = *bmLinkLossSlot;
+        to_disconnect &= connSlotFlag;
+        if (newLinkLossFlag & to_disconnect)
             rfu_STC_removeLinkData(i, 0);
     }
-    if (r9 != 0)
+    if (to_req_disconnect != 0)
     {
-        STWI_send_DisconnectREQ(r9);
+        STWI_send_DisconnectREQ(to_req_disconnect);
         STWI_poll_CommandEnd();
     }
     // equivalent to:
-    // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = sp10;
-    *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = sp10;
-    gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = sp14;
+    // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = stwiCommand;
+    *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = stwiCommand;
+    gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = stwiParam;
     return 0;
 }
 
-static void rfu_STC_removeLinkData(u8 r7, u8 r12)
+static void rfu_STC_removeLinkData(u8 bmConnectedPartnerId, u8 bmDisconnect)
 {
-    u8 r5 = 1 << r7;
-    s32 r6;
+    u8 bmLinkLossFlag = 1 << bmConnectedPartnerId;
+    s32 bmLinkRetainedFlag;
 
-    if ((gRfuLinkStatus->connSlotFlag & r5) && gRfuLinkStatus->connCount != 0)
+#if LIBRFU_VERSION >= 1026
+    gRfuStatic->lsFixedCount[bmConnectedPartnerId] = 0;
+#endif
+    if ((gRfuLinkStatus->connSlotFlag & bmLinkLossFlag) && gRfuLinkStatus->connCount != 0)
         --gRfuLinkStatus->connCount;
-    gRfuLinkStatus->connSlotFlag &= r6 = ~r5;
-    gRfuLinkStatus->linkLossSlotFlag |= r5;
-    if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0)
+    gRfuLinkStatus->connSlotFlag &= bmLinkRetainedFlag = ~bmLinkLossFlag;
+    gRfuLinkStatus->linkLossSlotFlag |= bmLinkLossFlag;
+    if (gRfuLinkStatus->parentChild == MODE_CHILD && gRfuLinkStatus->connSlotFlag == 0)
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
-    if (r12 != 0)
+    if (bmDisconnect)
     {
-        CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData));
-        gRfuLinkStatus->linkLossSlotFlag &= r6;
-        gRfuLinkStatus->getNameFlag &= r6;
-        gRfuLinkStatus->strength[r7] = 0;
+        CpuFill16(0, &gRfuLinkStatus->partner[bmConnectedPartnerId], sizeof(struct RfuTgtData));
+        gRfuLinkStatus->linkLossSlotFlag &= bmLinkRetainedFlag;
+        gRfuLinkStatus->getNameFlag &= bmLinkRetainedFlag;
+        gRfuLinkStatus->strength[bmConnectedPartnerId] = 0;
     }
 }
 
 void rfu_REQ_disconnect(u8 bmDisconnectSlot)
 {
-    u16 r1;
+    u16 result;
 
     if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmDisconnectSlot)
     {
@@ -1003,9 +1095,9 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot)
         else if (gRfuStatic->SCStartFlag
               && (STWI_set_Callback_M(rfu_CB_defaultCallback),
                   STWI_send_SC_EndREQ(),
-                  (r1 = STWI_poll_CommandEnd()) != 0))
+                  (result = STWI_poll_CommandEnd()) != 0))
         {
-            rfu_STC_REQ_callback(27, r1);
+            rfu_STC_REQ_callback(ID_SC_END_REQ, result);
         }
         else
         {
@@ -1015,38 +1107,38 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot)
     }
 }
 
-static void rfu_CB_disconnect(u8 r6, u16 r5)
+static void rfu_CB_disconnect(u8 reqCommand, u16 reqResult)
 {
-    u8 r4, r0;
+    u8 i, bm_slot_flag;
 
-    if (r5 == 3 && gRfuLinkStatus->parentChild == MODE_CHILD)
+    if (reqResult == 3 && gRfuLinkStatus->parentChild == MODE_CHILD)
     {
         STWI_set_Callback_M(rfu_CB_defaultCallback);
         STWI_send_SystemStatusREQ();
         if (STWI_poll_CommandEnd() == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
-            r5 = 0;
+            reqResult = 0;
     }
     gRfuStatic->recoveryBmSlot &= gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
     gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8] = gRfuStatic->recoveryBmSlot;
-    if (r5 == 0)
+    if (reqResult == 0)
     {
-        for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r0 = 1 << r4;
-            if (r0 & gRfuStatic->recoveryBmSlot)
-                rfu_STC_removeLinkData(r4, 1);
+            bm_slot_flag = 1 << i;
+            if (bm_slot_flag & gRfuStatic->recoveryBmSlot)
+                rfu_STC_removeLinkData(i, 1);
         }
     }
     if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0)
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
-    rfu_STC_REQ_callback(r6, r5);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
     if (gRfuStatic->SCStartFlag)
     {
         STWI_set_Callback_M(rfu_CB_defaultCallback);
         STWI_send_SC_StartREQ();
-        r5 = STWI_poll_CommandEnd();
-        if (r5 != 0)
-            rfu_STC_REQ_callback(25, r5);
+        reqResult = STWI_poll_CommandEnd();
+        if (reqResult != 0)
+            rfu_STC_REQ_callback(ID_SC_START_REQ, reqResult);
     }
 }
 
@@ -1068,38 +1160,35 @@ void rfu_REQ_CHILD_pollConnectRecovery(void)
     STWI_send_CPR_PollingREQ();
 }
 
-static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7)
+static void rfu_CB_CHILD_pollConnectRecovery(u8 reqCommand, u16 reqResult)
 {
-    u8 r3, r4;
-    struct RfuLinkStatus *r2;
+    u8 bm_slot_flag, i;
+    struct RfuLinkStatus *rfuLinkStatus;
 
-    if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot)
+    if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot)
     {
         gRfuLinkStatus->parentChild = MODE_CHILD;
-        for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r3 = 1 << r4;
-            r2 = gRfuLinkStatus; // ???
-            if (gRfuStatic->recoveryBmSlot & r3 & r2->linkLossSlotFlag)
+            bm_slot_flag = 1 << i;
+            rfuLinkStatus = gRfuLinkStatus; // ???
+            if (gRfuStatic->recoveryBmSlot & bm_slot_flag & rfuLinkStatus->linkLossSlotFlag)
             {
-                gRfuLinkStatus->connSlotFlag |= r3;
-                gRfuLinkStatus->linkLossSlotFlag &= ~r3;
+                gRfuLinkStatus->connSlotFlag |= bm_slot_flag;
+                gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag;
                 ++gRfuLinkStatus->connCount;
-                gRfuStatic->linkEmergencyFlag[r4] = 0;
+                gRfuStatic->linkEmergencyFlag[i] = 0;
             }
         }
         gRfuStatic->recoveryBmSlot = 0;
     }
-    rfu_STC_REQ_callback(r8, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u16 rfu_CHILD_getConnectRecoveryStatus(u8 *status)
 {
-    u8 r0;
-
     *status = 0xFF;
-    r0 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] + 77;
-    if (r0 <= 1)
+    if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB3 || gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB4)
     {
         *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
         return 0;
@@ -1127,14 +1216,14 @@ static void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size)
 
 void rfu_REQ_changeMasterSlave(void)
 {
-    if (STWI_read_status(1) == 1)
+    if (STWI_read_status(1) == AGB_CLK_MASTER)
     {
         STWI_set_Callback_M(rfu_STC_REQ_callback);
         STWI_send_MS_ChangeREQ();
     }
     else
     {
-        rfu_STC_REQ_callback(39, 0);
+        rfu_STC_REQ_callback(ID_MS_CHANGE_REQ, 0);
     }
 }
 
@@ -1144,11 +1233,11 @@ bool8 rfu_getMasterSlave(void)
 
     if (masterSlave == AGB_CLK_MASTER)
     {
-        if (gSTWIStatus->unk_2c)
+        if (gSTWIStatus->sending)
         {
-            if (gSTWIStatus->reqActiveCommand == 39
-             || gSTWIStatus->reqActiveCommand == 37
-             || gSTWIStatus->reqActiveCommand == 55)
+            if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)
                 masterSlave = AGB_CLK_SLAVE;
         }
     }
@@ -1159,7 +1248,7 @@ void rfu_clearAllSlot(void)
 {
     u16 i;
     u16 IMEBackup = REG_IME;
-    
+
     REG_IME = 0;
     for (i = 0; i < RFU_CHILD_MAX; ++i)
     {
@@ -1175,87 +1264,87 @@ void rfu_clearAllSlot(void)
     REG_IME = IMEBackup;
 }
 
-static void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4)
+static void rfu_STC_releaseFrame(u8 bm_slot_id, u8 send_recv, struct NIComm *NI_comm)
 {
 
     if (!(gRfuStatic->flags & 0x80))
     {
-        if (r3 == 0)
-            gRfuLinkStatus->remainLLFrameSizeParent += r4->payloadSize;
+        if (send_recv == 0)
+            gRfuLinkStatus->remainLLFrameSizeParent += NI_comm->payloadSize;
         gRfuLinkStatus->remainLLFrameSizeParent += 3;
     }
     else
     {
-        if (r3 == 0)
-            gRfuLinkStatus->remainLLFrameSizeChild[r5] += r4->payloadSize;
-        gRfuLinkStatus->remainLLFrameSizeChild[r5] += 2;
+        if (send_recv == 0)
+            gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += NI_comm->payloadSize;
+        gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += 2;
     }
 }
 
 u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex)
 {
-    u16 r10, r3, r1;
-    struct NIComm *r4;
+    u16 imeBak, send_recv, i;
+    struct NIComm *NI_comm;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
     if (!(connTypeFlag & (TYPE_UNI_SEND | TYPE_UNI_RECV | TYPE_NI_SEND | TYPE_NI_RECV)))
         return ERR_COMM_TYPE;
-    r10 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
     if (connTypeFlag & (TYPE_NI_SEND | TYPE_NI_RECV))
     {
-        for (r3 = 0; r3 < 2; ++r3)
+        for (send_recv = 0; send_recv < 2; ++send_recv)
         {
-            r4 = NULL;
-            if (r3 == 0)
+            NI_comm = NULL;
+            if (send_recv == 0)
             {
                 if (connTypeFlag & TYPE_NI_SEND)
                 {
-                    r4 = &gRfuSlotStatusNI[slotStatusIndex]->send;
-                    gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg;
+                    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->send;
+                    gRfuLinkStatus->sendSlotNIFlag &= ~NI_comm->bmSlotOrg;
                 }
             }
             else
             {
                 if (connTypeFlag & TYPE_NI_RECV)
                 {
-                    r4 = &gRfuSlotStatusNI[slotStatusIndex]->recv;
+                    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv;
                     gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex);
                 }
             }
-            if (r4 != NULL)
+            if (NI_comm != NULL)
             {
-                if (r4->state & SLOT_BUSY_FLAG)
+                if (NI_comm->state & SLOT_BUSY_FLAG)
                 {
-                    rfu_STC_releaseFrame(slotStatusIndex, r3, r4);
-                    for (r1 = 0; r1 < RFU_CHILD_MAX; ++r1)
-                        if ((r4->bmSlotOrg >> r1) & 1)
-                            r4->failCounter = 0;
+                    rfu_STC_releaseFrame(slotStatusIndex, send_recv, NI_comm);
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
+                        if ((NI_comm->bmSlotOrg >> i) & 1)
+                            NI_comm->failCounter = 0;
                 }
-                CpuFill16(0, r4, sizeof(struct NIComm));
+                CpuFill16(0, NI_comm, sizeof(struct NIComm));
             }
         }
     }
     if (connTypeFlag & TYPE_UNI_SEND)
     {
-        struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[slotStatusIndex];
+        struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[slotStatusIndex];
 
-        if (r3->send.state & SLOT_BUSY_FLAG)
+        if (slotStatusUNI->send.state & SLOT_BUSY_FLAG)
         {
             if (!(gRfuStatic->flags & 0x80))
-                gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->send.payloadSize;
+                gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)slotStatusUNI->send.payloadSize;
             else
-                gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)r3->send.payloadSize;
-            gRfuLinkStatus->sendSlotUNIFlag &= ~r3->send.bmSlot;
+                gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)slotStatusUNI->send.payloadSize;
+            gRfuLinkStatus->sendSlotUNIFlag &= ~slotStatusUNI->send.bmSlot;
         }
-        CpuFill16(0, &r3->send, sizeof(struct UNISend));
+        CpuFill16(0, &slotStatusUNI->send, sizeof(struct UNISend));
     }
     if (connTypeFlag & TYPE_UNI_RECV)
     {
         CpuFill16(0, &gRfuSlotStatusUNI[slotStatusIndex]->recv, sizeof(struct UNIRecv));
     }
-    REG_IME = r10;
+    REG_IME = imeBak;
     return 0;
 }
 
@@ -1301,16 +1390,16 @@ u16 rfu_NI_CHILD_setSendGameName(u8 slotNo, u8 subFrameSize)
     return rfu_STC_setSendData_org(64, 1 << slotNo, subFrameSize, &gRfuLinkStatus->my.serialNo, 26);
 }
 
-static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 sp28)
+static u16 rfu_STC_setSendData_org(u8 ni_or_uni, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 dataSize)
 {
-    u8 r2, r0;
-    u8 r4;
-    u8 *r9;
-    u8 r5;
+    u8 bm_slot_id, sendSlotFlag;
+    u8 frameSize;
+    u8 *llFrameSize_p;
+    u8 sending;
     u8 i;
-    u16 sp04;
-    struct RfuSlotStatusUNI *r1;
-    struct RfuSlotStatusNI *r12;
+    u16 imeBak;
+    struct RfuSlotStatusUNI *slotStatus_UNI;
+    struct RfuSlotStatusNI *slotStatus_NI;
 
     if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
         return ERR_MODE_NOT_CONNECTED;
@@ -1318,108 +1407,108 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const
         return ERR_SLOT_NO;
     if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmSendSlot) != bmSendSlot)
         return ERR_SLOT_NOT_CONNECTED;
-    if (r6 & 0x10)
-        r0 = gRfuLinkStatus->sendSlotUNIFlag;
+    if (ni_or_uni & 0x10)
+        sendSlotFlag = gRfuLinkStatus->sendSlotUNIFlag;
     else
-        r0 = gRfuLinkStatus->sendSlotNIFlag;
-    if (r0 & bmSendSlot)
+        sendSlotFlag = gRfuLinkStatus->sendSlotNIFlag;
+    if (sendSlotFlag & bmSendSlot)
         return ERR_SLOT_BUSY;
-    for (r2 = 0; r2 < RFU_CHILD_MAX && !((bmSendSlot >> r2) & 1); ++r2)
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX && !((bmSendSlot >> bm_slot_id) & 1); ++bm_slot_id)
         ;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
-        r9 = &gRfuLinkStatus->remainLLFrameSizeParent;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent;
     else if (gRfuLinkStatus->parentChild == MODE_CHILD)
-        r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2];
-    r4 = llsf_struct[gRfuLinkStatus->parentChild].unk00;
-    if (subFrameSize > *r9 || subFrameSize <= r4)
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id];
+    frameSize = llsf_struct[gRfuLinkStatus->parentChild].frameSize;
+    if (subFrameSize > *llFrameSize_p || subFrameSize <= frameSize)
         return ERR_SUBFRAME_SIZE;
-    sp04 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
-    r5 = r6 & 0x20;
-    if (r5 || r6 == 0x40)
-    {
-        u8 *r1; // a hack to swap instructions
-
-        r12 = gRfuSlotStatusNI[r2];
-        r1 = NULL;
-        r12->send.errorCode = 0;
-        *r12->send.now_p = r1 = &r12->send.dataType;
-        r12->send.remainSize = 7;
-        r12->send.bmSlotOrg = bmSendSlot;
-        r12->send.bmSlot = bmSendSlot;
-        r12->send.payloadSize = subFrameSize - r4;
-        if (r5 != 0)
-            *r1 = 0;
+    sending = ni_or_uni & 0x20;
+    if (sending || ni_or_uni == 0x40)
+    {
+        u8 *dataType_p; // a hack to swap instructions
+
+        slotStatus_NI = gRfuSlotStatusNI[bm_slot_id];
+        slotStatus_UNI = NULL;
+        slotStatus_NI->send.errorCode = 0;
+        *slotStatus_NI->send.now_p = dataType_p = &slotStatus_NI->send.dataType;
+        slotStatus_NI->send.remainSize = 7;
+        slotStatus_NI->send.bmSlotOrg = bmSendSlot;
+        slotStatus_NI->send.bmSlot = bmSendSlot;
+        slotStatus_NI->send.payloadSize = subFrameSize - frameSize;
+        if (sending != 0)
+            *dataType_p = 0;
         else
-            *r1 = 1;
-        r12->send.dataSize = sp28;
-        r12->send.src = src;
-        r12->send.ack = 0;
-        r12->send.phase = 0;
+            *dataType_p = 1;
+        slotStatus_NI->send.dataSize = dataSize;
+        slotStatus_NI->send.src = src;
+        slotStatus_NI->send.ack = 0;
+        slotStatus_NI->send.phase = 0;
     #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette
         asm("":::"r2");
     #endif
         for (i = 0; i < WINDOW_COUNT; ++i)
         {
-            r12->send.recvAckFlag[i] = 0;
-            r12->send.n[i] = 1;
+            slotStatus_NI->send.recvAckFlag[i] = 0;
+            slotStatus_NI->send.n[i] = 1;
         }
-        for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
-            if ((bmSendSlot >> r2) & 1)
-                gRfuSlotStatusNI[r2]->send.failCounter = 0;
+        for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
+            if ((bmSendSlot >> bm_slot_id) & 1)
+                gRfuSlotStatusNI[bm_slot_id]->send.failCounter = 0;
         gRfuLinkStatus->sendSlotNIFlag |= bmSendSlot;
-        *r9 -= subFrameSize;
-        r12->send.state = SLOT_STATE_SEND_START;
+        *llFrameSize_p -= subFrameSize;
+        slotStatus_NI->send.state = SLOT_STATE_SEND_START;
     }
-    else if (r6 & 0x10)
+    else if (ni_or_uni & 0x10)
     {
-        r1 = gRfuSlotStatusUNI[r2];
-        r1->send.bmSlot = bmSendSlot;
-        r1->send.src = src;
-        r1->send.payloadSize = subFrameSize - r4;
-        *r9 -= subFrameSize;
-        r1->send.state = SLOT_STATE_SEND_UNI;
+        slotStatus_UNI = gRfuSlotStatusUNI[bm_slot_id];
+        slotStatus_UNI->send.bmSlot = bmSendSlot;
+        slotStatus_UNI->send.src = src;
+        slotStatus_UNI->send.payloadSize = subFrameSize - frameSize;
+        *llFrameSize_p -= subFrameSize;
+        slotStatus_UNI->send.state = SLOT_STATE_SEND_UNI;
         gRfuLinkStatus->sendSlotUNIFlag |= bmSendSlot;
     }
-    REG_IME = sp04;
+    REG_IME = imeBak;
     return 0;
 }
 
 u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
 {
-    struct RfuSlotStatusNI *r5;
-    u16 r8;
-    u8 r2;
+    struct RfuSlotStatusNI *slotStatusNI;
+    u16 imeBak;
+    u8 i;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
     if (connType == 0x20)
     {
-        r5 = gRfuSlotStatusNI[slotStatusIndex];
-        if ((r5->send.state & SLOT_BUSY_FLAG)
-         && (r5->send.state & SLOT_SEND_FLAG))
+        slotStatusNI = gRfuSlotStatusNI[slotStatusIndex];
+        if ((slotStatusNI->send.state & SLOT_BUSY_FLAG)
+         && (slotStatusNI->send.state & SLOT_SEND_FLAG))
         {
-            connType = bmNewTgtSlot ^ r5->send.bmSlot;
-            
+            connType = bmNewTgtSlot ^ slotStatusNI->send.bmSlot;
+
             if (!(connType & bmNewTgtSlot))
             {
                 if (connType)
                 {
-                    r8 = REG_IME;
+                    imeBak = REG_IME;
                     REG_IME = 0;
-                    for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
                     {
-                        if ((connType >> r2) & 1)
-                            gRfuSlotStatusNI[r2]->send.failCounter = 0;
+                        if ((connType >> i) & 1)
+                            gRfuSlotStatusNI[i]->send.failCounter = 0;
                     }
                     gRfuLinkStatus->sendSlotNIFlag &= ~connType;
-                    r5->send.bmSlot = bmNewTgtSlot;
-                    if (r5->send.bmSlot == 0)
+                    slotStatusNI->send.bmSlot = bmNewTgtSlot;
+                    if (slotStatusNI->send.bmSlot == 0)
                     {
-                        rfu_STC_releaseFrame(slotStatusIndex, 0, &r5->send);
-                        r5->send.state = SLOT_STATE_SEND_FAILED;
+                        rfu_STC_releaseFrame(slotStatusIndex, 0, &slotStatusNI->send);
+                        slotStatusNI->send.state = SLOT_STATE_SEND_FAILED;
                     }
-                    REG_IME = r8;
+                    REG_IME = imeBak;
                 }
             }
             else
@@ -1436,21 +1525,21 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
     {
         if (connType == 16)
         {
-            s32 r3;
+            s32 bmSlot;
 
             if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != SLOT_STATE_SEND_UNI)
                 return ERR_SLOT_NOT_SENDING;
-            for (r3 = 0, r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
-                if (r2 != slotStatusIndex)
-                    r3 |= gRfuSlotStatusUNI[r2]->send.bmSlot;
-            if (bmNewTgtSlot & r3)
+            for (bmSlot = 0, i = 0; i < RFU_CHILD_MAX; ++i)
+                if (i != slotStatusIndex)
+                    bmSlot |= gRfuSlotStatusUNI[i]->send.bmSlot;
+            if (bmNewTgtSlot & bmSlot)
                 return ERR_SLOT_TARGET;
-            r8 = REG_IME;
+            imeBak = REG_IME;
             REG_IME = 0;
             gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot;
             gRfuLinkStatus->sendSlotUNIFlag |= bmNewTgtSlot;
             gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot = bmNewTgtSlot;
-            REG_IME = r8;
+            REG_IME = imeBak;
         }
         else
         {
@@ -1462,14 +1551,14 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
 
 u16 rfu_NI_stopReceivingData(u8 slotStatusIndex)
 {
-    struct NIComm *r5;
-    u16 r4, r1;
+    struct NIComm *NI_comm;
+    u16 imeBak;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
-    r5 = &gRfuSlotStatusNI[slotStatusIndex]->recv;
-    r4 = REG_IME;
-    ++r4; --r4; // fix r4, r5 register swap
+    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv;
+    imeBak = REG_IME;
+    ++imeBak; --imeBak; // fix imeBak, NI_comm register swap
     REG_IME = 0;
     if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & SLOT_BUSY_FLAG)
     {
@@ -1478,43 +1567,43 @@ u16 rfu_NI_stopReceivingData(u8 slotStatusIndex)
         else
             gRfuSlotStatusNI[slotStatusIndex]->recv.state = SLOT_STATE_RECV_FAILED;
         gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex);
-        rfu_STC_releaseFrame(slotStatusIndex, 1, r5);
+        rfu_STC_releaseFrame(slotStatusIndex, 1, NI_comm);
     }
-    REG_IME = r4;
+    REG_IME = imeBak;
     return 0;
 }
 
 u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size)
 {
-    struct UNISend *r4;
-    u8 *r6;
-    u16 r1;
-    u8 r3_;
+    struct UNISend *UNI_send;
+    u8 *frame_p;
+    u16 imeBak;
+    u8 frameEnd;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
-    r4 = &gRfuSlotStatusUNI[slotStatusIndex]->send;
-    if (r4->state != SLOT_STATE_SEND_UNI)
+    UNI_send = &gRfuSlotStatusUNI[slotStatusIndex]->send;
+    if (UNI_send->state != SLOT_STATE_SEND_UNI)
         return ERR_SLOT_NOT_SENDING;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
     {
-        r6 = &gRfuLinkStatus->remainLLFrameSizeParent;
-        r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize;
+        frame_p = &gRfuLinkStatus->remainLLFrameSizeParent;
+        frameEnd = gRfuLinkStatus->remainLLFrameSizeParent + (u8)UNI_send->payloadSize;
     }
     else
     {
-        r6 = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex];
-        r3_ = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)r4->payloadSize;
+        frame_p = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex];
+        frameEnd = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)UNI_send->payloadSize;
     }
-    if (r3_ < size)
+    if (frameEnd < size)
         return ERR_SUBFRAME_SIZE;
-    r1 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
-    r4->src = src;
-    *r6 = r3_ - size;
-    r4->payloadSize = size;
-    r4->dataReadyFlag = 1;
-    REG_IME = r1;
+    UNI_send->src = src;
+    *frame_p = frameEnd - size;
+    UNI_send->payloadSize = size;
+    UNI_send->dataReadyFlag = 1;
+    REG_IME = imeBak;
     return 0;
 }
 
@@ -1593,184 +1682,184 @@ void rfu_REQ_sendData(bool8 clockChangeFlag)
     }
 }
 
-static void rfu_CB_sendData(UNUSED u8 r0, u16 r7)
+static void rfu_CB_sendData(UNUSED u8 reqCommand, u16 reqResult)
 {
-    u8 r6;
-    struct NIComm *r4;
+    u8 i;
+    struct NIComm *NI_comm;
 
-    if (r7 == 0)
+    if (reqResult == 0)
     {
-        for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            if (gRfuSlotStatusUNI[r6]->send.dataReadyFlag)
-                gRfuSlotStatusUNI[r6]->send.dataReadyFlag = 0;
-            r4 = &gRfuSlotStatusNI[r6]->send;
-            if (r4->state == SLOT_STATE_SEND_NULL)
+            if (gRfuSlotStatusUNI[i]->send.dataReadyFlag)
+                gRfuSlotStatusUNI[i]->send.dataReadyFlag = 0;
+            NI_comm = &gRfuSlotStatusNI[i]->send;
+            if (NI_comm->state == SLOT_STATE_SEND_NULL)
             {
-                rfu_STC_releaseFrame(r6, 0, r4);
-                gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlot;
-                if (r4->dataType == 1)
-                    gRfuLinkStatus->getNameFlag |= 1 << r6;
-                r4->state = SLOT_STATE_SEND_SUCCESS;
+                rfu_STC_releaseFrame(i, 0, NI_comm);
+                gRfuLinkStatus->sendSlotNIFlag &= ~NI_comm->bmSlot;
+                if (NI_comm->dataType == 1)
+                    gRfuLinkStatus->getNameFlag |= 1 << i;
+                NI_comm->state = SLOT_STATE_SEND_SUCCESS;
             }
         }
     }
     gRfuLinkStatus->LLFReadyFlag = 0;
-    rfu_STC_REQ_callback(36, r7);
+    rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult);
 }
 
-static void rfu_CB_sendData2(UNUSED u8 r0, u16 r1)
+static void rfu_CB_sendData2(UNUSED u8 reqCommand, u16 reqResult)
 {
-    rfu_STC_REQ_callback(36, r1);
+    rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult);
 }
 
-static void rfu_CB_sendData3(u8 r0, u16 r1)
+static void rfu_CB_sendData3(u8 reqCommand, u16 reqResult)
 {
-    if (r1 != 0)
-        rfu_STC_REQ_callback(36, r1);
-    else if (r0 == 0xFF)
-        rfu_STC_REQ_callback(0xFF, 0);
+    if (reqResult != 0)
+        rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult);
+    else if (reqCommand == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ)
+        rfu_STC_REQ_callback(ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ, 0);
 }
 
 static void rfu_constructSendLLFrame(void)
 {
-    u32 r8, r5;
-    u8 r6;
-    u8 *sp00;
-    struct RfuSlotStatusNI *r2;
+    u32 pakcketSize, currSize;
+    u8 i;
+    u8 *llf_p;
+    struct RfuSlotStatusNI *slotStatusNI;
 
     if (gRfuLinkStatus->parentChild != MODE_NEUTRAL
      && gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag)
     {
         gRfuLinkStatus->LLFReadyFlag = 0;
-        r8 = 0;
-        sp00 = (u8 *)&gRfuFixed->LLFBuffer[1];
-        for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6)
+        pakcketSize = 0;
+        llf_p = (u8 *)&gRfuFixed->LLFBuffer[1];
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r5 = 0;
-            if (gRfuSlotStatusNI[r6]->send.state & SLOT_BUSY_FLAG)
-                r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->send);
-            if (gRfuSlotStatusNI[r6]->recv.state & SLOT_BUSY_FLAG)
-                r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->recv);
-            if (gRfuSlotStatusUNI[r6]->send.state == SLOT_STATE_SEND_UNI)
-                r5 += rfu_STC_UNI_constructLLSF(r6, &sp00);
-            if (r5 != 0)
+            currSize = 0;
+            if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG)
+                currSize = rfu_STC_NI_constructLLSF(i, &llf_p, &gRfuSlotStatusNI[i]->send);
+            if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG)
+                currSize += rfu_STC_NI_constructLLSF(i, &llf_p, &gRfuSlotStatusNI[i]->recv);
+            if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI)
+                currSize += rfu_STC_UNI_constructLLSF(i, &llf_p);
+            if (currSize != 0)
             {
                 if (gRfuLinkStatus->parentChild == MODE_PARENT)
-                    r8 += r5;
+                    pakcketSize += currSize;
                 else
-                    r8 |= r5 << (5 * r6 + 8);
+                    pakcketSize |= currSize << (5 * i + 8);
             }
         }
-        if (r8 != 0)
+        if (pakcketSize != 0)
         {
-            while ((u32)sp00 & 3)
-                *sp00++ = 0;
-            gRfuFixed->LLFBuffer[0] = r8;
+            while ((u32)llf_p & 3)
+                *llf_p++ = 0;
+            gRfuFixed->LLFBuffer[0] = pakcketSize;
             if (gRfuLinkStatus->parentChild == MODE_CHILD)
             {
-                u8 *r0 = sp00 - offsetof(struct RfuFixed, LLFBuffer[1]);
-                
-                // Does the volatile qualifier make sense? 
-                // It's the same as: 
+                u8 *maxSize = llf_p - offsetof(struct RfuFixed, LLFBuffer[1]);
+
+                // Does the volatile qualifier make sense?
+                // It's the same as:
                 // asm("":::"memory");
-                r8 = r0 - *(u8 *volatile *)&gRfuFixed;
+                pakcketSize = maxSize - *(u8 *volatile *)&gRfuFixed;
             }
         }
-        gRfuStatic->totalPacketSize = r8;
+        gRfuStatic->totalPacketSize = pakcketSize;
     }
 }
 
-static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4)
+static u16 rfu_STC_NI_constructLLSF(u8 bm_slot_id, u8 **dest_pp, struct NIComm *NI_comm)
 {
-    u16 r5;
-    u32 sp00;
+    u16 size;
+    u32 frame;
     u8 i;
-    u8 *r2;
-    const struct LLSFStruct *r8 = &llsf_struct[gRfuLinkStatus->parentChild];
+    u8 *frame8_p;
+    const struct LLSFStruct *llsf = &llsf_struct[gRfuLinkStatus->parentChild];
 
-    if (r4->state == SLOT_STATE_SENDING)
+    if (NI_comm->state == SLOT_STATE_SENDING)
     {
-        while (r4->now_p[r4->phase] >= (const u8 *)r4->src + r4->dataSize)
+        while (NI_comm->now_p[NI_comm->phase] >= (const u8 *)NI_comm->src + NI_comm->dataSize)
         {
-            ++r4->phase;
-            if (r4->phase == 4)
-                r4->phase = 0;
+            ++NI_comm->phase;
+            if (NI_comm->phase == 4)
+                NI_comm->phase = 0;
         }
     }
-    if (r4->state & SLOT_RECV_FLAG)
+    if (NI_comm->state & SLOT_RECV_FLAG)
     {
-        r5 = 0;
+        size = 0;
     }
-    else if (r4->state == SLOT_STATE_SENDING)
+    else if (NI_comm->state == SLOT_STATE_SENDING)
     {
-        if (r4->now_p[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize)
-            r5 = (const u8 *)r4->src + r4->dataSize - r4->now_p[r4->phase];
+        if (NI_comm->now_p[NI_comm->phase] + NI_comm->payloadSize > (const u8 *)NI_comm->src + NI_comm->dataSize)
+            size = (const u8 *)NI_comm->src + NI_comm->dataSize - NI_comm->now_p[NI_comm->phase];
         else
-            r5 = r4->payloadSize;
+            size = NI_comm->payloadSize;
     }
     else
     {
-        if ((u32)r4->remainSize >= r4->payloadSize)
-            r5 = r4->payloadSize;
+        if ((u32)NI_comm->remainSize >= NI_comm->payloadSize)
+            size = NI_comm->payloadSize;
         else
-            r5 = r4->remainSize;
+            size = NI_comm->remainSize;
     }
-    sp00 = (r4->state & 0xF) << r8->unk03
-         | r4->ack << r8->unk04
-         | r4->phase << r8->unk05
-         | r4->n[r4->phase] << r8->unk06
-         | r5;
+    frame = (NI_comm->state & 0xF) << llsf->slotStateShift
+         | NI_comm->ack << llsf->ackShift
+         | NI_comm->phase << llsf->phaseShit
+         | NI_comm->n[NI_comm->phase] << llsf->nShift
+         | size;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
-        sp00 |= r4->bmSlot << 18;
-    r2 = (u8 *)&sp00;
-    for (i = 0; i < r8->unk00; ++i)
-        *(*r12)++ = *r2++;
-    if (r5 != 0)
+        frame |= NI_comm->bmSlot << 18;
+    frame8_p = (u8 *)&frame;
+    for (i = 0; i < llsf->frameSize; ++i)
+        *(*dest_pp)++ = *frame8_p++;
+    if (size != 0)
     {
-        const u8 *sp04 = r4->now_p[r4->phase];
+        const u8 *src = NI_comm->now_p[NI_comm->phase];
 
-        gRfuFixed->fastCopyPtr(&sp04, r12, r5);
+        gRfuFixed->fastCopyPtr(&src, dest_pp, size);
     }
-    if (r4->state == SLOT_STATE_SENDING)
+    if (NI_comm->state == SLOT_STATE_SENDING)
     {
-        ++r4->phase;
-        if (r4->phase == 4)
-            r4->phase = 0;
+        ++NI_comm->phase;
+        if (NI_comm->phase == 4)
+            NI_comm->phase = 0;
     }
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
         gRfuLinkStatus->LLFReadyFlag = 1;
     else
-        gRfuLinkStatus->LLFReadyFlag |= 1 << r10;
-    return r5 + r8->unk00;
+        gRfuLinkStatus->LLFReadyFlag |= 1 << bm_slot_id;
+    return size + llsf->frameSize;
 }
 
-static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6)
+static u16 rfu_STC_UNI_constructLLSF(u8 bm_slot_id, u8 **dest_p)
 {
-    const struct LLSFStruct *r5;
-    const u8 *sp04;
-    u32 sp00;
-    u8 *r2;
+    const struct LLSFStruct *llsf;
+    const u8 *src_p;
+    u32 frame;
+    u8 *frame8_p;
     u8 i;
-    struct UNISend *r4 = &gRfuSlotStatusUNI[r8]->send;
+    struct UNISend *UNI_send = &gRfuSlotStatusUNI[bm_slot_id]->send;
 
-    if (!r4->dataReadyFlag || !r4->bmSlot)
+    if (!UNI_send->dataReadyFlag || !UNI_send->bmSlot)
         return 0;
-    r5 = &llsf_struct[gRfuLinkStatus->parentChild];
-    sp00 = (r4->state & 0xF) << r5->unk03
-         | r4->payloadSize;
+    llsf = &llsf_struct[gRfuLinkStatus->parentChild];
+    frame = (UNI_send->state & 0xF) << llsf->slotStateShift
+         | UNI_send->payloadSize;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
-        sp00 |= r4->bmSlot << 18;
-    r2 = (u8 *)&sp00;
-    for (i = 0; i < r5->unk00; ++i)
-        *(*r6)++ = *r2++;
-    sp04 = r4->src;
-    gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize);
+        frame |= UNI_send->bmSlot << 18;
+    frame8_p = (u8 *)&frame;
+    for (i = 0; i < llsf->frameSize; ++i)
+        *(*dest_p)++ = *frame8_p++;
+    src_p = UNI_send->src;
+    gRfuFixed->fastCopyPtr(&src_p, dest_p, UNI_send->payloadSize);
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
         gRfuLinkStatus->LLFReadyFlag = 16;
     else
-        gRfuLinkStatus->LLFReadyFlag |= 16 << r8;
-    return r5->unk00 + r4->payloadSize;
+        gRfuLinkStatus->LLFReadyFlag |= 16 << bm_slot_id;
+    return llsf->frameSize + UNI_send->payloadSize;
 }
 
 void rfu_REQ_recvData(void)
@@ -1784,434 +1873,433 @@ void rfu_REQ_recvData(void)
     }
 }
 
-static void rfu_CB_recvData(u8 r9, u16 r7)
+static void rfu_CB_recvData(u8 reqCommand, u16 reqResult)
 {
-    u8 r6;
-    struct RfuSlotStatusNI *r4;
-    struct NIComm *r5;
+    u8 i;
+    struct RfuSlotStatusNI *slotStatusNI;
+    struct NIComm *NI_comm;
 
-    if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1])
+    if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1])
     {
         gRfuStatic->NIEndRecvFlag = 0;
         if (gRfuLinkStatus->parentChild == MODE_PARENT)
             rfu_STC_PARENT_analyzeRecvPacket();
         else
             rfu_STC_CHILD_analyzeRecvPacket();
-        for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r4 = gRfuSlotStatusNI[r6];
-            if (r4->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> r6) & 1))
+            slotStatusNI = gRfuSlotStatusNI[i];
+            if (slotStatusNI->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> i) & 1))
             {
-                r5 = &r4->recv;
-                if (r5->dataType == 1)
-                    gRfuLinkStatus->getNameFlag |= 1 << r6;
-                rfu_STC_releaseFrame(r6, 1, r5);
-                gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot;
-                r4->recv.state = SLOT_STATE_RECV_SUCCESS;
+                NI_comm = &slotStatusNI->recv;
+                if (NI_comm->dataType == 1)
+                    gRfuLinkStatus->getNameFlag |= 1 << i;
+                rfu_STC_releaseFrame(i, 1, NI_comm);
+                gRfuLinkStatus->recvSlotNIFlag &= ~NI_comm->bmSlot;
+                slotStatusNI->recv.state = SLOT_STATE_RECV_SUCCESS;
             }
         }
         if (gRfuStatic->recvErrorFlag)
-            r7 = gRfuStatic->recvErrorFlag | ERR_DATA_RECV;
+            reqResult = gRfuStatic->recvErrorFlag | ERR_DATA_RECV;
     }
-    rfu_STC_REQ_callback(r9, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 static void rfu_STC_PARENT_analyzeRecvPacket(void)
 {
-    u32 r3;
-    u8 r5;
-    u8 sp[4];
-    u8 *r6;
+    u32 frames32;
+    u8 bm_slot_id;
+    u8 frame_counts[RFU_CHILD_MAX];
+    u8 *packet_p;
 
-    r3 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8;
-    for (r5 = 0; r5 < NELEMS(sp); ++r5)
+    frames32 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8;
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
     {
-        sp[r5] = r3 & 0x1F;
-        r3 >>= 5;
-        if (sp[r5] == 0)
-            gRfuStatic->NIEndRecvFlag |= 1 << r5;
+        frame_counts[bm_slot_id] = frames32 & 0x1F;
+        frames32 >>= 5;
+        if (frame_counts[bm_slot_id] == 0)
+            gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id;
     }
-    r6 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
-    for (r5 = 0; r5 < NELEMS(sp); ++r5)
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
     {
-        if (sp[r5])
+        if (frame_counts[bm_slot_id])
         {
-            u8 *r4 = &sp[r5];
+            u8 *frames_p = &frame_counts[bm_slot_id];
 
             do
             {
-                u8 r0 = rfu_STC_analyzeLLSF(r5, r6, *r4);
+                u8 analyzed_frames = rfu_STC_analyzeLLSF(bm_slot_id, packet_p, *frames_p);
 
-                r6 += r0;
-                *r4 -= r0;
-            } while (!(*r4 & 0x80) && (*r4));
+                packet_p += analyzed_frames;
+                *frames_p -= analyzed_frames;
+            } while (!(*frames_p & 0x80) && (*frames_p));
         }
     }
 }
 
 static void rfu_STC_CHILD_analyzeRecvPacket(void)
 {
-    u16 r4;
-    u8 *r5;
-    u16 r0;
+    u16 frames_remaining;
+    u8 *packet_p;
+    u16 analyzed_frames;
 
-    r4 = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F;
-    r5 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
-    if (r4 == 0)
+    frames_remaining = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F;
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
+    if (frames_remaining == 0)
         gRfuStatic->NIEndRecvFlag = 15;
     do
     {
-        if (r4 == 0)
+        if (frames_remaining == 0)
             break;
-        r0 = rfu_STC_analyzeLLSF(0, r5, r4);
-        r5 += r0;
-        r4 -= r0;
-    } while (!(r4 & 0x8000));
-}
-
-static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3)
-{
-    struct RfuLocalStruct sp00;
-    const struct LLSFStruct *r6;
-    u32 r5;
-    u8 r4;
-    u32 r0;
-    u16 r10;
-
-    r6 = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)];
-    if (r3 < r6->unk00)
-        return r3;
-    r5 = 0;
-    for (r4 = 0; r4 < r6->unk00; ++r4)
-        r5 |= *r7++ << 8 * r4;
-    sp00.unk00 = (r5 >> r6->unk01) & r6->unk07;
-    sp00.unk01 = (r5 >> r6->unk02) & r6->unk08;
-    sp00.unk02 = (r5 >> r6->unk03) & r6->unk09;
-    sp00.unk03 = (r5 >> r6->unk04) & r6->unk0A;
-    sp00.unk04 = (r5 >> r6->unk05) & r6->unk0B;
-    sp00.unk05 = (r5 >> r6->unk06) & r6->unk0C;
-    sp00.unk06 = (r5  & r6->unk0E) & r5;
-    r10 = sp00.unk06 + r6->unk00;
-    if (sp00.unk00 == 0)
+        analyzed_frames = rfu_STC_analyzeLLSF(0, packet_p, frames_remaining);
+        packet_p += analyzed_frames;
+        frames_remaining -= analyzed_frames;
+    } while (!(frames_remaining & 0x8000));
+}
+
+static u16 rfu_STC_analyzeLLSF(u8 slot_id, const u8 *src, u16 last_frame)
+{
+    struct RfuLocalStruct llsf_NI;
+    const struct LLSFStruct *llsf_p;
+    u32 frames;
+    u8 i;
+    u16 retVal;
+
+    llsf_p = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)];
+    if (last_frame < llsf_p->frameSize)
+        return last_frame;
+    frames = 0;
+    for (i = 0; i < llsf_p->frameSize; ++i)
+        frames |= *src++ << 8 * i;
+    llsf_NI.recvFirst = (frames >> llsf_p->recvFirstShift) & llsf_p->recvFirstMask;
+    llsf_NI.connSlotFlag = (frames >> llsf_p->connSlotFlagShift) & llsf_p->connSlotFlagMask;
+    llsf_NI.slotState = (frames >> llsf_p->slotStateShift) & llsf_p->slotStateMask;
+    llsf_NI.ack = (frames >> llsf_p->ackShift) & llsf_p->ackMask;
+    llsf_NI.phase = (frames >> llsf_p->phaseShit) & llsf_p->phaseMask;
+    llsf_NI.n = (frames >> llsf_p->nShift) & llsf_p->nMask;
+    llsf_NI.frame = (frames  & llsf_p->framesMask) & frames;
+    retVal = llsf_NI.frame + llsf_p->frameSize;
+    if (llsf_NI.recvFirst == 0)
     {
         if (gRfuLinkStatus->parentChild == MODE_PARENT)
         {
-            if ((gRfuLinkStatus->connSlotFlag >> r12) & 1)
+            if ((gRfuLinkStatus->connSlotFlag >> slot_id) & 1)
             {
-                if (sp00.unk02 == 4)
+                if (llsf_NI.slotState == LCOM_UNI)
                 {
-                    rfu_STC_UNI_receive(r12, &sp00, r7);
+                    rfu_STC_UNI_receive(slot_id, &llsf_NI, src);
                 }
-                else if (sp00.unk03 == 0)
+                else if (llsf_NI.ack == 0)
                 {
-                    rfu_STC_NI_receive_Receiver(r12, &sp00, r7);
+                    rfu_STC_NI_receive_Receiver(slot_id, &llsf_NI, src);
                 }
                 else
                 {
-                    for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
-                        if (((gRfuSlotStatusNI[r4]->send.bmSlot >> r12) & 1)
-                         && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1))
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
+                        if (((gRfuSlotStatusNI[i]->send.bmSlot >> slot_id) & 1)
+                         && ((gRfuLinkStatus->sendSlotNIFlag >> slot_id) & 1))
                             break;
-                    if (r4 <= 3)
-                        rfu_STC_NI_receive_Sender(r4, r12, &sp00, r7);
+                    if (i < RFU_CHILD_MAX)
+                        rfu_STC_NI_receive_Sender(i, slot_id, &llsf_NI, src);
                 }
             }
         }
         else
         {
-            s32 r5 = gRfuLinkStatus->connSlotFlag & sp00.unk01;
+            s32 conSlots = gRfuLinkStatus->connSlotFlag & llsf_NI.connSlotFlag;
 
-            if (r5)
+            if (conSlots)
             {
-                for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
+                for (i = 0; i < RFU_CHILD_MAX; ++i)
                 {
-                    if ((r5 >> r4) & 1)
+                    if ((conSlots >> i) & 1)
                     {
-                        if (sp00.unk02 == 4)
-                            rfu_STC_UNI_receive(r4, &sp00, r7);
-                        else if (sp00.unk03 == 0)
-                            rfu_STC_NI_receive_Receiver(r4, &sp00, r7);
-                        else if ((gRfuLinkStatus->sendSlotNIFlag >> r4) & 1)
-                            rfu_STC_NI_receive_Sender(r4, r4, &sp00, r7);
+                        if (llsf_NI.slotState == LCOM_UNI)
+                            rfu_STC_UNI_receive(i, &llsf_NI, src);
+                        else if (llsf_NI.ack == 0)
+                            rfu_STC_NI_receive_Receiver(i, &llsf_NI, src);
+                        else if ((gRfuLinkStatus->sendSlotNIFlag >> i) & 1)
+                            rfu_STC_NI_receive_Sender(i, i, &llsf_NI, src);
                     }
                 }
             }
         }
     }
-    return r10;
+    return retVal;
 }
 
-static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 *sp00)
+static void rfu_STC_UNI_receive(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *src)
 {
-    u8 *sp04;
-    u32 r2;
-    struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7];
-    struct UNIRecv *r5 = &r3->recv;
+    u8 *dest;
+    u32 size;
+    struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[bm_slot_id];
+    struct UNIRecv *UNI_recv = &slotStatusUNI->recv;
 
-    r5->errorCode = 0;
-    if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06)
+    UNI_recv->errorCode = 0;
+    if (gRfuSlotStatusUNI[bm_slot_id]->recvBufferSize < llsf_NI->frame)
     {
-        r3->recv.state = SLOT_STATE_RECV_IGNORE;
-        r5->errorCode = ERR_RECV_BUFF_OVER;
+        slotStatusUNI->recv.state = SLOT_STATE_RECV_IGNORE;
+        UNI_recv->errorCode = ERR_RECV_BUFF_OVER;
     }
     else
-    { 
-        if (r5->dataBlockFlag)
+    {
+        if (UNI_recv->dataBlockFlag)
         {
-            if (r5->newDataFlag)
+            if (UNI_recv->newDataFlag)
             {
-                r5->errorCode = ERR_RECV_UNK;
-                goto _081E2F0E;
+                UNI_recv->errorCode = ERR_RECV_UNK;
+                goto force_tail_merge;
             }
         }
         else
         {
-            if (r5->newDataFlag)
-                r5->errorCode = ERR_RECV_DATA_OVERWRITED;
+            if (UNI_recv->newDataFlag)
+                UNI_recv->errorCode = ERR_RECV_DATA_OVERWRITED;
         }
-        r5->state = SLOT_STATE_RECEIVING;
-        r2 = r5->dataSize = r6->unk06;
-        sp04 = gRfuSlotStatusUNI[r7]->recvBuffer;
-        gRfuFixed->fastCopyPtr(&sp00, &sp04, r2);
-        r5->newDataFlag = 1;
-        r5->state = 0;
+        UNI_recv->state = SLOT_STATE_RECEIVING;
+        size = UNI_recv->dataSize = llsf_NI->frame;
+        dest = gRfuSlotStatusUNI[bm_slot_id]->recvBuffer;
+        gRfuFixed->fastCopyPtr(&src, &dest, size);
+        UNI_recv->newDataFlag = 1;
+        UNI_recv->state = 0;
     }
-_081E2F0E:
-    if (r5->errorCode)
-        gRfuStatic->recvErrorFlag |= 16 << r7;
+force_tail_merge:
+    if (UNI_recv->errorCode)
+        gRfuStatic->recvErrorFlag |= 16 << bm_slot_id;
 }
 
-static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct *r6, const u8 *r3)
+static void rfu_STC_NI_receive_Sender(u8 NI_slot, u8 bm_flag, const struct RfuLocalStruct *llsf_NI, const u8 *data_p)
 {
-    struct NIComm *r12 = &gRfuSlotStatusNI[r0]->send;
-    u16 r9 = r12->state;
-    u8 sp00 = r12->n[r6->unk04];
-    u8 *r8;
-    u8 r4;
-    u16 r2;
+    struct NIComm *NI_comm = &gRfuSlotStatusNI[NI_slot]->send;
+    u16 state = NI_comm->state;
+    u8 n = NI_comm->n[llsf_NI->phase];
+    u8 i;
+    u16 imeBak;
 
-    if ((r6->unk02 == 2 && r9 == SLOT_STATE_SENDING)
-     || (r6->unk02 == 1 && r9 == SLOT_STATE_SEND_START)
-     || (r6->unk02 == 3 && r9 == SLOT_STATE_SEND_LAST))
+    if ((llsf_NI->slotState == LCOM_NI && state == SLOT_STATE_SENDING)
+     || (llsf_NI->slotState == LCOM_NI_START && state == SLOT_STATE_SEND_START)
+     || (llsf_NI->slotState == LCOM_NI_END && state == SLOT_STATE_SEND_LAST))
     {
-        if (r12->n[r6->unk04] == r6->unk05)
-            r12->recvAckFlag[r6->unk04] |= 1 << r10;
+        if (NI_comm->n[llsf_NI->phase] == llsf_NI->n)
+            NI_comm->recvAckFlag[llsf_NI->phase] |= 1 << bm_flag;
     }
-    if ((r12->recvAckFlag[r6->unk04] & r12->bmSlot) == r12->bmSlot)
+    if ((NI_comm->recvAckFlag[llsf_NI->phase] & NI_comm->bmSlot) == NI_comm->bmSlot)
     {
-        r12->n[r6->unk04] = (r12->n[r6->unk04] + 1) & 3;
-        r12->recvAckFlag[r6->unk04] = 0;
-        if ((u16)(r12->state + ~SLOT_STATE_SEND_NULL) <= 1)
+        NI_comm->n[llsf_NI->phase] = (NI_comm->n[llsf_NI->phase] + 1) & 3;
+        NI_comm->recvAckFlag[llsf_NI->phase] = 0;
+        if ((u16)(NI_comm->state + ~SLOT_STATE_SEND_NULL) <= 1)
         {
-            if (r12->state == SLOT_STATE_SEND_START)
-                r12->now_p[r6->unk04] += r12->payloadSize;
+            if (NI_comm->state == SLOT_STATE_SEND_START)
+                NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize;
             else
-                r12->now_p[r6->unk04] += r12->payloadSize << 2;
-            r12->remainSize -= r12->payloadSize;
-            if (r12->remainSize != 0)
-                if (r12->remainSize >= 0)
+                NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize << 2;
+            NI_comm->remainSize -= NI_comm->payloadSize;
+            if (NI_comm->remainSize != 0)
+                if (NI_comm->remainSize >= 0)
                     goto _081E30AE;
-            // Above is a hack to avoid optimization over comparison. 
-            // rfu_STC_NI_constructLLSF uses this field as u32. 
-            // It's equivalent to the following condition: 
-            // if (r12->remainSize == 0 || r12->remainSize < 0)
-            {
-                r12->phase = 0;
-                if (r12->state == SLOT_STATE_SEND_START)
+            // Above is a hack to avoid optimization over comparison.
+            // rfu_STC_NI_constructLLSF uses this field as u32.
+            // It's equivalent to the following condition:
+            // if (NI_comm->remainSize == 0 || NI_comm->remainSize < 0)
                 {
-                    for (r4 = 0; r4 < WINDOW_COUNT; ++r4)
+                    NI_comm->phase = 0;
+                    if (NI_comm->state == SLOT_STATE_SEND_START)
                     {
-                        r12->n[r4] = 1;
-                        r12->now_p[r4] = r12->src + r12->payloadSize * r4;
+                        for (i = 0; i < WINDOW_COUNT; ++i)
+                        {
+                            NI_comm->n[i] = 1;
+                            NI_comm->now_p[i] = NI_comm->src + NI_comm->payloadSize * i;
+                        }
+                        NI_comm->remainSize = NI_comm->dataSize;
+                        NI_comm->state = SLOT_STATE_SENDING;
+                    }
+                    else
+                    {
+                        NI_comm->n[0] = 0;
+                        NI_comm->remainSize = 0;
+                        NI_comm->state = SLOT_STATE_SEND_LAST;
                     }
-                    r12->remainSize = r12->dataSize;
-                    r12->state = SLOT_STATE_SENDING;
-                }
-                else
-                {
-                    r12->n[0] = 0;
-                    r12->remainSize = 0;
-                    r12->state = SLOT_STATE_SEND_LAST;
                 }
-            }
         _081E30AE:
+            ;
         }
-        else if (r12->state == SLOT_STATE_SEND_LAST)
+        else if (NI_comm->state == SLOT_STATE_SEND_LAST)
         {
-            r12->state = SLOT_STATE_SEND_NULL;
+            NI_comm->state = SLOT_STATE_SEND_NULL;
         }
     }
-    if (r12->state != r9
-     || r12->n[r6->unk04] != sp00
-     || (r12->recvAckFlag[r6->unk04] >> r10) & 1)
+    if (NI_comm->state != state
+     || NI_comm->n[llsf_NI->phase] != n
+     || (NI_comm->recvAckFlag[llsf_NI->phase] >> bm_flag) & 1)
     {
-        r2 = REG_IME;
+        imeBak = REG_IME;
         REG_IME = 0;
-        gRfuStatic->recvRenewalFlag |= 16 << r10;
-        gRfuSlotStatusNI[r10]->send.failCounter = 0;
-        REG_IME = r2;
+        gRfuStatic->recvRenewalFlag |= 16 << bm_flag;
+        gRfuSlotStatusNI[bm_flag]->send.failCounter = 0;
+        REG_IME = imeBak;
     }
 }
 
-static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, const u8 *sp00)
+static void rfu_STC_NI_receive_Receiver(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *data_p)
 {
-    u16 r2;
-    u32 r7 = 0;
-    struct RfuSlotStatusNI *r4 = gRfuSlotStatusNI[r8];
-    struct NIComm *r5 = &r4->recv;
-    u16 r9 = r4->recv.state;
-    u8 r10 = r4->recv.n[r6->unk04];
+    u16 imeBak;
+    u32 state_check = 0;
+    struct RfuSlotStatusNI *slotStatus_NI = gRfuSlotStatusNI[bm_slot_id];
+    struct NIComm *recvSlot = &slotStatus_NI->recv;
+    u16 state = slotStatus_NI->recv.state;
+    u8 n = slotStatus_NI->recv.n[llsf_NI->phase];
 
-    if (r6->unk02 == 3)
+    if (llsf_NI->slotState == LCOM_NI_END)
     {
-        gRfuStatic->NIEndRecvFlag |= 1 << r8;
-        if (r4->recv.state == SLOT_STATE_RECEIVING)
+        gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id;
+        if (slotStatus_NI->recv.state == SLOT_STATE_RECEIVING)
         {
-            r4->recv.phase = 0;
-            r4->recv.n[0] = 0;
-            r4->recv.state = SLOT_STATE_RECV_LAST;
+            slotStatus_NI->recv.phase = 0;
+            slotStatus_NI->recv.n[0] = 0;
+            slotStatus_NI->recv.state = SLOT_STATE_RECV_LAST;
         }
     }
-    else if (r6->unk02 == 2)
+    else if (llsf_NI->slotState == LCOM_NI)
     {
-        if (r9 == SLOT_STATE_RECV_START && !r5->remainSize)
-            rfu_STC_NI_initSlot_asRecvDataEntity(r8, r5);
-        if (r5->state == SLOT_STATE_RECEIVING)
-            r7 = 1;
+        if (state == SLOT_STATE_RECV_START && !recvSlot->remainSize)
+            rfu_STC_NI_initSlot_asRecvDataEntity(bm_slot_id, recvSlot);
+        if (recvSlot->state == SLOT_STATE_RECEIVING)
+            state_check = 1;
     }
-    else if (r6->unk02 == 1)
+    else if (llsf_NI->slotState == LCOM_NI_START)
     {
-        if (r9 == SLOT_STATE_RECV_START)
+        if (state == SLOT_STATE_RECV_START)
         {
-            r7 = 1;
+            state_check = 1;
         }
         else
         {
-            rfu_STC_NI_initSlot_asRecvControllData(r8, r5);
-            if (r4->recv.state != SLOT_STATE_RECV_START)
+            rfu_STC_NI_initSlot_asRecvControllData(bm_slot_id, recvSlot);
+            if (slotStatus_NI->recv.state != SLOT_STATE_RECV_START)
                 return;
-            r7 = 1;
+            state_check = 1;
         }
     }
-    if (r7 != 0)
+    if (state_check != 0)
     {
-        if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3))
+        if (llsf_NI->n == ((recvSlot->n[llsf_NI->phase] + 1) & 3))
         {
-            gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->now_p[r6->unk04], r6->unk06);
-            if (r5->state == SLOT_STATE_RECEIVING)
-                r5->now_p[r6->unk04] += 3 * r5->payloadSize;
-            r5->remainSize -= r6->unk06;
-            r5->n[r6->unk04] = r6->unk05;
+            gRfuFixed->fastCopyPtr(&data_p, (u8 **)&recvSlot->now_p[llsf_NI->phase], llsf_NI->frame);
+            if (recvSlot->state == SLOT_STATE_RECEIVING)
+                recvSlot->now_p[llsf_NI->phase] += 3 * recvSlot->payloadSize;
+            recvSlot->remainSize -= llsf_NI->frame;
+            recvSlot->n[llsf_NI->phase] = llsf_NI->n;
         }
     }
-    if (r5->errorCode == 0)
+    if (recvSlot->errorCode == 0)
     {
-        r5->phase = r6->unk04;
-        if (r5->state != r9 || r5->n[r6->unk04] != r10 || r5->n[r6->unk04] == r6->unk05)
+        recvSlot->phase = llsf_NI->phase;
+        if (recvSlot->state != state || recvSlot->n[llsf_NI->phase] != n || recvSlot->n[llsf_NI->phase] == llsf_NI->n)
         {
-            r2 = REG_IME;
+            imeBak = REG_IME;
             REG_IME = 0;
-            gRfuStatic->recvRenewalFlag |= 1 << r8;
-            r5->failCounter = 0;
-            REG_IME = r2;
+            gRfuStatic->recvRenewalFlag |= 1 << bm_slot_id;
+            recvSlot->failCounter = 0;
+            REG_IME = imeBak;
         }
     }
 }
 
-static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2)
+static void rfu_STC_NI_initSlot_asRecvControllData(u8 bm_slot_id, struct NIComm *NI_comm)
 {
-    u8 *r1;
-    u32 r5;
-    u8 r6;
+    u8 *llFrameSize_p;
+    u32 llFrameSize;
+    u8 bm_slot_flag;
 
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
     {
-        r5 = 3;
-        r1 = &gRfuLinkStatus->remainLLFrameSizeParent;
+        llFrameSize = 3;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent;
     }
     else
     {
-        r5 = 2;
-        r1 = &gRfuLinkStatus->remainLLFrameSizeChild[r4];
+        llFrameSize = 2;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id];
     }
-    r6 = 1 << r4;
-    if (r2->state == 0)
+    bm_slot_flag = 1 << bm_slot_id;
+    if (NI_comm->state == 0)
     {
-        if (*r1 < r5)
+        if (*llFrameSize_p < llFrameSize)
         {
-            r2->state = SLOT_STATE_RECV_IGNORE;
-            r2->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE;
-            gRfuStatic->recvErrorFlag |= r6;
+            NI_comm->state = SLOT_STATE_RECV_IGNORE;
+            NI_comm->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE;
+            gRfuStatic->recvErrorFlag |= bm_slot_flag;
         }
         else
         {
-            r2->errorCode = 0;
-            *r1 -= r5;
-            r2->now_p[0] = &r2->dataType;
-            r2->remainSize = 7;
-            r2->ack = 1;
-            r2->payloadSize = 0;
-            r2->bmSlot = r6;
-            r2->state = SLOT_STATE_RECV_START;
-            gRfuLinkStatus->recvSlotNIFlag |= r6;
+            NI_comm->errorCode = 0;
+            *llFrameSize_p -= llFrameSize;
+            NI_comm->now_p[0] = &NI_comm->dataType;
+            NI_comm->remainSize = 7;
+            NI_comm->ack = 1;
+            NI_comm->payloadSize = 0;
+            NI_comm->bmSlot = bm_slot_flag;
+            NI_comm->state = SLOT_STATE_RECV_START;
+            gRfuLinkStatus->recvSlotNIFlag |= bm_slot_flag;
         }
     }
 }
 
-static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4)
+static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 bm_slot_id, struct NIComm *NI_comm)
 {
-    u8 r1, r3;
+    u8 bm_slot_flag, win_id;
 
-    if (r4->dataType == 1)
+    if (NI_comm->dataType == 1)
     {
-        r4->now_p[0] = (void *)&gRfuLinkStatus->partner[r5].serialNo;
+        NI_comm->now_p[0] = (void *)&gRfuLinkStatus->partner[bm_slot_id].serialNo;
     }
     else
     {
-        if (r4->dataSize > gRfuSlotStatusNI[r5]->recvBufferSize)
+        if (NI_comm->dataSize > gRfuSlotStatusNI[bm_slot_id]->recvBufferSize)
         {
-            r1 = 1 << r5;
-            gRfuStatic->recvErrorFlag |= r1;
-            gRfuLinkStatus->recvSlotNIFlag &= ~r1;
-            r4->errorCode = ERR_RECV_BUFF_OVER;
-            r4->state = SLOT_STATE_RECV_FAILED;
-            rfu_STC_releaseFrame(r5, 1, r4);
+            bm_slot_flag = 1 << bm_slot_id;
+            gRfuStatic->recvErrorFlag |= bm_slot_flag;
+            gRfuLinkStatus->recvSlotNIFlag &= ~bm_slot_flag;
+            NI_comm->errorCode = ERR_RECV_BUFF_OVER;
+            NI_comm->state = SLOT_STATE_RECV_FAILED;
+            rfu_STC_releaseFrame(bm_slot_id, 1, NI_comm);
             return;
         }
-        r4->now_p[0] = gRfuSlotStatusNI[r5]->recvBuffer;
+        NI_comm->now_p[0] = gRfuSlotStatusNI[bm_slot_id]->recvBuffer;
     }
-    for (r3 = 0; r3 < WINDOW_COUNT; ++r3)
+    for (win_id = 0; win_id < WINDOW_COUNT; ++win_id)
     {
-        r4->n[r3] = 0;
-        r4->now_p[r3] = &r4->now_p[0][r4->payloadSize * r3];
+        NI_comm->n[win_id] = 0;
+        NI_comm->now_p[win_id] = &NI_comm->now_p[0][NI_comm->payloadSize * win_id];
     }
-    r4->remainSize = r4->dataSize;
-    r4->state = SLOT_STATE_RECEIVING;
+    NI_comm->remainSize = NI_comm->dataSize;
+    NI_comm->state = SLOT_STATE_RECEIVING;
 }
 
 static void rfu_NI_checkCommFailCounter(void)
 {
-    u16 r12;
-    u32 r7;
-    u8 r2, r3;
+    u16 imeBak;
+    u32 recvRenewalFlag;
+    u8 bm_slot_flag, bm_slot_id;
 
     if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag)
     {
-        r12 = REG_IME;
+        imeBak = REG_IME;
         REG_IME = 0;
-        r7 = gRfuStatic->recvRenewalFlag >> 4;
-        for (r3 = 0; r3 < RFU_CHILD_MAX; ++r3)
+        recvRenewalFlag = gRfuStatic->recvRenewalFlag >> 4;
+        for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
         {
-            r2 = 1 << r3;
-            if (gRfuLinkStatus->sendSlotNIFlag & r2
-             && !(gRfuStatic->recvRenewalFlag & r2))
-                ++gRfuSlotStatusNI[r3]->send.failCounter;
-            if (gRfuLinkStatus->recvSlotNIFlag & r2
-             && !(r7 & r2))
-                ++gRfuSlotStatusNI[r3]->recv.failCounter;
+            bm_slot_flag = 1 << bm_slot_id;
+            if (gRfuLinkStatus->sendSlotNIFlag & bm_slot_flag
+             && !(gRfuStatic->recvRenewalFlag & bm_slot_flag))
+                ++gRfuSlotStatusNI[bm_slot_id]->send.failCounter;
+            if (gRfuLinkStatus->recvSlotNIFlag & bm_slot_flag
+             && !(recvRenewalFlag & bm_slot_flag))
+                ++gRfuSlotStatusNI[bm_slot_id]->recv.failCounter;
         }
         gRfuStatic->recvRenewalFlag = 0;
-        REG_IME = r12;
+        REG_IME = imeBak;
     }
 }
 
diff --git a/src/librfu_sio32id.c b/src/librfu_sio32id.c
index fc5701986..b6623540f 100644
--- a/src/librfu_sio32id.c
+++ b/src/librfu_sio32id.c
@@ -4,44 +4,56 @@ static void Sio32IDIntr(void);
 static void Sio32IDInit(void);
 static s32 Sio32IDMain(void);
 
+struct RfuSIO32Id
+{
+    u8 MS_mode;
+    u8 state;
+    u16 count;
+    u16 send_id;
+    u16 recv_id;
+    u16 unk8; // unused
+    u16 lastId;
+};
+
 struct RfuSIO32Id gRfuSIO32Id;
 
 static const u16 Sio32ConnectionData[] = { 0x494e, 0x544e, 0x4e45, 0x4f44 }; // NINTENDO
 static const char Sio32IDLib_Var[] = "Sio32ID_030820";
 
-s32 AgbRFU_checkID(u8 r5)
+s32 AgbRFU_checkID(u8 maxTries)
 {
-    u16 r8;
-    vu16 *r4;
-    s32 r6;
+    u16 ieBak;
+    vu16 *regTMCNTL;
+    s32 id;
 
+    // Interrupts must be enabled
     if (REG_IME == 0)
         return -1;
-    r8 = REG_IE;
+    ieBak = REG_IE;
     gSTWIStatus->state = 10;
     STWI_set_Callback_ID(Sio32IDIntr);
     Sio32IDInit();
-    r4 = &REG_TMCNT_L(gSTWIStatus->timerSelect);
-    r5 *= 8;
-    while (--r5 != 0xFF)
+    regTMCNTL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
+    maxTries *= 8;
+    while (--maxTries != 0xFF)
     {
-        r6 = Sio32IDMain();
-        if (r6 != 0)
+        id = Sio32IDMain();
+        if (id != 0)
             break;
-        r4[1] = 0;
-        r4[0] = 0;
-        r4[1] = TIMER_1024CLK | TIMER_ENABLE;
-        while (r4[0] < 32)
+        regTMCNTL[1] = 0;
+        regTMCNTL[0] = 0;
+        regTMCNTL[1] = TIMER_1024CLK | TIMER_ENABLE;
+        while (regTMCNTL[0] < 32)
             ;
-        r4[1] = 0;
-        r4[0] = 0;
+        regTMCNTL[1] = 0;
+        regTMCNTL[0] = 0;
     }
     REG_IME = 0;
-    REG_IE = r8;
+    REG_IE = ieBak;
     REG_IME = 1;
     gSTWIStatus->state = 0;
     STWI_set_Callback_ID(NULL);
-    return r6;
+    return id;
 }
 
 static void Sio32IDInit(void)
@@ -58,107 +70,105 @@ static void Sio32IDInit(void)
 
 static s32 Sio32IDMain(void)
 {
-    u8 r12;
-
-    switch (r12 = gRfuSIO32Id.unk1)
+    switch (gRfuSIO32Id.state)
     {
     case 0:
-        gRfuSIO32Id.unk0 = 1;
+        gRfuSIO32Id.MS_mode = AGB_CLK_MASTER;
         REG_SIOCNT |= SIO_38400_BPS;
-        REG_IME = r12;
+        REG_IME = 0;
         REG_IE |= INTR_FLAG_SERIAL;
         REG_IME = 1;
-        gRfuSIO32Id.unk1 = 1;
+        gRfuSIO32Id.state = 1;
         *(vu8 *)&REG_SIOCNT |= SIO_ENABLE;
         break;
     case 1:
-        if (gRfuSIO32Id.unkA == 0)
+        if (gRfuSIO32Id.lastId == 0)
         {
-            if (gRfuSIO32Id.unk0 == 1)
+            if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER)
             {
-                if (gRfuSIO32Id.unk2 == 0)
+                if (gRfuSIO32Id.count == 0)
                 {
-                    REG_IME = gRfuSIO32Id.unk2;
+                    REG_IME = 0;
                     REG_SIOCNT |= SIO_ENABLE;
-                    REG_IME = r12;
+                    REG_IME = 1;
                 }
             }
-            else if (gRfuSIO32Id.unk4 != 0x8001 && !gRfuSIO32Id.unk2)
+            else if (gRfuSIO32Id.send_id != RFU_ID && !gRfuSIO32Id.count)
             {
-                REG_IME = gRfuSIO32Id.unk2;
+                REG_IME = 0;
                 REG_IE &= ~INTR_FLAG_SERIAL;
-                REG_IME = r12;
-                REG_SIOCNT = gRfuSIO32Id.unk2;
+                REG_IME = 1;
+                REG_SIOCNT = 0;
                 REG_SIOCNT = SIO_32BIT_MODE;
                 REG_IF = INTR_FLAG_SERIAL;
                 REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE;
-                REG_IME = gRfuSIO32Id.unk2;
+                REG_IME = 0;
                 REG_IE |= INTR_FLAG_SERIAL;
-                REG_IME = r12;
+                REG_IME = 1;
             }
             break;
         }
         else
         {
-            gRfuSIO32Id.unk1 = 2;
+            gRfuSIO32Id.state = 2;
             // fallthrough
         }
     default:
-        return gRfuSIO32Id.unkA;
+        return gRfuSIO32Id.lastId;
     }
     return 0;
 }
 
 static void Sio32IDIntr(void)
 {
-    u32 r5;
-    u16 r0;
+    u32 regSIODATA32;
+    u16 delay;
 #ifndef NONMATCHING
-    register u32 r1 asm("r1");
-    register u16 r0_ asm("r0");
+    register u32 rfuSIO32IdUnk0_times_16 asm("r1");
+    register u16 negRfuSIO32IdUnk6 asm("r0");
 #else
-    u32 r1;
-    u16 r0_;
+    u32 rfuSIO32IdUnk0_times_16;
+    u16 negRfuSIO32IdUnk6;
 #endif
 
-    r5 = REG_SIODATA32;
-    if (gRfuSIO32Id.unk0 != 1)
+    regSIODATA32 = REG_SIODATA32;
+    if (gRfuSIO32Id.MS_mode != AGB_CLK_MASTER)
         REG_SIOCNT |= SIO_ENABLE;
-    r1 = 16 * gRfuSIO32Id.unk0; // to handle side effect of inline asm
-    r1 = (r5 << r1) >> 16;
-    r5 = (r5 << 16 * (1 - gRfuSIO32Id.unk0)) >> 16;
-    if (gRfuSIO32Id.unkA == 0)
+    rfuSIO32IdUnk0_times_16 = 16 * gRfuSIO32Id.MS_mode; // to handle side effect of inline asm
+    rfuSIO32IdUnk0_times_16 = (regSIODATA32 << rfuSIO32IdUnk0_times_16) >> 16;
+    regSIODATA32 = (regSIODATA32 << 16 * (1 - gRfuSIO32Id.MS_mode)) >> 16;
+    if (gRfuSIO32Id.lastId == 0)
     {
-        if (r1 == gRfuSIO32Id.unk6)
+        if (rfuSIO32IdUnk0_times_16 == gRfuSIO32Id.recv_id)
         {
-            if (gRfuSIO32Id.unk2 > 3)
+            if (gRfuSIO32Id.count > 3)
             {
-                gRfuSIO32Id.unkA = r5;
+                gRfuSIO32Id.lastId = regSIODATA32;
             }
-            else if (r1 == (u16)~gRfuSIO32Id.unk4)
+            else if (rfuSIO32IdUnk0_times_16 == (u16)~gRfuSIO32Id.send_id)
             {
-                r0_ = ~gRfuSIO32Id.unk6;
-                if (r5 == r0_)
-                    ++gRfuSIO32Id.unk2;
+                negRfuSIO32IdUnk6 = ~gRfuSIO32Id.recv_id;
+                if (regSIODATA32 == negRfuSIO32IdUnk6)
+                    ++gRfuSIO32Id.count;
             }
         }
         else
         {
-            gRfuSIO32Id.unk2 = gRfuSIO32Id.unkA;
+            gRfuSIO32Id.count = 0;
         }
     }
-    if (gRfuSIO32Id.unk2 < 4)
-        gRfuSIO32Id.unk4 = *(gRfuSIO32Id.unk2 + Sio32ConnectionData);
+    if (gRfuSIO32Id.count < 4)
+        gRfuSIO32Id.send_id = *(gRfuSIO32Id.count + Sio32ConnectionData);
     else
-        gRfuSIO32Id.unk4 = 0x8001;
-    gRfuSIO32Id.unk6 = ~r5;
-    REG_SIODATA32 = (gRfuSIO32Id.unk4 << 16 * (1 - gRfuSIO32Id.unk0))
-                  + (gRfuSIO32Id.unk6 << 16 * gRfuSIO32Id.unk0);
-    if (gRfuSIO32Id.unk0 == 1 && (gRfuSIO32Id.unk2 || r5 == 0x494E))
+        gRfuSIO32Id.send_id = RFU_ID;
+    gRfuSIO32Id.recv_id = ~regSIODATA32;
+    REG_SIODATA32 = (gRfuSIO32Id.send_id << 16 * (1 - gRfuSIO32Id.MS_mode))
+                  + (gRfuSIO32Id.recv_id << 16 * gRfuSIO32Id.MS_mode);
+    if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER && (gRfuSIO32Id.count != 0 || regSIODATA32 == 0x494e))
     {
-        for (r0 = 0; r0 < 600; ++r0)
+        for (delay = 0; delay < 600; ++delay)
             ;
-        if (gRfuSIO32Id.unkA == 0)
+        if (gRfuSIO32Id.lastId == 0)
             REG_SIOCNT |= SIO_ENABLE;
     }
 }
diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c
index b88f21737..0287b358a 100644
--- a/src/librfu_stwi.c
+++ b/src/librfu_stwi.c
@@ -28,8 +28,8 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b
     }
     gSTWIStatus->rxPacket = &interruptStruct->rxPacketAlloc;
     gSTWIStatus->txPacket = &interruptStruct->txPacketAlloc;
-    gSTWIStatus->msMode = 1;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->msMode = AGB_CLK_MASTER;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     gSTWIStatus->ackLength = 0;
@@ -39,7 +39,7 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b
     gSTWIStatus->timerActive = 0;
     gSTWIStatus->error = 0;
     gSTWIStatus->recoveryCount = 0;
-    gSTWIStatus->unk_2c = 0;
+    gSTWIStatus->sending = 0;
     REG_RCNT = 0x100; // TODO: mystery bit? 
     REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
     STWI_init_Callback_M();
@@ -71,7 +71,7 @@ void AgbRFU_SoftReset(void)
     *timerH = 3;
     REG_RCNT = 0x80A0;
     REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     gSTWIStatus->reqActiveCommand = 0;
@@ -81,9 +81,9 @@ void AgbRFU_SoftReset(void)
     gSTWIStatus->timerState = 0;
     gSTWIStatus->timerActive = 0;
     gSTWIStatus->error = 0;
-    gSTWIStatus->msMode = 1;
+    gSTWIStatus->msMode = AGB_CLK_MASTER;
     gSTWIStatus->recoveryCount = 0;
-    gSTWIStatus->unk_2c = 0;
+    gSTWIStatus->sending = 0;
 }
 
 void STWI_set_MS_mode(u8 mode)
@@ -131,12 +131,12 @@ void STWI_set_Callback_S(void (*callbackS)(u16))
 
 void STWI_set_Callback_ID(void (*func)(void)) // name in SDK, but is actually setting a function pointer
 {
-    gSTWIStatus->unk_20 = func;
+    gSTWIStatus->callbackID = func;
 }
 
 u16 STWI_poll_CommandEnd(void)
 {
-    while (gSTWIStatus->unk_2c == TRUE)
+    while (gSTWIStatus->sending == 1)
         ;
     return gSTWIStatus->error;
 }
@@ -195,7 +195,7 @@ void STWI_send_ConfigStatusREQ(void)
     }
 }
 
-void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data)
+void STWI_send_GameConfigREQ(const u8 *serial_gname, const u8 *uname)
 {
     u8 *packetBytes;
     s32 i;
@@ -203,29 +203,28 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data)
     if (!STWI_init(ID_GAME_CONFIG_REQ))
     {
         gSTWIStatus->reqLength = 6;
-        // TODO: what is unk1
         packetBytes = gSTWIStatus->txPacket->rfuPacket8.data;
         packetBytes += sizeof(u32);
-        *(u16 *)packetBytes = *(u16 *)unk1;
+        *(u16 *)packetBytes = *(u16 *)serial_gname;
         packetBytes += sizeof(u16);
-        unk1 += sizeof(u16);
+        serial_gname += sizeof(u16);
         for (i = 0; i < 14; ++i)
         {
-            *packetBytes = *unk1;
+            *packetBytes = *serial_gname;
             ++packetBytes;
-            ++unk1;
+            ++serial_gname;
         }
         for (i = 0; i < 8; ++i)
         {
-            *packetBytes = *data;
+            *packetBytes = *uname;
             ++packetBytes;
-            ++data;
+            ++uname;
         }
         STWI_start_Command();
     }
 }
 
-void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
+void STWI_send_SystemConfigREQ(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
 {
     if (!STWI_init(ID_SYSTEM_CONFIG_REQ))
     {
@@ -234,9 +233,9 @@ void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
         gSTWIStatus->reqLength = 1;
         packetBytes = gSTWIStatus->txPacket->rfuPacket8.data;
         packetBytes += sizeof(u32);
-        *packetBytes++ = unk3;
-        *packetBytes++ = unk2;
-        *(u16*)packetBytes = unk1;
+        *packetBytes++ = mcTimer;
+        *packetBytes++ = maxMFrame;
+        *(u16*)packetBytes = availSlotFlag;
         STWI_start_Command();
     }
 }
@@ -499,20 +498,17 @@ static void STWI_intr_timer(void)
         STWI_stop_timer();
         STWI_reset_ClockCounter();
         if (gSTWIStatus->callbackM != NULL)
-            gSTWIStatus->callbackM(255, 0);
+            gSTWIStatus->callbackM(ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ, 0);
         break;
     }
 }
 
-static void STWI_set_timer(u8 unk)
+static void STWI_set_timer(u8 count)
 {
-    vu16 *timerL;
-    vu16 *timerH;
-
-    timerL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
-    timerH = &REG_TMCNT_H(gSTWIStatus->timerSelect);
+    vu16 *timerL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
+    vu16 *timerH = &REG_TMCNT_H(gSTWIStatus->timerSelect);
     REG_IME = 0;
-    switch (unk)
+    switch (count)
     {
     case 50:
         *timerL = 0xFCCB;
@@ -543,25 +539,31 @@ static void STWI_stop_timer(void)
     REG_TMCNT_H(gSTWIStatus->timerSelect) = 0;
 }
 
+/*
+ * Set up STWI to send REQ. Returns 1 if error (see below).
+ */
 static u16 STWI_init(u8 request)
 {
     if (!REG_IME)
     {
+        // Can't start sending if IME is disabled.
         gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error);
         return TRUE;
     }
-    else if (gSTWIStatus->unk_2c == TRUE)
+    else if (gSTWIStatus->sending == 1)
     {
+        // Already sending something. Cancel and error.
         gSTWIStatus->error = ERR_REQ_CMD_SENDING;
-        gSTWIStatus->unk_2c = FALSE;
+        gSTWIStatus->sending = 0;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error);
         return TRUE;
     }
-    else if(!gSTWIStatus->msMode)
+    else if (gSTWIStatus->msMode == AGB_CLK_SLAVE)
     {
+        // Can't send if clock slave
         gSTWIStatus->error = ERR_REQ_CMD_CLOCK_SLAVE;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error, gSTWIStatus);
@@ -569,9 +571,10 @@ static u16 STWI_init(u8 request)
     }
     else
     {
-        gSTWIStatus->unk_2c = TRUE;
+        // Good to go, start sending
+        gSTWIStatus->sending = 1;
         gSTWIStatus->reqActiveCommand = request;
-        gSTWIStatus->state = 0;
+        gSTWIStatus->state = 0; // master send req
         gSTWIStatus->reqLength = 0;
         gSTWIStatus->reqNext = 0;
         gSTWIStatus->ackLength = 0;
@@ -595,7 +598,7 @@ static s32 STWI_start_Command(void)
     // but the cast here is required to avoid register issue
     *(u32 *)gSTWIStatus->txPacket->rfuPacket8.data = 0x99660000 | (gSTWIStatus->reqLength << 8) | gSTWIStatus->reqActiveCommand;
     REG_SIODATA32 = gSTWIStatus->txPacket->rfuPacket32.command;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqNext = 1;
     imeTemp = REG_IME;
     REG_IME = 0;
@@ -608,7 +611,7 @@ static s32 STWI_start_Command(void)
 
 static s32 STWI_restart_Command(void)
 {
-    if (gSTWIStatus->recoveryCount <= 1)
+    if (gSTWIStatus->recoveryCount < 2)
     {
         ++gSTWIStatus->recoveryCount;
         STWI_start_Command();
@@ -618,17 +621,17 @@ static s32 STWI_restart_Command(void)
         if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_UNK35_REQ || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)
         {
             gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT;
-            gSTWIStatus->unk_2c = 0;
+            gSTWIStatus->sending = 0;
             if (gSTWIStatus->callbackM != NULL)
                 gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error);
         }
         else
         {
             gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT;
-            gSTWIStatus->unk_2c = 0;
+            gSTWIStatus->sending = 0;
             if (gSTWIStatus->callbackM != NULL)
                 gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error);
-            gSTWIStatus->state = 4; // TODO: what's 4
+            gSTWIStatus->state = 4; // error
         }
     }
     return 0;
@@ -636,7 +639,7 @@ static s32 STWI_restart_Command(void)
 
 static s32 STWI_reset_ClockCounter(void)
 {
-    gSTWIStatus->state = 5; // TODO: what is 5
+    gSTWIStatus->state = 5; // slave receive req init
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     REG_SIODATA32 = (1 << 31);
diff --git a/src/link.c b/src/link.c
index dfb21f126..cb46a50ff 100644
--- a/src/link.c
+++ b/src/link.c
@@ -82,14 +82,14 @@ u32 gFiller_3003EC0;
 u16 gLinkHeldKeys;
 u16 gRecvCmds[MAX_RFU_PLAYERS][CMD_LENGTH];
 u32 gLinkStatus;
-bool8 gUnknown_3003F24;
+bool8 gLinkAllAcked5FFF;
 bool8 gUnknown_3003F28;
-bool8 gUnknown_3003F2C[MAX_LINK_PLAYERS];
-bool8 gUnknown_3003F30[MAX_LINK_PLAYERS];
-u16 gUnknown_3003F34;
+bool8 gLinkCommand2FFEAck[MAX_LINK_PLAYERS];
+bool8 gLinkCommand5FFFAck[MAX_LINK_PLAYERS];
+u16 gLinkCmd5FFFparam;
 u8 gSuppressLinkErrorMessage;
-bool8 gWirelessCommType;
-bool8 gSavedLinkPlayerCount;
+u8 gWirelessCommType;
+u8 gSavedLinkPlayerCount;
 u16 gSendCmd[CMD_LENGTH];
 u8 gSavedMultiplayerId;
 bool8 gReceivedRemoteLinkPlayers;
@@ -123,8 +123,8 @@ EWRAM_DATA struct {
     u8 lastSendQueueCount;
     u8 unk_06;
 } sLinkErrorBuffer = {};
-EWRAM_DATA u16 gUnknown_202285C = 0;
-EWRAM_DATA void *gUnknown_2022860 = NULL;
+static EWRAM_DATA u16 sStartSend5FFFfailures = 0;
+static EWRAM_DATA void *sLinkErrorBgTilemapBuffer = NULL;
 
 static void InitLocalLinkPlayer(void);
 static void sub_800978C(void);
@@ -142,13 +142,13 @@ static u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size);
 static void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2);
 static void LinkCB_RequestPlayerDataExchange(void);
 static void Task_PrintTestData(u8 taskId);
-static void sub_800AB0C(void);
-static void sub_800AB38(void);
-static void sub_800ABD4(void);
-static void sub_800AC00(void);
+static void LinkCB_BuildCommand5FFF(void);
+static void LinkCB_WaitAckCommand5FFF(void);
+static void LinkFunc_Send2FFE_1(void);
+static void LinkFunc_Send2FFE_2(void);
 static void CheckErrorStatus(void);
 static void CB2_PrintErrorMessage(void);
-static void sub_800B210(void);
+static void SetWirelessCommType0(void);
 static void DisableSerial(void);
 static void EnableSerial(void);
 static bool8 IsSioMultiMaster(void);
@@ -232,16 +232,16 @@ bool8 IsWirelessAdapterConnected(void)
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return FALSE;
 
-    sub_800B1F4();
+    SetWirelessCommType1();
     sub_80F86F4();
     sub_80FB128(TRUE);
-    if (sub_80FD3A4() == RFU_ID)
+    if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID)
     {
         rfu_REQ_stopMode();
         rfu_waitREQComplete();
         return TRUE;
     }
-    sub_800B210();
+    SetWirelessCommType0();
     CloseLink();
     RestoreSerialTimer3IntrHandlers();
     return FALSE;
@@ -379,8 +379,8 @@ void OpenLink(void)
         ResetBlockSend();
         gUnknown_3000E4C = 0;
         gUnknown_3003F28 = FALSE;
-        gUnknown_3003F24 = FALSE;
-        gUnknown_3003F34 = 0;
+        gLinkAllAcked5FFF = FALSE;
+        gLinkCmd5FFFparam = 0;
         CreateTask(Task_TriggerHandshake, 2);
     }
     else
@@ -391,8 +391,8 @@ void OpenLink(void)
     for (i = 0; i < MAX_LINK_PLAYERS; i++)
     {
         gRemoteLinkPlayersNotReceived[i] = TRUE;
-        gUnknown_3003F30[i] = FALSE;
-        gUnknown_3003F2C[i] = FALSE;
+        gLinkCommand5FFFAck[i] = FALSE;
+        gLinkCommand2FFEAck[i] = FALSE;
     }
 }
 
@@ -401,7 +401,7 @@ void CloseLink(void)
     gReceivedRemoteLinkPlayers = FALSE;
     if (gWirelessCommType)
     {
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
     }
     gLinkOpen = FALSE;
     DisableSerial();
@@ -468,7 +468,7 @@ void LinkTestProcessKeyInput(void)
     }
     if (JOY_NEW(SELECT_BUTTON))
     {
-        sub_800AAC0();
+        Link_TryStartSend5FFF();
     }
     if (gLinkTestDebugValuesEnabled)
     {
@@ -613,7 +613,7 @@ void ProcessRecvCmds(u8 unused)
                         linkPlayer->name[9] = 0;
                         linkPlayer->name[8] = 0;
                     }
-                    sub_800B284(linkPlayer);
+                    IntlConvertLinkPlayerName(linkPlayer);
                     if (strcmp(block->magic1, sASCIIGameFreakInc) != 0
                         || strcmp(block->magic2, sASCIIGameFreakInc) != 0)
                     {
@@ -632,10 +632,10 @@ void ProcessRecvCmds(u8 unused)
         }
             break;
         case LINKCMD_0x5FFF:
-            gUnknown_3003F30[i] = TRUE;
+            gLinkCommand5FFFAck[i] = TRUE;
             break;
         case LINKCMD_0x2FFE:
-            gUnknown_3003F2C[i] = TRUE;
+            gLinkCommand2FFEAck[i] = TRUE;
             break;
         case LINKCMD_0xAAAA:
             sub_800A3CC();
@@ -701,7 +701,7 @@ void BuildSendCmd(u16 command)
         break;
     case LINKCMD_0x5FFF:
         gSendCmd[0] = LINKCMD_0x5FFF;
-        gSendCmd[1] = gUnknown_3003F34;
+        gSendCmd[1] = gLinkCmd5FFFparam;
         break;
     case LINKCMD_0x5566:
         gSendCmd[0] = LINKCMD_0x5566;
@@ -721,7 +721,7 @@ void sub_8009FE8(void)
 {
     if (gWirelessCommType)
     {
-        sub_80F9828();
+        StartSendingKeysToRfu();
     }
     gLinkCallback = sub_800A040;
 }
@@ -796,7 +796,7 @@ u8 GetLinkPlayerDataExchangeStatusTimed(int lower, int upper)
         if (lower > cmpVal || cmpVal > upper)
         {
             sPlayerDataExchangeStatus = EXCHANGE_STAT_6;
-            return 6;
+            return EXCHANGE_STAT_6;
         }
         else
         {
@@ -1006,15 +1006,15 @@ bool8 SendBlock(u8 unused, const void *src, u16 size)
     return InitBlockSend(src, size);
 }
 
-bool8 sub_800A474(u8 a0)
+bool8 sub_800A474(u8 blockRequestType)
 {
     if (gWirelessCommType == 1)
     {
-        return sub_80FA0F8(a0);
+        return sub_80FA0F8(blockRequestType);
     }
     if (gLinkCallback == NULL)
     {
-        gBlockRequestType = a0;
+        gBlockRequestType = blockRequestType;
         BuildSendCmd(LINKCMD_0xCCCC);
         return TRUE;
     }
@@ -1312,54 +1312,54 @@ u8 sub_800AA74(void)
     return gUnknown_3000E50;
 }
 
-void sub_800AA80(u16 a0)
+void Link_StartSend5FFFwithParam(u16 a0)
 {
     if (gWirelessCommType == 1)
     {
-        task_add_05_task_del_08FA224_when_no_RfuFunc();
+        Rfu_BeginBuildAndSendCommand5F();
     }
     else
     {
         if (gLinkCallback == NULL)
         {
-            gLinkCallback = sub_800AB0C;
-            gUnknown_3003F24 = FALSE;
-            gUnknown_3003F34 = a0;
+            gLinkCallback = LinkCB_BuildCommand5FFF;
+            gLinkAllAcked5FFF = FALSE;
+            gLinkCmd5FFFparam = a0;
         }
     }
 }
 
-void sub_800AAC0(void)
+void Link_TryStartSend5FFF(void)
 {
     if (gWirelessCommType == 1)
     {
-        task_add_05_task_del_08FA224_when_no_RfuFunc();
+        Rfu_BeginBuildAndSendCommand5F();
     }
     else
     {
         if (gLinkCallback != NULL)
         {
-            gUnknown_202285C++;
+            sStartSend5FFFfailures++;
         }
         else
         {
-            gLinkCallback = sub_800AB0C;
-            gUnknown_3003F24 = FALSE;
-            gUnknown_3003F34 = 0;
+            gLinkCallback = LinkCB_BuildCommand5FFF;
+            gLinkAllAcked5FFF = FALSE;
+            gLinkCmd5FFFparam = 0;
         }
     }
 }
 
-static void sub_800AB0C(void)
+static void LinkCB_BuildCommand5FFF(void)
 {
     if (gLastRecvQueueCount == 0)
     {
         BuildSendCmd(LINKCMD_0x5FFF);
-        gLinkCallback = sub_800AB38;
+        gLinkCallback = LinkCB_WaitAckCommand5FFF;
     }
 }
 
-static void sub_800AB38(void)
+static void LinkCB_WaitAckCommand5FFF(void)
 {
     int i;
     unsigned count;
@@ -1369,7 +1369,7 @@ static void sub_800AB38(void)
     count = 0;
     for (i = 0; i < linkPlayerCount; i++)
     {
-        if (gUnknown_3003F30[i])
+        if (gLinkCommand5FFFAck[i])
         {
             count++;
         }
@@ -1380,36 +1380,36 @@ static void sub_800AB38(void)
         gLinkVSyncDisabled = TRUE;
         CloseLink();
         gLinkCallback = NULL;
-        gUnknown_3003F24 = TRUE;
+        gLinkAllAcked5FFF = TRUE;
     }
 }
 
-void sub_800AB9C(void)
+void PrepareSendLinkCmd2FFE_or_RfuCmd6600(void)
 {
     if (gWirelessCommType == 1)
     {
-        sub_80FA42C();
+        LinkRfu_SetRfuFuncToSend6600();
     }
     else
     {
         if (gLinkCallback == NULL)
         {
-            gLinkCallback = sub_800ABD4;
+            gLinkCallback = LinkFunc_Send2FFE_1;
         }
-        gUnknown_3003F24 = FALSE;
+        gLinkAllAcked5FFF = FALSE;
     }
 }
 
-static void sub_800ABD4(void)
+static void LinkFunc_Send2FFE_1(void)
 {
     if (gLastRecvQueueCount == 0)
     {
         BuildSendCmd(LINKCMD_0x2FFE);
-        gLinkCallback = sub_800AC00;
+        gLinkCallback = LinkFunc_Send2FFE_2;
     }
 }
 
-static void sub_800AC00(void)
+static void LinkFunc_Send2FFE_2(void)
 {
     u8 i;
     u8 linkPlayerCount;
@@ -1417,7 +1417,7 @@ static void sub_800AC00(void)
     linkPlayerCount = GetLinkPlayerCount();
     for (i = 0; i < linkPlayerCount; i++)
     {
-        if (!gUnknown_3003F2C[i])
+        if (!gLinkCommand2FFEAck[i])
         {
             break;
         }
@@ -1426,7 +1426,7 @@ static void sub_800AC00(void)
     {
         for (i = 0; i < MAX_LINK_PLAYERS; i++)
         {
-            gUnknown_3003F2C[i] = FALSE;
+            gLinkCommand2FFEAck[i] = FALSE;
         }
         gLinkCallback = NULL;
     }
@@ -1448,7 +1448,7 @@ static void CheckErrorStatus(void)
     }
 }
 
-void sub_800ACBC(u32 status, u8 lastSendQueueCount, u8 lastRecvQueueCount, u8 unk_06)
+void SetLinkErrorFromRfu(u32 status, u8 lastSendQueueCount, u8 lastRecvQueueCount, u8 unk_06)
 {
     sLinkErrorBuffer.status = status;
     sLinkErrorBuffer.lastSendQueueCount = lastSendQueueCount;
@@ -1477,12 +1477,12 @@ void CB2_LinkError(void)
         {
             gWirelessCommType = 3;
         }
-        sub_80F85F8();
+        ResetLinkRfuGFLayer();
     }
     SetVBlankCallback(sub_800978C);
-    ResetBgsAndClearDma3BusyFlags(0);
+    ResetBgsAndClearDma3BusyFlags(FALSE);
     InitBgsFromTemplates(0, sLinkErrorBgTemplates, 2);
-    gUnknown_2022860 = tilemapBuffer = malloc(0x800);
+    sLinkErrorBgTilemapBuffer = tilemapBuffer = malloc(0x800);
     SetBgTilemapBuffer(1, tilemapBuffer);
     if (InitWindows(sLinkErrorWindowTemplates))
     {
@@ -1603,12 +1603,12 @@ static void CB2_PrintErrorMessage(void)
 
 bool8 GetSioMultiSI(void)
 {
-    return (REG_SIOCNT & 0x04) != 0;
+    return (REG_SIOCNT & SIO_MULTI_SI) != 0;
 }
 
 static bool8 IsSioMultiMaster(void)
 {
-    return (REG_SIOCNT & 0x8) && !(REG_SIOCNT & 0x04);
+    return (REG_SIOCNT & SIO_MULTI_SD) && !(REG_SIOCNT & SIO_MULTI_SI);
 }
 
 bool8 IsLinkConnectionEstablished(void)
@@ -1626,7 +1626,7 @@ bool8 HasLinkErrorOccurred(void)
     return gLinkErrorOccurred;
 }
 
-void sub_800B0B4(void)
+void PrepareLocalLinkPlayerBlock(void)
 {
     struct LinkPlayerBlock * block;
 
@@ -1638,7 +1638,7 @@ void sub_800B0B4(void)
     memcpy(gBlockSendBuffer, block, sizeof(*block));
 }
 
-void sub_800B110(u32 who)
+void LinkPlayerFromBlock(u32 who)
 {
     u8 who_ = who;
     struct LinkPlayerBlock * block;
@@ -1647,7 +1647,7 @@ void sub_800B110(u32 who)
     block = (struct LinkPlayerBlock *)gBlockRecvBuffer[who_];
     player = &gLinkPlayers[who_];
     *player = block->linkPlayer;
-    sub_800B284(player);
+    IntlConvertLinkPlayerName(player);
     if (strcmp(block->magic1, sASCIIGameFreakInc) != 0 || strcmp(block->magic2, sASCIIGameFreakInc) != 0)
     {
         SetMainCallback2(CB2_LinkError);
@@ -1670,8 +1670,8 @@ bool8 HandleLinkConnection(void)
     }
     else
     {
-        r4 = sub_80FAE94();
-        r5 = sub_80FAEF0();
+        r4 = LinkRfuMain1();
+        r5 = LinkRfuMain2();
         if (sub_8058318() == TRUE)
         {
             if (r4 == TRUE || IsRfuRecvQueueEmpty() || r5)
@@ -1683,7 +1683,7 @@ bool8 HandleLinkConnection(void)
     return FALSE;
 }
 
-void sub_800B1F4(void)
+void SetWirelessCommType1(void)
 {
     if (gReceivedRemoteLinkPlayers == 0)
     {
@@ -1691,7 +1691,7 @@ void sub_800B1F4(void)
     }
 }
 
-static void sub_800B210(void)
+static void SetWirelessCommType0(void)
 {
     if (gReceivedRemoteLinkPlayers == 0)
     {
@@ -1699,7 +1699,7 @@ static void sub_800B210(void)
     }
 }
 
-void sub_800B22C(void)
+void SetWirelessCommType0_UnusedCopy(void)
 {
     if (gReceivedRemoteLinkPlayers == 0)
     {
@@ -1725,7 +1725,7 @@ bool32 sub_800B270(void)
     return FALSE;
 }
 
-void sub_800B284(struct LinkPlayer * player)
+void IntlConvertLinkPlayerName(struct LinkPlayer * player)
 {
     player->name[10] = player->name[8];
     ConvertInternationalString(player->name, player->language);
diff --git a/src/link_rfu.c b/src/link_rfu.c
deleted file mode 100644
index 8ab76ffd5..000000000
--- a/src/link_rfu.c
+++ /dev/null
@@ -1,1381 +0,0 @@
-#include "global.h"
-#include "librfu.h"
-#include "link_rfu.h"
-
-struct UnkRfuStruct_1 gUnknown_3005E10;
-
-static void sub_80FD4E4(void);
-static void sub_80FDC28(u32 a0);
-static void sub_80FDC98(u16 reqCommandId, u16 reqResult);
-static void sub_80FE394(u16 reqCommandId);
-static void sub_80FE418(void);
-static void sub_80FE63C(void);
-static void sub_80FE6F0(void);
-static void sub_80FE74C(void);
-static u8 sub_80FE778(void);
-static void sub_80FE7F0(u8 a0, u8 a1);
-static void sub_80FE818(u8 bmDisconnectSlot);
-static void sub_80FE83C(u8 a0);
-static void sub_80FE918(void);
-static void sub_80FEAF4(void);
-
-u32 sub_80FD3A4(void)
-{
-    u32 id = rfu_REQBN_softReset_and_checkID();
-    if (id == RFU_ID)
-        gUnknown_3005E10.unk_08 = 1;
-    if (gUnknown_3005E10.unk_04 != 0x17 && gUnknown_3005E10.unk_04 != 0x01)
-    {
-        gUnknown_3005E10.unk_05 = 0;
-        gUnknown_3005E10.unk_04 = 0;
-    }
-    gUnknown_3005E10.unk_07 = 0;
-    gUnknown_3005E10.unk_0d = 0;
-    gUnknown_3005E10.unk_01 = 0;
-    gUnknown_3005E10.unk_00 = 0;
-    gUnknown_3005E10.unk_06 = -1;
-    sub_80FEAF4();
-    return id;
-}
-
-void LinkRfu_REQ_SendData_HandleParentRelationship(u8 clockChangeFlag)
-{
-    if (gRfuLinkStatus->parentChild == MODE_CHILD)
-    {
-        if (gUnknown_3005E10.unk_02 == TRUE)
-            clockChangeFlag = TRUE;
-        else
-            clockChangeFlag = FALSE;
-    }
-    else
-        gUnknown_3005E10.unk_03 = 0;
-    rfu_REQ_sendData(clockChangeFlag);
-}
-
-s32 sub_80FD430(void (*func1)(u8, u8), void (*func2)(u16))
-{
-    if (func1 == NULL)
-    {
-        return 4;
-    }
-    CpuFill16(0, &gUnknown_3005E10, sizeof(struct UnkRfuStruct_1));
-    gUnknown_3005E10.unk_06 = -1;
-    gUnknown_3005E10.unk_40 = func1;
-    gUnknown_3005E10.unk_44 = func2;
-    rfu_setMSCCallback(sub_80FE394);
-    rfu_setREQCallback(sub_80FDC98);
-    return 0;
-}
-
-static void sub_80FD484(void)
-{
-    CpuFill16(0, &gUnknown_3005E10, offsetof(struct UnkRfuStruct_1, unk_40));
-    gUnknown_3005E10.unk_06 = -1;
-}
-
-void sub_80FD4B0(const struct UnkLinkRfuStruct_02022B2C *unk0)
-{
-    sub_80FD4E4();
-    gUnknown_3005E10.unk_04 = 1;
-    gUnknown_3005E10.unk_05 = 2;
-    gUnknown_3005E10.unk_3c = unk0;
-    gUnknown_3005E10.unk_09 = unk0->unk_11;
-    gUnknown_3005E10.unk_32 = unk0->unk_12;
-    gUnknown_3005E10.unk_18 = unk0->unk_14;
-    if (unk0->unk_10)
-    {
-        gUnknown_3005E10.unk_0b = 1;
-    }
-}
-
-static void sub_80FD4E4(void)
-{
-    u8 i;
-
-    gUnknown_3005E10.unk_05 = 0;
-    gUnknown_3005E10.unk_04 = 0;
-    gUnknown_3005E10.unk_06 = -1;
-    gUnknown_3005E10.unk_07 = 0;
-    gUnknown_3005E10.unk_10 = 0;
-    gUnknown_3005E10.unk_0c = 0;
-    gUnknown_3005E10.unk_24 = 0;
-    gUnknown_3005E10.unk_30 = 0;
-    for (i = 0; i < RFU_CHILD_MAX; i++)
-    {
-        gUnknown_3005E10.unk_28[i] = 0;
-        gUnknown_3005E10.unk_34[i] = 0;
-    }
-}
-
-void sub_80FD52C(void)
-{
-    gUnknown_3005E10.unk_04 = 0x15;
-}
-
-u8 sub_80FD538(u8 r5, u16 r7, u16 r8, const u16 *r6)
-{
-    u8 i;
-    const u16 *buffer;
-
-    if (gUnknown_3005E10.unk_04 != 0 && (gUnknown_3005E10.unk_04 != 0x08 || r5 != 1))
-    {
-        gUnknown_3005E10.unk_14 = 1;
-        sub_80FE7F0(0xf3, 0x01);
-        return 1;
-    }
-    if (rfu_getMasterSlave() == AGB_CLK_SLAVE)
-    {
-        gUnknown_3005E10.unk_14 = 2;
-        sub_80FE7F0(0xf3, 0x01);
-        return 2;
-    }
-    for (i = 0, buffer = r6; i < 16; i++)
-    {
-        if (*buffer++ == 0xFFFF)
-        {
-            break;
-        }
-    }
-    if (i == 16)
-    {
-        gUnknown_3005E10.unk_14 = 4;
-        sub_80FE7F0(0xf3, 0x01);
-        return 4;
-    }
-    if (r5 > 1)
-    {
-        gUnknown_3005E10.unk_07 = 1;
-        r5 = 1;
-        r7 = 0;
-    }
-    else
-    {
-        gUnknown_3005E10.unk_07 = 0;
-    }
-    if (r5 != 0)
-    {
-        gUnknown_3005E10.unk_04 = 5;
-    }
-    else
-    {
-        gUnknown_3005E10.unk_04 = 9;
-        if (gUnknown_3005E10.unk_0b)
-        {
-            gUnknown_3005E10.unk_0b = 2;
-        }
-    }
-    gUnknown_3005E10.unk_06 = r5;
-    gUnknown_3005E10.unk_1a = r7;
-    gUnknown_3005E10.unk_26 = r8;
-    gUnknown_3005E10.unk_20 = r6;
-    return 0;
-}
-
-u8 sub_80FD610(u16 parentId, u16 unk_1a)
-{
-    u8 i;
-
-    if (gUnknown_3005E10.unk_04 != 0 && (gUnknown_3005E10.unk_04 < 9 || gUnknown_3005E10.unk_04 > 11))
-    {
-        gUnknown_3005E10.unk_14 = 1;
-        sub_80FE7F0(0xF3, 0x01);
-        return 1;
-    }
-    if (rfu_getMasterSlave() == AGB_CLK_SLAVE)
-    {
-        gUnknown_3005E10.unk_14 = 2;
-        sub_80FE7F0(0xF3, 0x01);
-        return 2;
-    }
-    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
-    {
-        if (gRfuLinkStatus->partner[i].id == parentId)
-        {
-            break;
-        }
-    }
-    if (gRfuLinkStatus->findParentCount == 0 || i == gRfuLinkStatus->findParentCount)
-    {
-        gUnknown_3005E10.unk_14 = 3;
-        sub_80FE7F0(0xF3, 0x01);
-        return 3;
-    }
-    if (gUnknown_3005E10.unk_04 == 0 || gUnknown_3005E10.unk_04 == 9)
-    {
-        gUnknown_3005E10.unk_04 = 12;
-        gUnknown_3005E10.unk_05 = 13;
-    }
-    else
-    {
-        gUnknown_3005E10.unk_04 = 11;
-        gUnknown_3005E10.unk_05 = 12;
-    }
-    gUnknown_3005E10.unk_1e = parentId;
-    gUnknown_3005E10.unk_1a = unk_1a;
-    if (gUnknown_3005E10.unk_07 != 0)
-    {
-        gUnknown_3005E10.unk_07 = 7;
-    }
-    return 0;
-}
-
-static void sub_80FD6F4(u8 lossSlot)
-{
-    u8 i;
-
-    if (lossSlot & gUnknown_3005E10.unk_30)
-    {
-        gUnknown_3005E10.unk_30 &= ~lossSlot;
-        for (i = 0; i < RFU_CHILD_MAX; i++)
-        {
-            if ((lossSlot >> i) & 1)
-            {
-                gUnknown_3005E10.unk_34[i] = 0;
-            }
-        }
-        i = gRfuLinkStatus->linkLossSlotFlag & lossSlot;
-        if (i)
-        {
-            sub_80FE818(i);
-        }
-        gUnknown_3005E10.unk_14 = i;
-        sub_80FE7F0(0x33, i);
-    }
-}
-
-void sub_80FD760(bool8 a0)
-{
-    u8 r2;
-
-    r2 = 0;
-    gUnknown_3005E10.unk_07 = 0;
-    if (a0)
-    {
-        sub_80FD4E4();
-        gUnknown_3005E10.unk_04 = 23;
-    }
-    else
-    {
-        switch (gUnknown_3005E10.unk_04)
-        {
-        case 5:
-            gUnknown_3005E10.unk_04 = 8;
-            gUnknown_3005E10.unk_05 = 0;
-            r2 = 0x13;
-            break;
-        case 6:
-            gUnknown_3005E10.unk_04 = 7;
-            gUnknown_3005E10.unk_05 = 8;
-            break;
-        case 7:
-            gUnknown_3005E10.unk_04 = 7;
-            gUnknown_3005E10.unk_05 = 8;
-            break;
-        case 8:
-            break;
-        case 9:
-            gUnknown_3005E10.unk_05 = 0;
-            gUnknown_3005E10.unk_04 = 0;
-            r2 = 0x21;
-            break;
-        case 10:
-            gUnknown_3005E10.unk_04 = 11;
-            gUnknown_3005E10.unk_05 = 0;
-            break;
-        case 11:
-            gUnknown_3005E10.unk_04 = 11;
-            gUnknown_3005E10.unk_05 = 0;
-            break;
-        case 12:
-            gUnknown_3005E10.unk_05 = 0;
-            gUnknown_3005E10.unk_04 = 0;
-            r2 = 0x23;
-            break;
-        case 13:
-            gUnknown_3005E10.unk_04 = 14;
-            break;
-        case 14:
-            gUnknown_3005E10.unk_04 = 14;
-            break;
-        case 15:
-            break;
-        case 16:
-            gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_11;
-            gUnknown_3005E10.unk_05 = gUnknown_3005E10.unk_12;
-            sub_80FE818(gRfuLinkStatus->linkLossSlotFlag);
-            gUnknown_3005E10.unk_14 = gRfuLinkStatus->linkLossSlotFlag;
-            sub_80FE7F0(0x33, 0x01);
-            return;
-        case 17:
-            gUnknown_3005E10.unk_04 = 18;
-            break;
-        case 18:
-            gUnknown_3005E10.unk_04 = 18;
-            break;
-        default:
-            gUnknown_3005E10.unk_05 = 0;
-            gUnknown_3005E10.unk_04 = 0;
-            r2 = 0x43;
-            break;
-        }
-        if (gUnknown_3005E10.unk_04 == 0)
-        {
-            sub_80FE7F0(r2, 0);
-        }
-    }
-}
-
-static bool8 sub_80FD850(u16 reqCommandId)
-{
-    bool8 retVal;
-    u8 i;
-    u8 bmLinkLossSlot;
-    u8 linkLossReason;
-    u8 parentBmLinkRecoverySlot;
-    u8 flags;
-
-    retVal = FALSE;
-    rfu_REQBN_watchLink(reqCommandId, &bmLinkLossSlot, &linkLossReason, &parentBmLinkRecoverySlot);
-    if (bmLinkLossSlot)
-    {
-        gUnknown_3005E10.unk_14 = bmLinkLossSlot;
-        gUnknown_3005E10.unk_16 = linkLossReason;
-        if (gUnknown_3005E10.unk_09)
-        {
-            gUnknown_3005E10.unk_0a = 1;
-            if (gUnknown_3005E10.unk_06 == 0 && linkLossReason == REASON_DISCONNECTED)
-            {
-                gUnknown_3005E10.unk_0a = 4;
-            }
-            if (gUnknown_3005E10.unk_0a == 1)
-            {
-                for (i = 0; i < RFU_CHILD_MAX; i++)
-                {
-                    if ((bmLinkLossSlot >> i) & 1)
-                    {
-                        gUnknown_3005E10.unk_30 |= (1 << i);
-                        gUnknown_3005E10.unk_34[i] = gUnknown_3005E10.unk_32;
-                    }
-                }
-                sub_80FE7F0(0x31, 0x01);
-            }
-            else
-            {
-                gUnknown_3005E10.unk_0a = 0;
-                sub_80FE818(bmLinkLossSlot);
-                retVal = TRUE;
-                sub_80FE7F0(0x33, 0x01);
-            }
-        }
-        else
-        {
-            sub_80FE818(bmLinkLossSlot);
-            retVal = TRUE;
-            sub_80FE7F0(0x30, 0x02);
-        }
-        sub_80FEAF4();
-    }
-    if (gRfuLinkStatus->parentChild == MODE_PARENT)
-    {
-        if (parentBmLinkRecoverySlot)
-        {
-            for (i = 0; i < RFU_CHILD_MAX; i++)
-            {
-                if ((gUnknown_3005E10.unk_30 >> i) & 1 && (parentBmLinkRecoverySlot >> i) & 1)
-                {
-                    gUnknown_3005E10.unk_34[i] = 0;
-                }
-            }
-            gUnknown_3005E10.unk_30 &= ~parentBmLinkRecoverySlot;
-            gUnknown_3005E10.unk_14 = parentBmLinkRecoverySlot;
-            sub_80FE7F0(0x32, 0x01);
-        }
-        if (gUnknown_3005E10.unk_30)
-        {
-            flags = 0;
-            for (i = 0; i < RFU_CHILD_MAX; i++)
-            {
-                if ((gUnknown_3005E10.unk_30 >> i) & 1 && gUnknown_3005E10.unk_34[i] && --gUnknown_3005E10.unk_34[i] == 0)
-                {
-                    gUnknown_3005E10.unk_30 &= ~(1 << i);
-                    flags |= (1 << i);
-                }
-            }
-            if (flags)
-            {
-                sub_80FE818(flags);
-                retVal = TRUE;
-                gUnknown_3005E10.unk_14 = flags;
-                sub_80FE7F0(0x33, 0x01);
-            }
-        }
-        if (!gUnknown_3005E10.unk_30)
-        {
-            gUnknown_3005E10.unk_0a = 0;
-        }
-    }
-    return retVal;
-}
-
-void LinkRfu_syncVBlank_(void)
-{
-    if (rfu_syncVBlank())
-    {
-        sub_80FE7F0(0xF1, 0x00);
-        sub_80FEAF4();
-    }
-}
-
-void sub_80FDA30(u32 a0)
-{
-    u8 r2;
-
-    if (gUnknown_3005E10.unk_40 == NULL && gUnknown_3005E10.unk_04 != 0)
-    {
-        gUnknown_3005E10.unk_04 = 0;
-    }
-    else
-    {
-        if (gUnknown_3005E10.unk_07 != 0)
-        {
-            sub_80FDC28(a0);
-        }
-        do
-        {
-            if (gUnknown_3005E10.unk_04 != 0)
-            {
-                rfu_waitREQComplete();
-                gUnknown_3005E10.unk_0e = 1;
-                switch (gUnknown_3005E10.unk_04)
-                {
-                case 23:
-                    r2 = sub_80FD3A4() == RFU_ID ? 0x44 : 0xFF;
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                    sub_80FE7F0(r2, 0);
-                    break;
-                case 1:
-                    if (sub_80FD3A4() == RFU_ID)
-                    {
-                        gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                        gUnknown_3005E10.unk_05 = 3;
-                    }
-                    else
-                    {
-                        gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                        sub_80FE7F0(0xFF, 0);
-                    }
-                    break;
-                case 2:
-                    rfu_REQ_reset();
-                    break;
-                case 3:
-                    rfu_REQ_configSystem(gUnknown_3005E10.unk_3c->availSlotFlag, gUnknown_3005E10.unk_3c->maxMFrame, gUnknown_3005E10.unk_3c->mcTimer);
-                    break;
-                case 4:
-                    rfu_REQ_configGameData(gUnknown_3005E10.unk_3c->mbootFlag, gUnknown_3005E10.unk_3c->serialNo, (const u8 *)gUnknown_3005E10.unk_3c->gname, gUnknown_3005E10.unk_3c->uname);
-                    break;
-                case 5:
-                    rfu_REQ_startSearchChild();
-                    break;
-                case 6:
-                    rfu_REQ_pollSearchChild();
-                    break;
-                case 7:
-                    rfu_REQ_endSearchChild();
-                    break;
-                case 8:
-                    break;
-                case 9:
-                    rfu_REQ_startSearchParent();
-                    break;
-                case 10:
-                    rfu_REQ_pollSearchParent();
-                    break;
-                case 11:
-                    rfu_REQ_endSearchParent();
-                    break;
-                case 12:
-                    rfu_REQ_startConnectParent(gUnknown_3005E10.unk_1e);
-                    break;
-                case 13:
-                    rfu_REQ_pollConnectParent();
-                    break;
-                case 14:
-                    rfu_REQ_endConnectParent();
-                    break;
-                case 15:
-                    break;
-                case 16:
-                    rfu_REQ_CHILD_startConnectRecovery(gRfuLinkStatus->linkLossSlotFlag);
-                    break;
-                case 17:
-                    rfu_REQ_CHILD_pollConnectRecovery();
-                    break;
-                case 18:
-                    rfu_REQ_CHILD_endConnectRecovery();
-                    break;
-                case 19:
-                    rfu_REQ_changeMasterSlave();
-                    break;
-                case 20:
-                    break;
-                case 21:
-                    rfu_REQ_stopMode();
-                    break;
-                case 22:
-                    break;
-                }
-                rfu_waitREQComplete();
-                gUnknown_3005E10.unk_0e = 0;
-            }
-        } while (gUnknown_3005E10.unk_04 == 18 || gUnknown_3005E10.unk_04 == 19);
-        if (gRfuLinkStatus->parentChild != MODE_PARENT || !sub_80FD850(0))
-        {
-            sub_80FE418();
-            sub_80FE63C();
-            sub_80FE74C();
-            sub_80FE918();
-        }
-    }
-}
-
-static void sub_80FDC28(u32 a0)
-{
-    if (gUnknown_3005E10.unk_07 == 5)
-    {
-        gUnknown_3005E10.unk_06 = 1;
-        gUnknown_3005E10.unk_04 = 5;
-        gUnknown_3005E10.unk_1a = gUnknown_3005E10.unk_1c;
-        if (gUnknown_3005E10.unk_1a)
-        {
-            gUnknown_3005E10.unk_07 = 6;
-        }
-        else
-        {
-            gUnknown_3005E10.unk_07 = 1;
-        }
-    }
-    if (gUnknown_3005E10.unk_07 == 1)
-    {
-        gUnknown_3005E10.unk_06 = 1;
-        gUnknown_3005E10.unk_04 = 5;
-        gUnknown_3005E10.unk_1a = a0 % 140;
-        gUnknown_3005E10.unk_1c = 140 - gUnknown_3005E10.unk_1a;
-        if (gUnknown_3005E10.unk_1a)
-        {
-            gUnknown_3005E10.unk_07 = 2;
-        }
-        else
-        {
-            gUnknown_3005E10.unk_07 = 3;
-        }
-    }
-    if (gUnknown_3005E10.unk_07 == 3)
-    {
-        gUnknown_3005E10.unk_06 = 0;
-        gUnknown_3005E10.unk_1a = 40;
-        gUnknown_3005E10.unk_07 = 4;
-        gUnknown_3005E10.unk_04 = 9;
-    }
-}
-
-static void sub_80FDC98(u16 reqCommandId, u16 reqResult)
-{
-    u8 sp0;
-    register u8 *stwiRecvBuffer asm("r0");
-    u8 *tmp;
-    u8 i;
-
-    if (gUnknown_3005E10.unk_0e != 0)
-    {
-        gUnknown_3005E10.unk_0e = 0;
-        switch (reqCommandId)
-        {
-        case ID_RESET_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                gUnknown_3005E10.unk_05 = 4;
-            }
-            break;
-        case ID_SYSTEM_CONFIG_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                gUnknown_3005E10.unk_05 = 0;
-            }
-            break;
-        case ID_GAME_CONFIG_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                sub_80FE7F0(0x00, 0x00);
-            }
-            break;
-        case ID_SC_START_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 6;
-            }
-            break;
-        case ID_SC_POLL_REQ:
-            if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0)
-            {
-                gUnknown_3005E10.unk_04 = 7;
-                gUnknown_3005E10.unk_05 = 8;
-            }
-            break;
-        case ID_SC_END_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                gUnknown_3005E10.unk_05 = 0;
-                if (gUnknown_3005E10.unk_07 == 0)
-                {
-                    sub_80FE7F0(0x13, 0x00);
-                }
-            }
-            break;
-        case ID_SP_START_REQ:
-            if (reqResult == 0)
-            {
-                if (gUnknown_3005E10.unk_0b == 1 && gUnknown_3005E10.unk_1a > 1)
-                {
-                    gUnknown_3005E10.unk_1a--;
-                }
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 10;
-            }
-            break;
-        case ID_SP_POLL_REQ:
-            if (reqResult == 0)
-            {
-                sp0 = sub_80FE778();
-                gUnknown_3005E10.unk_14 = sp0;
-                if (sp0)
-                {
-                    sub_80FE7F0(0x20, 0x01);
-                }
-                if (gUnknown_3005E10.unk_0b && gUnknown_3005E10.unk_1a != 1 && gRfuLinkStatus->findParentCount == RFU_CHILD_MAX)
-                {
-                    rfu_REQ_endSearchParent();
-                    rfu_waitREQComplete();
-                    gUnknown_3005E10.unk_04 = 9;
-                    gUnknown_3005E10.unk_0b = 1;
-                }
-            }
-            if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0)
-            {
-                gUnknown_3005E10.unk_04 = 11;
-                gUnknown_3005E10.unk_05 = 0;
-            }
-            break;
-        case ID_SP_END_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                if (gUnknown_3005E10.unk_07 == 0)
-                {
-                    if (gUnknown_3005E10.unk_04 == 0)
-                    {
-                        sub_80FE7F0(0x21, 0x00);
-                    }
-                }
-                else if (gUnknown_3005E10.unk_07 != 7)
-                {
-                    gUnknown_3005E10.unk_04 = 5;
-                    gUnknown_3005E10.unk_07 = 5;
-                }
-            }
-            break;
-        case ID_CP_START_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 13;
-            }
-            break;
-        case ID_CP_POLL_REQ:
-            if (reqResult == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_3005E10.unk_10) && !sp0)
-            {
-                gUnknown_3005E10.unk_04 = 14;
-            }
-            if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0)
-            {
-                gUnknown_3005E10.unk_04 = 14;
-            }
-            break;
-        case ID_CP_END_REQ:
-            if (reqResult == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_3005E10.unk_10))
-            {
-                if (!sp0)
-                {
-                    gUnknown_3005E10.unk_04 = 19;
-                    gUnknown_3005E10.unk_05 = 15;
-                    gUnknown_3005E10.unk_1e = 0x22;
-                    gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_10;
-                }
-                else
-                {
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                    gUnknown_3005E10.unk_1e = 0x23;
-                    gUnknown_3005E10.unk_14 = sp0;
-                    if (gUnknown_3005E10.unk_07)
-                    {
-                        gUnknown_3005E10.unk_07 = 3;
-                        gUnknown_3005E10.unk_04 = 9;
-                    }
-                }
-                sub_80FE7F0(gUnknown_3005E10.unk_1e, 0x01);
-                gUnknown_3005E10.unk_1e = 0;
-            }
-            break;
-        case ID_CPR_START_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_14 = gRfuLinkStatus->linkLossSlotFlag;
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 17;
-                for (gUnknown_3005E10.unk_10 = 0; gUnknown_3005E10.unk_10 < RFU_CHILD_MAX; gUnknown_3005E10.unk_10++)
-                {
-                    if ((gRfuLinkStatus->linkLossSlotFlag >> gUnknown_3005E10.unk_10) & 1)
-                    {
-                        break;
-                    }
-                }
-            }
-            break;
-        case ID_CPR_POLL_REQ:
-            if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0) && sp0 < 2)
-            {
-                gUnknown_3005E10.unk_04 = 18;
-            }
-            if (gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] && --gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] == 0)
-            {
-                gUnknown_3005E10.unk_04 = 18;
-            }
-            break;
-        case ID_CPR_END_REQ:
-            if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0))
-            {
-                if (!sp0)
-                {
-                    gUnknown_3005E10.unk_04 = 19;
-                    gUnknown_3005E10.unk_05 = 22;
-                    gUnknown_3005E10.unk_1e = 0x32;
-                }
-                else
-                {
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                    sub_80FE818(gRfuLinkStatus->linkLossSlotFlag);
-                    gUnknown_3005E10.unk_1e = 0x33;
-                }
-                gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] = 0;
-                gUnknown_3005E10.unk_30 = 0;
-                gUnknown_3005E10.unk_0a = 0;
-                sub_80FE7F0(gUnknown_3005E10.unk_1e, 0x01);
-                gUnknown_3005E10.unk_1e = 0;
-            }
-            break;
-        case ID_MS_CHANGE_REQ:
-            if (reqResult == 0)
-            {
-                if (gUnknown_3005E10.unk_05 == 22)
-                {
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_11;
-                    gUnknown_3005E10.unk_05 = gUnknown_3005E10.unk_12;
-                    gUnknown_3005E10.unk_02 = 1;
-                    sub_80FE7F0(0x41, 0x00);
-                }
-                else if (gUnknown_3005E10.unk_05 == 15)
-                {
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05;
-                    gUnknown_3005E10.unk_02 = 1;
-                    sub_80FE7F0(0x41, 0x00);
-                    gUnknown_3005E10.unk_24 |= 1 << gUnknown_3005E10.unk_10;
-                    gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = gUnknown_3005E10.unk_26;
-                    rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10);
-                    tmp = &sp0;
-                    *tmp = rfu_NI_CHILD_setSendGameName(gUnknown_3005E10.unk_10, 0x0e);
-                    if (*tmp)
-                    {
-                        gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                        sub_80FEAF4();
-                        sub_80FE818(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-                        gUnknown_3005E10.unk_14 = sp0;
-                        sub_80FE7F0(0x25, 0x01);
-                    }
-                }
-            }
-            break;
-        case ID_STOP_MODE_REQ:
-            if (reqResult == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                sub_80FE7F0(0x42, 0x00);
-            }
-            break;
-        }
-        gUnknown_3005E10.unk_0e = 1;
-    }
-    else if (reqResult == 3 && gUnknown_3005E10.unk_0f && (reqCommandId == ID_DATA_TX_REQ || reqCommandId == ID_DATA_RX_REQ || reqCommandId == ID_MS_CHANGE_REQ))
-    {
-        rfu_REQ_RFUStatus();
-        rfu_waitREQComplete();
-        rfu_getRFUStatus(&sp0);
-        if (sp0 == 0 && gRfuLinkStatus->parentChild == MODE_CHILD)
-        {
-            stwiRecvBuffer = rfu_getSTWIRecvBuffer()->rxPacketAlloc.rfuPacket8.data;
-            stwiRecvBuffer[4] = gRfuLinkStatus->connSlotFlag;
-            stwiRecvBuffer[5] = 1;
-            sub_80FD850(0x29);
-            reqResult = 0;
-        }
-    }
-    switch (reqCommandId)
-    {
-    case ID_DISCONNECT_REQ:
-        if (reqResult == 0)
-        {
-            stwiRecvBuffer = rfu_getSTWIRecvBuffer()->rxPacketAlloc.rfuPacket8.data;
-            gUnknown_3005E10.unk_14 = stwiRecvBuffer[8];
-            sub_80FE83C(gUnknown_3005E10.unk_14);
-            if (gUnknown_3005E10.unk_30)
-            {
-                gUnknown_3005E10.unk_30 &= ~gUnknown_3005E10.unk_14;
-                for (i = 0; i < RFU_CHILD_MAX; i++)
-                {
-                    if ((gUnknown_3005E10.unk_14 >> i) & 1)
-                    {
-                        gUnknown_3005E10.unk_34[i] = 0;
-                    }
-                }
-                if (gUnknown_3005E10.unk_06 == 0)
-                {
-                    gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                }
-            }
-            sp0 = gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14;
-            for (i = 0; i < RFU_CHILD_MAX; i++)
-            {
-                if ((sp0 >> i) & 1 && gUnknown_3005E10.unk_01)
-                {
-                    gUnknown_3005E10.unk_01--;
-                }
-            }
-            gUnknown_3005E10.unk_00 &= ~gUnknown_3005E10.unk_14;
-            if (gUnknown_3005E10.unk_07)
-            {
-                if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
-                {
-                    if (gUnknown_3005E10.unk_07 == 8)
-                    {
-                        gUnknown_3005E10.unk_1a = gUnknown_3005E10.unk_1c;
-                        gUnknown_3005E10.unk_07 = 6;
-                        gUnknown_3005E10.unk_04 = 6;
-                    }
-                    else if (gUnknown_3005E10.unk_04 != 6 && gUnknown_3005E10.unk_04 != 7)
-                    {
-                        gUnknown_3005E10.unk_07 = 1;
-                        gUnknown_3005E10.unk_04 = 5;
-                    }
-                }
-            }
-            if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
-            {
-                if (gUnknown_3005E10.unk_04 == 0)
-                {
-                    gUnknown_3005E10.unk_06 = -1;
-                }
-            }
-            if (gUnknown_3005E10.unk_0e == 0)
-            {
-                sub_80FE7F0(0x40, 0x01);
-            }
-        }
-        break;
-    case ID_DATA_RX_REQ:
-        sub_80FE6F0();
-        if (gRfuLinkStatus->parentChild != MODE_NEUTRAL)
-        {
-            sub_80FE7F0(0x50, 0x00);
-        }
-        break;
-    case ID_RESET_REQ:
-    case ID_STOP_MODE_REQ:
-        if (reqResult == 0)
-        {
-            gUnknown_3005E10.unk_0d = 0;
-            gUnknown_3005E10.unk_01 = 0;
-            gUnknown_3005E10.unk_00 = 0;;
-            gUnknown_3005E10.unk_06 = -1;
-            sub_80FEAF4();
-            if (reqCommandId == 61)
-            {
-                sub_80FD484();
-            }
-        }
-        break;
-    }
-    if (reqResult != 0)
-    {
-        if (reqCommandId == ID_SP_START_REQ && reqResult != 0 && gUnknown_3005E10.unk_07 == 4)
-        {
-            gRfuLinkStatus->parentChild = MODE_PARENT;
-            gRfuLinkStatus->connSlotFlag = 0xF;
-            sub_80FE818(15);
-            rfu_waitREQComplete();
-            return;
-        }
-        else
-        {
-            gUnknown_3005E10.unk_14 = reqCommandId;
-            gUnknown_3005E10.unk_16 = reqResult;
-            if (gUnknown_3005E10.unk_0e)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-            }
-            sub_80FE7F0(0xf0, 0x02);
-            sub_80FEAF4();
-        }
-    }
-    if (reqCommandId == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ)
-    {
-        sub_80FE7F0(0xf2, 0x00);
-        sub_80FEAF4();
-    }
-}
-
-static void sub_80FE394(u16 reqCommandId)
-{
-    u8 r7;
-    u8 ackFlag;
-
-    r7 = gUnknown_3005E10.unk_0e;
-    gUnknown_3005E10.unk_0e = 0;
-    gUnknown_3005E10.unk_0f = 1;
-    if (gRfuLinkStatus->parentChild == MODE_CHILD)
-    {
-        sub_80FD850(reqCommandId);
-        if (gUnknown_3005E10.unk_02 != 1)
-        {
-            sub_80FEAF4();
-            gUnknown_3005E10.unk_0f = 0;
-            gUnknown_3005E10.unk_0e = r7;
-            return;
-        }
-    }
-    else
-    {
-        if (!rfu_UNI_PARENT_getDRAC_ACK(&ackFlag))
-        {
-            gUnknown_3005E10.unk_03 |= ackFlag;
-        }
-    }
-    if (gUnknown_3005E10.unk_44 != NULL)
-    {
-        gUnknown_3005E10.unk_44(reqCommandId);
-        rfu_waitREQComplete();
-        if (gUnknown_3005E10.unk_02 == 2)
-        {
-            sub_80FEAF4();
-        }
-    }
-    gUnknown_3005E10.unk_0f = 0;
-    gUnknown_3005E10.unk_0e = r7;
-}
-
-static void sub_80FE418(void)
-{
-    u8 flags;
-    u8 sp0;
-    u8 i;
-    u8 r5;
-    u8 r4;
-    const u16 *ptr;
-
-    if (gUnknown_3005E10.unk_04 == 5 || gUnknown_3005E10.unk_04 == 6 || gUnknown_3005E10.unk_04 == 7 || gUnknown_3005E10.unk_04 == 8)
-    {
-        flags = ((gRfuLinkStatus->connSlotFlag ^ gUnknown_3005E10.unk_0c) & gRfuLinkStatus->connSlotFlag) & ~gRfuLinkStatus->getNameFlag;
-        gUnknown_3005E10.unk_0c = gRfuLinkStatus->connSlotFlag;
-        if (flags)
-        {
-            gUnknown_3005E10.unk_14 = flags;
-            sub_80FE7F0(0x10, 0x01);
-        }
-        sp0 = 0x00;
-        for (i = 0; i < RFU_CHILD_MAX; i++)
-        {
-            r4 = 1 << i;
-            r5 = 0x00;
-            if (flags & r4)
-            {
-                gUnknown_3005E10.unk_28[i] = gUnknown_3005E10.unk_26;
-                gUnknown_3005E10.unk_24 |= r4;
-            }
-            else if (gUnknown_3005E10.unk_24 & r4)
-            {
-                if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS)
-                {
-                    if (gRfuSlotStatusNI[i]->recv.dataType == 1) // Game identification information
-                    {
-                        r5 = 0x02;
-                        for (ptr = gUnknown_3005E10.unk_20; *ptr != 0xFFFF; ptr++)
-                        {
-                            if (gRfuLinkStatus->partner[i].serialNo == *ptr)
-                            {
-                                gUnknown_3005E10.unk_00 |= r4;
-                                gUnknown_3005E10.unk_01++;
-                                sp0 |= r4;
-                                r5 |= 0x01;
-                                break;
-                            }
-                        }
-                        if (!(r5 & 0x01))
-                        {
-                            r5 |= 0x04;
-                        }
-                    }
-                }
-                else if (--gUnknown_3005E10.unk_28[i] == 0)
-                {
-                    r5 = 0x06;
-                }
-                if (r5 & 0x02)
-                {
-                    gUnknown_3005E10.unk_24 &= ~r4;
-                    gUnknown_3005E10.unk_28[i] = 0;
-                    rfu_clearSlot(TYPE_NI_RECV, i);
-                }
-                if (r5 & 0x04)
-                {
-                    gUnknown_3005E10.unk_0d |= r4;
-                }
-            }
-        }
-        if (sp0)
-        {
-            gUnknown_3005E10.unk_14 = sp0;
-            sub_80FE7F0(0x11, 0x01);
-        }
-        if (gUnknown_3005E10.unk_0d)
-        {
-            r5 = 0x01;
-            if (gRfuLinkStatus->sendSlotUNIFlag && ((gUnknown_3005E10.unk_03 & gUnknown_3005E10.unk_00) != gUnknown_3005E10.unk_00))
-            {
-                r5 = 0x00;
-            }
-            if (r5)
-            {
-                sub_80FE818(gUnknown_3005E10.unk_0d);
-                gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_0d;
-                gUnknown_3005E10.unk_0d = 0;
-                sub_80FE7F0(0x12, 0x01);
-            }
-        }
-        if (gUnknown_3005E10.unk_24 == 0 && gUnknown_3005E10.unk_04 == 8)
-        {
-            if (gUnknown_3005E10.unk_07 == 0)
-            {
-                gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-                sub_80FE7F0(0x14, 0x00);
-            }
-            else
-            {
-                if (gUnknown_3005E10.unk_07 == 2)
-                {
-                    gUnknown_3005E10.unk_07 = 3;
-                    gUnknown_3005E10.unk_04 = 9;
-                }
-                else
-                {
-                    gUnknown_3005E10.unk_07 = 1;
-                    gUnknown_3005E10.unk_04 = 5;
-                }
-                if (gUnknown_3005E10.unk_00)
-                {
-                    gUnknown_3005E10.unk_1a = 0;
-                    gUnknown_3005E10.unk_07 = 8;
-                    gUnknown_3005E10.unk_04 = 5;
-                }
-            }
-        }
-    }
-}
-
-static void sub_80FE63C(void)
-{
-    u16 imeBak = REG_IME;
-    REG_IME = 0;
-    if (gUnknown_3005E10.unk_04 == 15)
-    {
-        if (--gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] == 0 || gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == SLOT_STATE_SEND_FAILED)
-        {
-            sub_80FEB14();
-            gUnknown_3005E10.unk_04 = 24;
-            rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10);
-            gUnknown_3005E10.unk_24 &= ~(1 << gUnknown_3005E10.unk_10);
-            gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = 0;
-        }
-    }
-    REG_IME = imeBak;
-    if (gUnknown_3005E10.unk_04 == 24)
-    {
-        if (gUnknown_3005E10.unk_02 == 1)
-        {
-            sub_80FEB14();
-        }
-        if (gUnknown_3005E10.unk_02 == 0)
-        {
-            gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-            sub_80FE818(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-            gUnknown_3005E10.unk_14 = 0;
-            sub_80FE7F0(0x25, 0x01);
-        }
-    }
-}
-
-static void sub_80FE6F0(void)
-{
-    if (gUnknown_3005E10.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == SLOT_STATE_SEND_SUCCESS)
-    {
-        gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
-        rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10);
-        gUnknown_3005E10.unk_24 &= ~(1 << gUnknown_3005E10.unk_10);
-        gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = 0;
-        sub_80FE7F0(0x24, 0x00);
-    }
-}
-
-static void sub_80FE74C(void)
-{
-    if (gUnknown_3005E10.unk_06 == 0 && gUnknown_3005E10.unk_0a == 1)
-    {
-        gUnknown_3005E10.unk_11 = gUnknown_3005E10.unk_04;
-        gUnknown_3005E10.unk_12 = gUnknown_3005E10.unk_05;
-        gUnknown_3005E10.unk_04 = 16;
-        gUnknown_3005E10.unk_05 = 17;
-        gUnknown_3005E10.unk_0a = 2;
-    }
-}
-
-static u8 sub_80FE778(void)
-{
-    u8 i;
-    const u16 *ptr;
-    u8 flags = 0x00;
-
-    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
-    {
-        for (ptr = gUnknown_3005E10.unk_20; *ptr != 0xFFFF; ptr++)
-        {
-            if (gRfuLinkStatus->partner[i].serialNo == *ptr)
-            {
-                flags |= (1 << i);
-            }
-        }
-    }
-    return flags;
-}
-
-static void sub_80FE7F0(u8 a0, u8 a1)
-{
-    if (gUnknown_3005E10.unk_40 != NULL)
-    {
-        gUnknown_3005E10.unk_40(a0, a1);
-    }
-    gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_16 = 0;
-}
-
-static void sub_80FE818(u8 a0)
-{
-    u8 unk_0e_bak = gUnknown_3005E10.unk_0e;
-    gUnknown_3005E10.unk_0e = 1;
-    rfu_REQ_disconnect(a0);
-    rfu_waitREQComplete();
-    gUnknown_3005E10.unk_0e = unk_0e_bak;
-}
-
-static void sub_80FE83C(u8 a0)
-{
-    u8 i;
-
-    if (gRfuLinkStatus->sendSlotNIFlag)
-    {
-        for (i = 0; i < RFU_CHILD_MAX; i++)
-        {
-            if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->send.bmSlot & a0)
-            {
-                rfu_changeSendTarget(TYPE_NI, i, gRfuSlotStatusNI[i]->send.bmSlot & ~a0);
-            }
-        }
-    }
-    if (gRfuLinkStatus->recvSlotNIFlag)
-    {
-        for (i = 0; i < RFU_CHILD_MAX; i++)
-        {
-            if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.bmSlot & a0)
-            {
-                rfu_NI_stopReceivingData(i);
-            }
-        }
-    }
-    if (gRfuLinkStatus->sendSlotUNIFlag)
-    {
-        gRfuLinkStatus->sendSlotUNIFlag &= ~a0;
-        for (i = 0; i < RFU_CHILD_MAX; i++)
-        {
-            if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI && a0 & gRfuSlotStatusUNI[i]->send.bmSlot)
-            {
-                gRfuSlotStatusUNI[i]->send.bmSlot &= ~a0;
-            }
-        }
-    }
-}
-
-static void sub_80FE918(void)
-{
-    u8 i;
-    u8 j;
-    u8 flags;
-
-    if (gUnknown_3005E10.unk_18)
-    {
-        if (gRfuLinkStatus->sendSlotNIFlag)
-        {
-            for (i = 0; i < RFU_CHILD_MAX; i++)
-            {
-                if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG)
-                {
-                    flags = 0;
-                    for (j = 0; j < RFU_CHILD_MAX; j++)
-                    {
-                        if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > gUnknown_3005E10.unk_18)
-                        {
-                            flags |= (1 << j);
-                        }
-                        if (flags)
-                        {
-                            rfu_changeSendTarget(TYPE_NI, i, flags ^ gRfuSlotStatusNI[i]->send.bmSlot);
-                        }
-                    }
-                }
-            }
-        }
-        if (gRfuLinkStatus->recvSlotNIFlag)
-        {
-            for (i = 0; i < RFU_CHILD_MAX; i++)
-            {
-                if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.failCounter > gUnknown_3005E10.unk_18)
-                {
-                    rfu_NI_stopReceivingData(i);
-                }
-            }
-        }
-    }
-}
-
-void sub_80FEA10(void (*func)(u16))
-{
-    gUnknown_3005E10.unk_44 = func;
-    rfu_setMSCCallback(sub_80FE394);
-}
-
-static void sub_80FEA28(void (*func)(u8, u8))
-{
-    gUnknown_3005E10.unk_40 = func;
-}
-
-u8 sub_80FEA34(u8 a0, u16 a1)
-{
-    u16 imeBak;
-    if (gUnknown_3005E10.unk_09 && a0 == 0 && gUnknown_3005E10.unk_30)
-    {
-        return 5;
-    }
-    imeBak = REG_IME;
-    REG_IME = 0;
-    gUnknown_3005E10.unk_09 = a0;
-    gUnknown_3005E10.unk_32 = a1;
-    REG_IME = imeBak;
-    return 0;
-}
-
-static u8 sub_80FEA78(u16 a0)
-{
-    if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag)
-    {
-        gUnknown_3005E10.unk_14 = 6;
-        sub_80FE7F0(0xf3, 0x01);
-        return 6;
-    }
-    gUnknown_3005E10.unk_18 = a0;
-    return 0;
-}
-
-static u8 sub_80FEAB4(u8 a0)
-{
-    if (gUnknown_3005E10.unk_04 == 9 || gUnknown_3005E10.unk_04 == 10 || gUnknown_3005E10.unk_04 == 11)
-    {
-        gUnknown_3005E10.unk_14 = 7;
-        sub_80FE7F0(0xf3, 0x01);
-        return 7;
-    }
-    if (a0)
-    {
-        gUnknown_3005E10.unk_0b = 1;
-    }
-    else
-    {
-        gUnknown_3005E10.unk_0b = 0;
-    }
-    return 0;
-}
-
-static void sub_80FEAF4(void)
-{
-    if (gUnknown_3005E10.unk_02)
-    {
-        gUnknown_3005E10.unk_02 = 0;
-        sub_80FE7F0(0x45, 0x00);
-    }
-}
-
-void sub_80FEB14(void)
-{
-    if (gUnknown_3005E10.unk_02 == 0)
-    {
-        sub_80FE7F0(0x45, 0x00);
-    }
-    else if (gUnknown_3005E10.unk_02 == 1)
-    {
-        gUnknown_3005E10.unk_02 = 2;
-    }
-}
-
-void sub_80FEB3C(void)
-{
-    if (gUnknown_3005E10.unk_07)
-    {
-        switch (gUnknown_3005E10.unk_04)
-        {
-        case 5:
-            gUnknown_3005E10.unk_07 = 3;
-            gUnknown_3005E10.unk_04 = 9;
-            break;
-        case 6:
-            gUnknown_3005E10.unk_07 = 2;
-            gUnknown_3005E10.unk_1a = 1;
-            break;
-        case 7:
-        case 8:
-            gUnknown_3005E10.unk_07 = 2;
-            break;
-        case 9:
-        case 10:
-            gUnknown_3005E10.unk_1a = 40;
-            break;
-        case 11:
-            gUnknown_3005E10.unk_1a = 40;
-            gUnknown_3005E10.unk_04 = 10;
-            break;
-        }
-    }
-}
diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c
index a27948650..2259e9214 100644
--- a/src/link_rfu_2.c
+++ b/src/link_rfu_2.c
@@ -12,67 +12,69 @@
 #include "string_util.h"
 #include "task.h"
 #include "constants/species.h"
+#include "constants/union_room.h"
 
-struct UnkRfuStruct_8010A14{
-    char unk_00[15]; // PokemonSioInfo
-    u8 unk_0f;
-    u8 unk_10[4];
-    struct LinkPlayer unk_14[5];
+struct SioInfo
+{
+    char magic[15]; // PokemonSioInfo
+    u8 playerCount;
+    u8 linkPlayerIdx[RFU_CHILD_MAX];
+    struct LinkPlayer linkPlayers[MAX_RFU_PLAYERS];
     u8 fill_a0[0x5c];
 };
 
-static EWRAM_DATA struct UnkLinkRfuStruct_02022B2C sRfuReqConfig = {};
+static EWRAM_DATA struct InitializeParametersTag sRfuReqConfig = {};
 static EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {};
 
-static struct RfuAPIBuffer gRfuAPIBuffer;
-static u8 gUnknown_3001FF8[14];
-static u16 gUnknown_3002008[7];
+static u32 gf_rfu_REQ_api[RFU_API_BUFF_SIZE_RAM / 4];
+static u8 sResendBlock8[14];
+static u16 sResendBlock16[7];
 
 struct GFtgtGname gHostRFUtgtGnameBuffer;
-struct UnkRfuStruct_2 Rfu;
+GF_RFU_MANAGER Rfu;
 u8 gHostRFUtgtUnameBuffer[PLAYER_NAME_LENGTH + 1];
 
 static void sub_80F8AA4(void);
 static void sub_80F8AEC(void);
-static void sub_80F8D20(u16 a0);
-static void sub_80F8DA8(u16 a0);
+static void MscCallback_Child(u16 a0);
+static void MSCCallback_SetUnkCDB(u16 a0);
 static void sub_80F906C(void);
-static void sub_80F9868(u8 unused);
-static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data);
-static void sub_80F9D04(u16 command);
-static void rfufunc_80F9F44(void);
-static void sub_80F9FA8(void);
-static void rfufunc_80FA020(void);
+static void RfuHandleReceiveCommand(u8 unused);
+static void ResetSendDataManager(struct RfuBlockSend *data);
+static void RfuPrepareSendBuffer(u16 command);
+static void RfuFunc_HandleBlockSend(void);
+static void RfuFunc_SendNextBlock(void);
+static void RfuFunc_SendLastBlock(void);
 static void CallRfuFunc(void);
 static void sub_80FA738(void);
 static int sub_80FA788(void);
 static void sub_80FA834(u8 taskId);
 static void sub_80FA9D0(u16 a0);
-static void sub_80FAA58(void * a0);
-static void sub_80FAA94(u8 taskId);
+static void ValidateAndReceivePokemonSioInfo(void * a0);
+static void Task_ExchangeLinkPlayers(u8 taskId);
 static void sub_80FACF0(u8 taskId);
-static void sub_80FB0E8(u32 a0);
-static void sub_80FB564(s32 a0);
+static void GetLinkmanErrorParams(u32 msg);
+static void sub_80FB564(s32 bmConnectedFlag);
 static void sub_80FBB74(void);
-static u8 sub_80FBC70(const u8 *a0, u16 a1);
-static void sub_80FBCF8(u32 a0);
+static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId);
+static void RfuReqDisconnectSlot(u32 bmDisconnectSlot);
 static void sub_80FBE20(u32 a0, u32 a1);
 static void sub_80FC028(u8 taskId);
-static void sub_80FC208(void);
-static void nullsub_89(u8 taskId);
+static void rfu_dbg_clear(void);
+static void Task_idle(u8 taskId);
 
-static const struct UnkLinkRfuStruct_02022B2C sRfuReqConfigTemplate = {
+static const struct InitializeParametersTag sRfuReqConfigTemplate = {
     .maxMFrame = 4,
-    .mcTimer = 32,
-    .availSlotFlag = 0,
-    .mbootFlag = 0,
+    .MC_TimerCount = 32,
+    .availSlot_flag = 0,
+    .mboot_flag = 0,
     .serialNo = 0x0002,
-    .gname = &gHostRFUtgtGnameBuffer,
-    .uname = gHostRFUtgtUnameBuffer,
-    .unk_10 = 0x01,
-    .unk_11 = 0x00,
-    .unk_12 = 0x0258,
-    .unk_14 = 0x012c
+    .gameName = (void *)&gHostRFUtgtGnameBuffer,
+    .userName = gHostRFUtgtUnameBuffer,
+    .fastSearchParent_flag = TRUE,
+    .linkRecovery_enable = FALSE,
+    .linkRecovery_period = 600,
+    .NI_failCounter_limit = 300
 };
 
 static const u8 sAvailSlots[] = {
@@ -82,7 +84,7 @@ static const u8 sAvailSlots[] = {
     [4] = AVAIL_SLOT4
 };
 
-static const u32 gUnknown_843EBD4[] = {
+static const u32 sAllBlocksReceived[] = {
     0x000000,
     0x000001,
     0x000003,
@@ -138,8 +140,10 @@ static const struct {
     { gBlockSendBuffer,  40 }
 };
 
-static const u16 gUnknown_843EC8C[] = {
-    0x0002, 0x7f7d, 0xFFFF
+static const u16 sAcceptedSerialNos[] = {
+    0x0002, // Pokemon FR/LG/EM
+    0x7f7d,
+    0xFFFF
 };
 
 static const char sUnref_843EC92[][15] = {
@@ -166,38 +170,38 @@ static const char sUnref_843ED37[][16] = {
 
 static const TaskFunc gUnknown_843ED88[] = {
     sub_80FA834,
-    sub_80FAA94,
+    Task_ExchangeLinkPlayers,
     sub_80FACF0
 };
 
-static void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2)
+static void rfu_dbg_print_str(const void *string, u8 x, u8 y)
 {
     // debug?
 }
 
-static void nullsub_88(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3)
+static void rfu_dbg_print_num(u16 num, u8 x, u8 y, u8 ndigits)
 {
 
 }
 
-void sub_80F85F8(void)
+void ResetLinkRfuGFLayer(void)
 {
     s32 i;
-    u8 unk_ee_bak = Rfu.unk_ee;
+    u8 errorState_bak = Rfu.errorState;
     CpuFill16(0, &Rfu, sizeof Rfu);
-    Rfu.unk_0c = 0xFF;
-    Rfu.unk_ee = unk_ee_bak;
-    if (Rfu.unk_ee != 4)
+    Rfu.parent_child = MODE_NEUTRAL;
+    Rfu.errorState = errorState_bak;
+    if (Rfu.errorState != 4)
     {
-        Rfu.unk_ee = 0;
+        Rfu.errorState = 0;
     }
     for (i = 0; i < 5; i++)
     {
-        sub_80F9CB4(Rfu.unk_80 + i);
+        ResetSendDataManager(Rfu.cmd_8800_recvbuf + i);
     }
-    sub_80F9CB4(&Rfu.unk_6c);
-    sub_80FC478(&Rfu.unk_124);
-    sub_80FC4D4(&Rfu.unk_9e8);
+    ResetSendDataManager(&Rfu.cmd_8800_sendbuf);
+    RFU_queue_20_70_reset(&Rfu.unk_124);
+    RFU_queue_40_14_reset(&Rfu.unk_9e8);
     CpuFill16(0, gSendCmd, sizeof gSendCmd);
     CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
     CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers);
@@ -218,46 +222,46 @@ void InitRFU(void)
 
 void sub_80F86F4(void)
 {
-    if (!rfu_initializeAPI(&gRfuAPIBuffer, sizeof gRfuAPIBuffer, gIntrTable + 1, TRUE))
+    if (!rfu_initializeAPI(gf_rfu_REQ_api, RFU_API_BUFF_SIZE_RAM, gIntrTable + 1, TRUE))
     {
         gLinkType = 0;
         sub_80FB128(FALSE);
-        sub_80F85F8();
+        ResetLinkRfuGFLayer();
         rfu_setTimerInterrupt(3, gIntrTable + 2);
     }
 }
 
-static void sub_80F8738(u8 taskId)
+static void Task_LinkLeaderSearchForChildren(u8 taskId)
 {
     sub_80FA738();
-    switch (Rfu.unk_04)
+    switch (Rfu.state)
     {
     case 0:
-        sub_80FD4B0(&sRfuReqConfig);
-        Rfu.unk_04 = 1;
+        rfu_LMAN_initializeRFU(&sRfuReqConfig);
+        Rfu.state = 1;
         gTasks[taskId].data[1] = 1;
         break;
     case 1:
         break;
     case 2:
-        sub_80FD538(Rfu.unk_0c, 0, 240, gUnknown_843EC8C);
-        Rfu.unk_04 = 3;
+        rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos);
+        Rfu.state = 3;
         gTasks[taskId].data[1] = 6;
         break;
     case 3:
         break;
     case 4:
-        sub_80FD760(FALSE);
-        Rfu.unk_04 = 5;
+        rfu_LMAN_stopManager(0);
+        Rfu.state = 5;
         break;
     case 5:
         break;
     case 18:
         Rfu.unk_cdb = 0;
-        sub_80FEA10(sub_80F8DA8);
+        rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB);
         sub_80F8AA4();
         sub_80F8AEC();
-        Rfu.unk_04 = 20;
+        Rfu.state = 20;
         gTasks[taskId].data[1] = 8;
         CreateTask(sub_80FA834, 5);
         DestroyTask(taskId);
@@ -282,7 +286,7 @@ static void sub_80F887C(s32 r2, s32 r5)
         {
             if (r2 & 1)
             {
-                Rfu.unk_cde[i] = r4;
+                Rfu.linkPlayerIdx[i] = r4;
                 r4++;
             }
         }
@@ -293,12 +297,12 @@ static void sub_80F887C(s32 r2, s32 r5)
         {
             if (!(r1 & 1))
             {
-                Rfu.unk_cde[i] = 0;
+                Rfu.linkPlayerIdx[i] = 0;
             }
         }
         for (r4 = 4; r4 != 0; r4--)
         {
-            for (i = 0; i < RFU_CHILD_MAX && Rfu.unk_cde[i] != r4; i++);
+            for (i = 0; i < RFU_CHILD_MAX && Rfu.linkPlayerIdx[i] != r4; i++);
             if (i == 4)
             {
                 r6 = r4;
@@ -308,26 +312,26 @@ static void sub_80F887C(s32 r2, s32 r5)
         {
             if (r5 & 1)
             {
-                Rfu.unk_cde[i] = r6++;
+                Rfu.linkPlayerIdx[i] = r6++;
             }
         }
     }
 }
 
-static void sub_80F893C(u8 taskId)
+static void Task_JoinGroupSearchForParent(u8 taskId)
 {
-    switch (Rfu.unk_04)
+    switch (Rfu.state)
     {
     case 0:
-        sub_80FD4B0(&sRfuReqConfigTemplate);
-        Rfu.unk_04 = 1;
+        rfu_LMAN_initializeRFU((INIT_PARAM*)&sRfuReqConfigTemplate);
+        Rfu.state = 1;
         gTasks[taskId].data[1] = 1;
         break;
     case 1:
         break;
     case 6:
-        sub_80FD538(Rfu.unk_0c, 0, 0xf0, gUnknown_843EC8C);
-        Rfu.unk_04 = 7;
+        rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos);
+        Rfu.state = 7;
         gTasks[taskId].data[1] = 7;
         break;
     case 7:
@@ -339,11 +343,11 @@ static void sub_80F893C(u8 taskId)
         switch (sub_80FA788())
         {
         case 5:
-            Rfu.unk_04 = 12;
+            Rfu.state = 12;
             break;
         case 6:
         case 9:
-            sub_80FEB14();
+            rfu_LMAN_requestChangeAgbClockMaster();
             Rfu.unk_ce4 = 2;
             DestroyTask(taskId);
             break;
@@ -351,15 +355,15 @@ static void sub_80F893C(u8 taskId)
         break;
     case 12:
     {
-        u8 r5 = 1 << Rfu.unk_c3e;
-        rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, Rfu.unk_c3e);
-        rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, sizeof(Rfu.unk_c3f));
-        rfu_UNI_setSendData(r5, Rfu.unk_4c, sizeof(Rfu.unk_4c));
+        u8 bmChildSlot = 1 << Rfu.child_slot;
+        rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, Rfu.child_slot);
+        rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f));
+        rfu_UNI_setSendData(bmChildSlot, Rfu.unk_4c, sizeof(Rfu.unk_4c));
         gTasks[taskId].data[1] = 8;
         DestroyTask(taskId);
         if (gUnknown_203AC08.unk_0f == 0)
         {
-            sub_80FC208();
+            rfu_dbg_clear();
             gUnknown_203AC08.unk_0f++;
         }
         CreateTask(sub_80FA834, 5);
@@ -371,56 +375,56 @@ static void sub_80F893C(u8 taskId)
 static void sub_80F8AA4(void)
 {
     u8 i;
-    u8 r5 = gUnknown_3005E10.unk_00;
+    u8 acceptSlot = lman.acceptSlot_flag;
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (r5 & 1)
+        if (acceptSlot & 1)
         {
             rfu_setRecvBuffer(TYPE_UNI, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i]));
             rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, i);
         }
-        r5 >>= 1;
+        acceptSlot >>= 1;
     }
 }
 
 static void sub_80F8AEC(void)
 {
-    u8 r5 = gUnknown_3005E10.unk_00;
-    rfu_UNI_setSendData(r5, Rfu.unk_c87, sizeof(Rfu.unk_c87));
-    Rfu.unk_cda = sub_80F886C(r5);
-    Rfu.unk_ce2 = r5;
-    sub_80F887C(r5, -1);
-    Rfu.unk_0c = 1;
+    u8 acceptSlot = lman.acceptSlot_flag;
+    rfu_UNI_setSendData(acceptSlot, Rfu.recvCmds, sizeof(Rfu.recvCmds));
+    Rfu.unk_cda = sub_80F886C(acceptSlot);
+    Rfu.bm_PartnerFlags = acceptSlot;
+    sub_80F887C(acceptSlot, -1);
+    Rfu.parent_child = MODE_PARENT;
 }
 
-static void sub_80F8B34(u8 taskId)
+static void Task_LinkRfu_UnionRoomListen(u8 taskId)
 {
-    if (sub_80F9800()->unk_0a_0 == 0x54 && sub_80FB9F4() == 4)
+    if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM) && RfuGetErrorStatus() == 4)
     {
-        rfu_REQ_disconnect(gUnknown_3005E10.unk_00);
+        rfu_REQ_disconnect(lman.acceptSlot_flag);
         rfu_waitREQComplete();
-        sub_80FB9E4(0, 0);
+        RfuSetErrorStatus(0, 0);
     }
-    switch (Rfu.unk_04)
+    switch (Rfu.state)
     {
     case 0:
-        sub_80FD4B0(&sRfuReqConfig);
-        Rfu.unk_04 = 1;
+        rfu_LMAN_initializeRFU(&sRfuReqConfig);
+        Rfu.state = 1;
         gTasks[taskId].data[1] = 1;
         break;
     case 1:
         break;
     case 17:
-        sub_80FD538(2, 0, 240, gUnknown_843EC8C);
-        sub_80FEA10(sub_80F8D20);
-        Rfu.unk_04 = 18;
+        rfu_LMAN_establishConnection(2, 0, 240, (u16*)sAcceptedSerialNos);
+        rfu_LMAN_setMSCCallback(MscCallback_Child);
+        Rfu.state = 18;
         break;
     case 18:
         break;
     case 13:
-        if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0)
+        if (rfu_UNI_setSendData(1 << Rfu.child_slot, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0)
         {
-            Rfu.unk_0c = 0;
+            Rfu.parent_child = MODE_CHILD;
             DestroyTask(taskId);
             if (gTasks[taskId].data[7])
             {
@@ -433,20 +437,20 @@ static void sub_80F8B34(u8 taskId)
         }
         break;
     case 14:
-        sub_80FD760(0);
-        Rfu.unk_04 = 15;
+        rfu_LMAN_stopManager(0);
+        Rfu.state = 15;
         break;
     case 15:
         break;
     case 16:
         Rfu.unk_cdb = 0;
-        sub_80FEA10(sub_80F8DA8);
-        sub_80FAFE0(1);
+        rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB);
+        UpdateGameData_GroupLockedIn(1);
         sub_80F8AA4();
         sub_80F8AEC();
-        Rfu.unk_04 = 20;
+        Rfu.state = 20;
         gTasks[taskId].data[1] = 8;
-        Rfu.unk_0c = 1;
+        Rfu.parent_child = MODE_PARENT;
         CreateTask(sub_80FA834, 5);
         Rfu.unk_ce8 = TRUE;
         DestroyTask(taskId);
@@ -454,17 +458,17 @@ static void sub_80F8B34(u8 taskId)
     }
 }
 
-void sub_80F8CFC(void)
+void LinkRfu_CreateConnectionAsParent(void)
 {
-    sub_80FD538(1, 0, 240, gUnknown_843EC8C);
+    rfu_LMAN_establishConnection(MODE_PARENT, 0, 240, (u16*)sAcceptedSerialNos);
 }
 
-void sub_80F8D14(void)
+void LinkRfu_StopManagerBeforeEnteringChat(void)
 {
-    sub_80FD760(FALSE);
+    rfu_LMAN_stopManager(0);
 }
 
-static void sub_80F8D20(u16 unused)
+static void MscCallback_Child(u16 unused)
 {
     s32 i;
 
@@ -474,53 +478,53 @@ static void sub_80F8D20(u16 unused)
     }
     rfu_REQ_recvData();
     rfu_waitREQComplete();
-    if (gRfuSlotStatusUNI[Rfu.unk_c3e]->recv.newDataFlag)
+    if (gRfuSlotStatusUNI[Rfu.child_slot]->recv.newDataFlag)
     {
         Rfu.unk_cd0++;
-        sub_80FC588(&Rfu.unk_124, Rfu.unk_c3f);
+        RFU_queue_20_70_recv(&Rfu.unk_124, Rfu.unk_c3f);
         gUnknown_203AC08.unk_06++;
         sub_80F906C();
-        rfu_UNI_readySendData(Rfu.unk_c3e);
-        rfu_UNI_clearRecvNewDataFlag(Rfu.unk_c3e);
+        rfu_UNI_readySendData(Rfu.child_slot);
+        rfu_UNI_clearRecvNewDataFlag(Rfu.child_slot);
     }
-    LinkRfu_REQ_SendData_HandleParentRelationship(TRUE);
+    rfu_LMAN_REQ_sendData(TRUE);
 }
 
-static void sub_80F8DA8(u16 unused)
+static void MSCCallback_SetUnkCDB(u16 unused)
 {
     Rfu.unk_cdb = 1;
 }
 
-void sub_80F8DC0(void)
+void LinkRfu_Shutdown(void)
 {
     u8 i;
 
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return;
 
-    sub_80FD52C();
-    if (Rfu.unk_0c == 1)
+    rfu_LMAN_powerDownRFU();
+    if (Rfu.parent_child == MODE_PARENT)
     {
-        if (FuncIsActiveTask(sub_80F8738) == TRUE)
+        if (FuncIsActiveTask(Task_LinkLeaderSearchForChildren) == TRUE)
         {
             DestroyTask(Rfu.unk_67);
-            sub_80F85F8();
+            ResetLinkRfuGFLayer();
         }
     }
-    else if (Rfu.unk_0c == 0)
+    else if (Rfu.parent_child == MODE_CHILD)
     {
-        if (FuncIsActiveTask(sub_80F893C) == TRUE)
+        if (FuncIsActiveTask(Task_JoinGroupSearchForParent) == TRUE)
         {
             DestroyTask(Rfu.unk_67);
-            sub_80F85F8();
+            ResetLinkRfuGFLayer();
         }
     }
-    else if (Rfu.unk_0c == 2)
+    else if (Rfu.parent_child == 2)
     {
-        if (FuncIsActiveTask(sub_80F8B34) == TRUE)
+        if (FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE)
         {
             DestroyTask(Rfu.unk_67);
-            sub_80F85F8();
+            ResetLinkRfuGFLayer();
         }
     }
     for (i = 0; i < NELEMS(gUnknown_843ED88); i++)
@@ -532,59 +536,59 @@ void sub_80F8DC0(void)
     }
 }
 
-static void sub_80F8E74(void)
+static void CreateTask_LinkLeaderSearchForChildren(void)
 {
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return;
-    Rfu.unk_67 = CreateTask(sub_80F8738, 1);
+    Rfu.unk_67 = CreateTask(Task_LinkLeaderSearchForChildren, 1);
 }
 
-static bool8 sub_80F8EA4(void)
+static bool8 RfuStateIs7AndPlayerIsChild(void)
 {
-    if (Rfu.unk_04 == 7 && Rfu.unk_ccd)
+    if (Rfu.state == 7 && Rfu.parentId)
     {
         return TRUE;
     }
     return FALSE;
 }
 
-static bool32 sub_80F8ECC(void)
+static bool32 IsParentSuccessfullyReconnected(void)
 {
-    if (Rfu.unk_04 == 7 && !sub_80FD610(gRfuLinkStatus->partner[Rfu.unk_c3d].id, 240))
+    if (Rfu.state == 7 && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[Rfu.reconnectedParentIdx].id, 240))
     {
-        Rfu.unk_04 = 9;
+        Rfu.state = 9;
         return TRUE;
     }
     return FALSE;
 }
 
-static void sub_80F8F10(void)
+static void CreateTask_JoinGroupSearchForParent(void)
 {
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return;
-    Rfu.unk_67 = CreateTask(sub_80F893C, 1);
+    Rfu.unk_67 = CreateTask(Task_JoinGroupSearchForParent, 1);
 }
 
-bool8 sub_80F8F40(void)
+bool8 LmanAcceptSlotFlagIsNotZero(void)
 {
-    if (gUnknown_3005E10.unk_00)
+    if (lman.acceptSlot_flag)
     {
         return TRUE;
     }
     return FALSE;
 }
 
-void sub_80F8F5C(void)
+void LinkRfu_StopManagerAndFinalizeSlots(void)
 {
-    Rfu.unk_04 = 4;
-    Rfu.unk_ce7 = gUnknown_3005E10.unk_00;
+    Rfu.state = 4;
+    Rfu.acceptSlot_flag = lman.acceptSlot_flag;
 }
 
-bool32 sub_80F8F7C(bool32 a0)
+bool32 WaitRfuState(bool32 force)
 {
-    if (Rfu.unk_04 == 17 || a0)
+    if (Rfu.state == 17 || force)
     {
-        Rfu.unk_04 = 18;
+        Rfu.state = 18;
         return TRUE;
     }
     return FALSE;
@@ -592,7 +596,7 @@ bool32 sub_80F8F7C(bool32 a0)
 
 void sub_80F8FA0(void)
 {
-    Rfu.unk_04 = 14;
+    Rfu.state = 14;
 }
 
 static void sub_80F8FAC(u8 a0)
@@ -616,11 +620,11 @@ static void sub_80F8FD4(void)
 
     for (i = 0; i < 5; i++)
     {
-        struct UnkRfuStruct_2 *ptr = &Rfu;
+        GF_RFU_MANAGER *ptr = &Rfu;
         for (j = 0; j < 7; j++)
         {
-            ptr->unk_c87[i][j][1] = gRecvCmds[i][j] >> 8;
-            ptr->unk_c87[i][j][0] = gRecvCmds[i][j];
+            ptr->recvCmds[i][j][1] = gRecvCmds[i][j] >> 8;
+            ptr->recvCmds[i][j][0] = gRecvCmds[i][j];
         }
     }
     CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
@@ -643,8 +647,8 @@ static void sub_80F906C(void)
 {
     if (Rfu.unk_c3c)
     {
-        u8 r2 = sub_80FC888(&Rfu.unk_c1c, Rfu.unk_4c);
-        if (Rfu.unk_c1c.unk_1e == 0)
+        u8 r2 = RFU_queue_2_14_send(&Rfu.unk_c1c, Rfu.unk_4c);
+        if (Rfu.unk_c1c.count == 0)
         {
             Rfu.unk_c3c = 0;
         }
@@ -655,8 +659,8 @@ static void sub_80F906C(void)
     }
     if (Rfu.unk_c3c == 0)
     {
-        sub_80FC79C(&Rfu.unk_9e8, Rfu.unk_4c);
-        sub_80FC828(&Rfu.unk_c1c, Rfu.unk_4c);
+        RFU_queue_40_14_send(&Rfu.unk_9e8, Rfu.unk_4c);
+        RFU_queue_2_14_recv(&Rfu.unk_c1c, Rfu.unk_4c);
     }
 }
 
@@ -684,39 +688,39 @@ bool32 IsRfuRecvQueueEmpty(void)
 
 static bool32 sub_80F911C(void)
 {
-    if (Rfu.unk_04 < 20)
+    if (Rfu.state < 20)
     {
         rfu_REQ_recvData();
         rfu_waitREQComplete();
-        LinkRfu_REQ_SendData_HandleParentRelationship(FALSE);
+        rfu_LMAN_REQ_sendData(FALSE);
     }
     else
     {
         Rfu.unk_cdb = 0;
-        if ((Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag) == Rfu.unk_ce2 && (Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag))
+        if ((Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag) == Rfu.bm_PartnerFlags && (Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag))
         {
             if (!Rfu.unk_cdc)
             {
-                if (Rfu.unk_ce3)
+                if (Rfu.bm_DisconnectSlot)
                 {
-                    sub_80FBCF8(Rfu.unk_ce3);
-                    Rfu.unk_ce3 = 0;
+                    RfuReqDisconnectSlot(Rfu.bm_DisconnectSlot);
+                    Rfu.bm_DisconnectSlot = 0;
                     if (Rfu.unk_ce4 == 1)
                     {
-                        sub_80FB9E4(2, 0x8000);
-                        sub_80FB0E8(0x8000);
+                        RfuSetErrorStatus(2, 0x8000);
+                        GetLinkmanErrorParams(0x8000);
                         return FALSE;
                     }
-                    if (!gUnknown_3005E10.unk_00)
+                    if (!lman.acceptSlot_flag)
                     {
-                        sub_80F8DC0();
+                        LinkRfu_Shutdown();
                         gReceivedRemoteLinkPlayers = 0;
                         return FALSE;
                     }
                 }
                 sub_80F8FD4();
                 rfu_UNI_readySendData(Rfu.unk_cda);
-                LinkRfu_REQ_SendData_HandleParentRelationship(TRUE);
+                rfu_LMAN_REQ_sendData(TRUE);
             }
             else
             {
@@ -736,23 +740,23 @@ static bool32 sub_80F9204(void)
     u16 j;
     u8 retval;
 
-    if (Rfu.unk_04 >= 20 && Rfu.unk_0e == 1)
+    if (Rfu.state >= 20 && Rfu.unk_0e == 1)
     {
         rfu_waitREQComplete();
         while (Rfu.unk_cdb == 0)
         {
-            if (Rfu.unk_ee != 0)
+            if (Rfu.errorState != 0)
             {
                 return FALSE;
             }
         }
         rfu_REQ_recvData();
         rfu_waitREQComplete();
-        if ((gUnknown_3005E10.unk_03 & Rfu.unk_ce2) == Rfu.unk_ce2)
+        if ((lman.parentAck_flag & Rfu.bm_PartnerFlags) == Rfu.bm_PartnerFlags)
         {
             Rfu.unk_cdc = 0;
             gUnknown_203AC08.unk_06++;
-            flags = gUnknown_3005E10.unk_00;
+            flags = lman.acceptSlot_flag;
             for (i = 0; i < RFU_CHILD_MAX; i++)
             {
                 if (flags & 1)
@@ -762,14 +766,14 @@ static bool32 sub_80F9204(void)
                         if (Rfu.unk_cee[i] != 0xFF && (Rfu.unk_14[i][0] >> 5) != ((Rfu.unk_cee[i] + 1) & 7))
                         {
                             if (++Rfu.unk_cea[i] > 4)
-                                sub_80FB0E8(0x8100);
+                                GetLinkmanErrorParams(0x8100);
                         }
                         else
                         {
                             Rfu.unk_cee[i] = Rfu.unk_14[i][0] / 32;
                             Rfu.unk_cea[i] = 0;
                             Rfu.unk_14[i][0] &= 0x1f;
-                            r0 = Rfu.unk_cde[i];
+                            r0 = Rfu.linkPlayerIdx[i];
                             for (j = 0; j < 7; j++)
                             {
                                 gRecvCmds[r0][j] = (Rfu.unk_14[i][(j << 1) + 1] << 8) | Rfu.unk_14[i][(j << 1) + 0];
@@ -783,7 +787,7 @@ static bool32 sub_80F9204(void)
                 flags >>= 1;
             }
             sub_80F9038();
-            sub_80F9868(0);
+            RfuHandleReceiveCommand(0);
             CallRfuFunc();
             if (Rfu.unk_ce5 && !Rfu.unk_cd9)
             {
@@ -796,13 +800,13 @@ static bool32 sub_80F9204(void)
                         rfu_setRecvBuffer(TYPE_UNI, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i]));
                     }
                 }
-                sub_80F887C(Rfu.unk_ce2, Rfu.unk_ce2 | Rfu.unk_ce5);
+                sub_80F887C(Rfu.bm_PartnerFlags, Rfu.bm_PartnerFlags | Rfu.unk_ce5);
                 Rfu.unk_ce9 = Rfu.unk_ce5;
-                Rfu.unk_ce2 |= Rfu.unk_ce5;
+                Rfu.bm_PartnerFlags |= Rfu.unk_ce5;
                 Rfu.unk_ce5 = 0;
-                rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, sizeof(Rfu.unk_c87));
-                Rfu.unk_cda = sub_80F886C(Rfu.unk_ce2);
-                CreateTask(sub_80FAA94, 0);
+                rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, sizeof(Rfu.recvCmds));
+                Rfu.unk_cda = sub_80F886C(Rfu.bm_PartnerFlags);
+                CreateTask(Task_ExchangeLinkPlayers, 0);
             }
         }
         else
@@ -837,7 +841,7 @@ static void sub_80F94BC(u16 *a0, u8 *a1)
     }
 }
 
-static bool32 sub_80F9514(void)
+static bool32 RfuProcessEnqueuedRecvBlock(void)
 {
     u8 i;
     u8 j;
@@ -845,7 +849,7 @@ static bool32 sub_80F9514(void)
     u8 sp48[2 * (CMD_LENGTH - 1)];
     u8 switchval;
 
-    sub_80FC6E8(&Rfu.unk_124, sp00);
+    RFU_queue_20_70_send(&Rfu.unk_124, sp00);
     for (i = 0; i < MAX_RFU_PLAYERS; i++)
     {
         for (j = 0; j < CMD_LENGTH - 1; j++)
@@ -853,23 +857,23 @@ static bool32 sub_80F9514(void)
             gRecvCmds[i][j] = (sp00[i * 14 + (j << 1) + 1] << 8) | sp00[i * 14 + (j << 1) + 0];
         }
     }
-    sub_80F9868(0);
-    if (gUnknown_3005E10.unk_02 == 0 && Rfu.unk_ce4)
+    RfuHandleReceiveCommand(0);
+    if (lman.childClockSlave_flag == 0 && Rfu.unk_ce4)
     {
         rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
         rfu_waitREQComplete();
-        switchval = sub_80FB9F4();
+        switchval = RfuGetErrorStatus();
         if (switchval != 1 && switchval != 6 && switchval != 9)
-            sub_80FB9E4(2, 0x9000);
+            RfuSetErrorStatus(2, 0x9000);
         rfu_clearAllSlot();
         gReceivedRemoteLinkPlayers = FALSE;
         Rfu.RfuFunc = NULL;
         if (Rfu.unk_ce4 == 1)
         {
-            sub_80FB9E4(2, 0x9000);
-            sub_80FB0E8(0x9000);
+            RfuSetErrorStatus(2, 0x9000);
+            GetLinkmanErrorParams(0x9000);
         }
-        gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0;
+        lman.state = lman.next_state = 0;
         Rfu.unk_ce4 = 0;
     }
     if (Rfu.unk_cd0)
@@ -877,36 +881,36 @@ static bool32 sub_80F9514(void)
         Rfu.unk_cd0--;
         CallRfuFunc();
         sub_80F94BC(gSendCmd, sp48);
-        sub_80FC63C(&Rfu.unk_9e8, sp48);
+        RFU_queue_40_14_recv(&Rfu.unk_9e8, sp48);
         for (i = 0; i < CMD_LENGTH - 1; i++)
             gSendCmd[i] = 0;
     }
     return IsRfuRecvQueueEmpty();
 }
 
-static void sub_80F965C(u8 unused, u32 flags)
+static void HandleSendFailure(u8 unused, u32 flags)
 {
     s32 i, j;
 
-    const u8 *r10 = Rfu.unk_6c.unk_04;
-    for (i = 0; i < Rfu.unk_6c.unk_02; i++)
+    const u8 *r10 = Rfu.cmd_8800_sendbuf.payload;
+    for (i = 0; i < Rfu.cmd_8800_sendbuf.count; i++)
     {
         if (!(flags & 1))
         {
-            gUnknown_3002008[0] = (~0x76ff) | i;
+            sResendBlock16[0] = RFU_COMMAND_0x8900 | i;
             for (j = 0; j < 7; j++)
             {
-                gUnknown_3002008[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0];
+                sResendBlock16[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0];
             }
             for (j = 0; j < 7; j++)
             {
-                gUnknown_3001FF8[2 * j + 1] = gUnknown_3002008[j] >> 8;
-                gUnknown_3001FF8[2 * j + 0] = gUnknown_3002008[j];
+                sResendBlock8[2 * j + 1] = sResendBlock16[j] >> 8;
+                sResendBlock8[2 * j + 0] = sResendBlock16[j];
 
                 j++;j--; // Needed to match;
             }
-            sub_80FC63C(&Rfu.unk_9e8, gUnknown_3001FF8);
-            Rfu.unk_6c.unk_0c |= (1 << i);
+            RFU_queue_40_14_recv(&Rfu.unk_9e8, sResendBlock8);
+            Rfu.cmd_8800_sendbuf.failedFlags |= (1 << i);
         }
         flags >>= 1;
     }
@@ -914,7 +918,7 @@ static void sub_80F965C(u8 unused, u32 flags)
 
 void Rfu_SetBlockReceivedFlag(u8 a0)
 {
-    if (Rfu.unk_0c == 1 && a0)
+    if (Rfu.parent_child == MODE_PARENT && a0)
         Rfu.unk_61[a0] = 1;
     else
         Rfu.unk_5c[a0] = 1;
@@ -923,23 +927,23 @@ void Rfu_SetBlockReceivedFlag(u8 a0)
 void Rfu_ResetBlockReceivedFlag(u8 a0)
 {
     Rfu.unk_5c[a0] = 0;
-    Rfu.unk_80[a0].unk_12 = 0;
+    Rfu.cmd_8800_recvbuf[a0].receiving = 0;
 }
 
 static u8 sub_80F9770(const u8 *a0)
 {
     u8 i;
 
-    if (Rfu.unk_0c == 1)
+    if (Rfu.parent_child == MODE_PARENT)
         return FALSE;
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        Rfu.unk_cde[i] = a0[i];
+        Rfu.linkPlayerIdx[i] = a0[i];
     }
-    return a0[Rfu.unk_c3e];
+    return a0[Rfu.child_slot];
 }
 
-static void rfu_func_080F97B8(void)
+static void RfuFunc_SendKeysToRfu(void)
 {
      static u8 gUnknown_3001188;
     if (gReceivedRemoteLinkPlayers
@@ -948,24 +952,24 @@ static void rfu_func_080F97B8(void)
     {
         gUnknown_3001188++;
         gHeldKeyCodeToSend |= (gUnknown_3001188 << 8);
-        sub_80F9D04(0xbe00);
+        RfuPrepareSendBuffer(RFU_COMMAND_0xbe00);
     }
 }
 
-struct GFtgtGname *sub_80F9800(void)
+struct GFtgtGname *GetHostRFUtgtGname(void)
 {
     return &gHostRFUtgtGnameBuffer;
 }
 
 bool32 IsSendingKeysToRfu(void)
 {
-    return Rfu.RfuFunc == rfu_func_080F97B8;
+    return Rfu.RfuFunc == RfuFunc_SendKeysToRfu;
 }
 
-void sub_80F9828(void)
+void StartSendingKeysToRfu(void)
 {
     AGB_ASSERT_EX(Rfu.RfuFunc == NULL, ABSPATH("rfu.c"), 1473);
-    Rfu.RfuFunc = rfu_func_080F97B8;
+    Rfu.RfuFunc = RfuFunc_SendKeysToRfu;
 }
 
 void Rfu_set_zero(void)
@@ -973,7 +977,7 @@ void Rfu_set_zero(void)
     Rfu.RfuFunc = NULL;
 }
 
-static void sub_80F9868(u8 unused)
+static void RfuHandleReceiveCommand(u8 unused)
 {
     u16 i;
     u16 j;
@@ -982,63 +986,63 @@ static void sub_80F9868(u8 unused)
     {
         switch (gRecvCmds[i][0] & 0xff00)
         {
-        case 0x7800:
-            if (Rfu.unk_0c == 0 && gReceivedRemoteLinkPlayers != 0)
+        case RFU_COMMAND_0x7800:
+            if (Rfu.parent_child == MODE_CHILD && gReceivedRemoteLinkPlayers != 0)
                 return;
             // fallthrough
-        case 0x7700:
+        case RFU_COMMAND_0x7700:
             if (gRfuLinkStatus->parentChild == MODE_CHILD)
             {
                 Rfu.playerCount = gRecvCmds[i][1];
                 Rfu.unk_cce = sub_80F9770((u8 *)(gRecvCmds[i] + 2));
             }
             break;
-        case 0x8800:
-            if (Rfu.unk_80[i].unk_12 == 0)
+        case RFU_COMMAND_0x8800:
+            if (Rfu.cmd_8800_recvbuf[i].receiving == 0)
             {
-                Rfu.unk_80[i].unk_00 = 0;
-                Rfu.unk_80[i].unk_02 = gRecvCmds[i][1];
-                Rfu.unk_80[i].unk_11 = gRecvCmds[i][2];
-                Rfu.unk_80[i].unk_08 = 0;
-                Rfu.unk_80[i].unk_12 = 1;
+                Rfu.cmd_8800_recvbuf[i].next = 0;
+                Rfu.cmd_8800_recvbuf[i].count = gRecvCmds[i][1];
+                Rfu.cmd_8800_recvbuf[i].owner = gRecvCmds[i][2];
+                Rfu.cmd_8800_recvbuf[i].receivedFlags = 0;
+                Rfu.cmd_8800_recvbuf[i].receiving = 1;
                 Rfu.unk_5c[i] = 0;
             }
             break;
-        case 0x8900:
-            if (Rfu.unk_80[i].unk_12 == 1)
+        case RFU_COMMAND_0x8900:
+            if (Rfu.cmd_8800_recvbuf[i].receiving == 1)
             {
-                Rfu.unk_80[i].unk_00 = gRecvCmds[i][0] & 0xff;
-                Rfu.unk_80[i].unk_08 |= (1 << Rfu.unk_80[i].unk_00);
+                Rfu.cmd_8800_recvbuf[i].next = gRecvCmds[i][0] & 0xff;
+                Rfu.cmd_8800_recvbuf[i].receivedFlags |= (1 << Rfu.cmd_8800_recvbuf[i].next);
                 for (j = 0; j < 6; j++)
-                    gBlockRecvBuffer[i][Rfu.unk_80[i].unk_00 * 6 + j] = gRecvCmds[i][j + 1];
-                if (Rfu.unk_80[i].unk_08 == gUnknown_843EBD4[Rfu.unk_80[i].unk_02])
+                    gBlockRecvBuffer[i][Rfu.cmd_8800_recvbuf[i].next * 6 + j] = gRecvCmds[i][j + 1];
+                if (Rfu.cmd_8800_recvbuf[i].receivedFlags == sAllBlocksReceived[Rfu.cmd_8800_recvbuf[i].count])
                 {
-                    Rfu.unk_80[i].unk_12 = 2;
+                    Rfu.cmd_8800_recvbuf[i].receiving = 2;
                     Rfu_SetBlockReceivedFlag(i);
-                    if (sub_80F9800()->unk_0a_0 == 0x45 && gReceivedRemoteLinkPlayers != 0 && Rfu.unk_0c == 0)
-                        sub_80FAA58(gBlockRecvBuffer);
+                    if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers != 0 && Rfu.parent_child == MODE_CHILD)
+                        ValidateAndReceivePokemonSioInfo(gBlockRecvBuffer);
                 }
             }
             break;
-        case 0xa100:
+        case RFU_COMMAND_0xa100:
             Rfu_InitBlockSend(gUnknown_843EC64[gRecvCmds[i][1]].buffer, (u16)gUnknown_843EC64[gRecvCmds[i][1]].size);
             break;
-        case 0x5f00:
-            Rfu.unk_e4[i] = 1;
+        case RFU_COMMAND_0x5f00:
+            Rfu.cmd5f00Ack[i] = 1;
             break;
-        case 0x6600:
-            if (Rfu.unk_100 == gRecvCmds[i][1])
-                Rfu.unk_e9[i] = 1;
+        case RFU_COMMAND_0x6600:
+            if (Rfu.cmd_6600_count == gRecvCmds[i][1])
+                Rfu.cmd_6600_recvd[i] = 1;
             break;
-        case 0xed00:
-            if (Rfu.unk_0c == 0)
+        case RFU_COMMAND_0xed00:
+            if (Rfu.parent_child == MODE_CHILD)
             {
                 if (gReceivedRemoteLinkPlayers != 0)
                 {
                     if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag)
                     {
                         gReceivedRemoteLinkPlayers = 0;
-                        sub_80FEB14();
+                        rfu_LMAN_requestChangeAgbClockMaster();
                         Rfu.unk_ce4 = gRecvCmds[i][2];
                     }
                     Rfu.playerCount = gRecvCmds[i][3];
@@ -1047,25 +1051,25 @@ static void sub_80F9868(u8 unused)
             }
             else
             {
-                sub_80F9D04(0xee00);
+                RfuPrepareSendBuffer(RFU_COMMAND_0xee00);
                 gSendCmd[1] = gRecvCmds[i][1];
                 gSendCmd[2] = gRecvCmds[i][2];
                 gSendCmd[3] = gRecvCmds[i][3];
             }
             break;
-        case 0xee00:
-            if (Rfu.unk_0c == 1)
+        case RFU_COMMAND_0xee00:
+            if (Rfu.parent_child == MODE_PARENT)
             {
-                Rfu.unk_ce3 |= gRecvCmds[i][1];
+                Rfu.bm_DisconnectSlot |= gRecvCmds[i][1];
                 Rfu.unk_ce4 = gRecvCmds[i][2];
                 sub_80FA9D0(gRecvCmds[i][1]);
             }
             break;
-        case 0xbe00:
+        case RFU_COMMAND_0xbe00:
             gLinkPartnersHeldKeys[i] = gRecvCmds[i][1];
             break;
         }
-        if (Rfu.unk_0c == 1 && Rfu.unk_61[i])
+        if (Rfu.parent_child == MODE_PARENT && Rfu.unk_61[i])
         {
             if (Rfu.unk_61[i] == 4)
             {
@@ -1078,13 +1082,13 @@ static void sub_80F9868(u8 unused)
     }
 }
 
-static bool8 sub_80F9C50(void)
+static bool8 Cmd8000recvIsFinished(void)
 {
     s32 i;
 
     for (i = 0; i < 5; i++)
     {
-        if (Rfu.unk_80[i].unk_12)
+        if (Rfu.cmd_8800_recvbuf[i].receiving)
             return FALSE;
     }
     return TRUE;
@@ -1096,21 +1100,21 @@ static bool8 sub_80F9C78(void)
 
     for (i = 0; i < Rfu.playerCount; i++)
     {
-        if (Rfu.unk_80[i].unk_12 != 2 || Rfu.unk_5c[i] != 1)
+        if (Rfu.cmd_8800_recvbuf[i].receiving != 2 || Rfu.unk_5c[i] != 1)
             return FALSE;
     }
     return TRUE;
 }
 
-static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data)
+static void ResetSendDataManager(struct RfuBlockSend *data)
 {
-    data->unk_00 = 0;
-    data->unk_02 = 0;
-    data->unk_04 = NULL;
-    data->unk_08 = 0;
-    data->unk_10 = 0;
-    data->unk_11 = 0;
-    data->unk_12 = 0;
+    data->next = 0;
+    data->count = 0;
+    data->payload = NULL;
+    data->receivedFlags = 0;
+    data->sending = 0;
+    data->owner = 0;
+    data->receiving = 0;
 }
 
 u8 Rfu_GetBlockReceivedStatus(void)
@@ -1120,7 +1124,7 @@ u8 Rfu_GetBlockReceivedStatus(void)
 
     for (i = 0; i < 5; i++)
     {
-        if (Rfu.unk_80[i].unk_12 == 2 && Rfu.unk_5c[i] == 1)
+        if (Rfu.cmd_8800_recvbuf[i].receiving == 2 && Rfu.unk_5c[i] == 1)
         {
             flags |= (1 << i);
         }
@@ -1128,7 +1132,7 @@ u8 Rfu_GetBlockReceivedStatus(void)
     return flags;
 }
 
-static void sub_80F9D04(u16 command)
+static void RfuPrepareSendBuffer(u16 command)
 {
     u8 i;
     u8 *buff;
@@ -1137,47 +1141,47 @@ static void sub_80F9D04(u16 command)
     gSendCmd[0] = command;
     switch (command)
     {
-    case 0x8800:
-        gSendCmd[1] = Rfu.unk_6c.unk_02;
-        gSendCmd[2] = Rfu.unk_6c.unk_11 + 0x80;
+    case RFU_COMMAND_0x8800:
+        gSendCmd[1] = Rfu.cmd_8800_sendbuf.count;
+        gSendCmd[2] = Rfu.cmd_8800_sendbuf.owner + 0x80;
         break;
-    case 0xa100:
-        if (sub_80F9C50())
+    case RFU_COMMAND_0xa100:
+        if (Cmd8000recvIsFinished())
             gSendCmd[1] = Rfu.unk_5a;
         break;
-    case 0x7700:
-    case 0x7800:
-        tmp = Rfu.unk_ce2 ^ Rfu.unk_ce3;
+    case RFU_COMMAND_0x7700:
+    case RFU_COMMAND_0x7800:
+        tmp = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot;
         Rfu.playerCount = gUnknown_843EC41[tmp] + 1;
         gSendCmd[1] = Rfu.playerCount;
         buff = (u8 *)(gSendCmd + 2);
         for (i = 0; i < RFU_CHILD_MAX; i++)
-            buff[i] = Rfu.unk_cde[i];
+            buff[i] = Rfu.linkPlayerIdx[i];
         break;
-    case 0x6600:
-    case 0x5f00:
-        gSendCmd[1] = Rfu.unk_100;
+    case RFU_COMMAND_0x6600:
+    case RFU_COMMAND_0x5f00:
+        gSendCmd[1] = Rfu.cmd_6600_count;
         break;
-    case 0x2f00:
+    case RFU_COMMAND_0x2f00:
         for (i = 0; i < 6; i++)
             gSendCmd[1 + i] = Rfu.unk_f2[i];
         break;
-    case 0xbe00:
+    case RFU_COMMAND_0xbe00:
         gSendCmd[1] = gHeldKeyCodeToSend;
         break;
-    case 0xee00:
+    case RFU_COMMAND_0xee00:
         break;
-    case 0xed00:
+    case RFU_COMMAND_0xed00:
         break;
     }
 }
 
-void sub_80F9E2C(void *a0)
+void RfuPrepareSend0x2f00(void * data)
 {
-    if (gSendCmd[0] == 0 && !sub_80FBA00())
+    if (gSendCmd[0] == 0 && !RfuIsErrorStatus1or2())
     {
-        memcpy(Rfu.unk_f2, a0, sizeof(Rfu.unk_f2));
-        sub_80F9D04(0x2f00);
+        memcpy(Rfu.unk_f2, data, sizeof(Rfu.unk_f2));
+        RfuPrepareSendBuffer(RFU_COMMAND_0x2f00);
     }
 }
 
@@ -1189,77 +1193,77 @@ bool32 Rfu_InitBlockSend(const u8 *src, size_t size)
         return FALSE;
     if (gSendCmd[0] != 0)
         return FALSE;
-    if (Rfu.unk_6c.unk_10 != 0)
+    if (Rfu.cmd_8800_sendbuf.sending != 0)
     {
         gUnknown_203AC08.unk_83++;
         return FALSE;
     }
     r4 = (size % 12) != 0;
-    Rfu.unk_6c.unk_11 = GetMultiplayerId();
-    Rfu.unk_6c.unk_10 = 1;
-    Rfu.unk_6c.unk_02 = (size / 12) + r4;
-    Rfu.unk_6c.unk_00 = 0;
-    if (size > 0x100)
-        Rfu.unk_6c.unk_04 = src;
+    Rfu.cmd_8800_sendbuf.owner = GetMultiplayerId();
+    Rfu.cmd_8800_sendbuf.sending = 1;
+    Rfu.cmd_8800_sendbuf.count = (size / 12) + r4;
+    Rfu.cmd_8800_sendbuf.next = 0;
+    if (size > 0x100) // should never be reached
+        Rfu.cmd_8800_sendbuf.payload = src;
     else
     {
         if (src != gBlockSendBuffer)
             memcpy(gBlockSendBuffer, src, size);
-        Rfu.unk_6c.unk_04 = gBlockSendBuffer;
+        Rfu.cmd_8800_sendbuf.payload = gBlockSendBuffer;
     }
-    sub_80F9D04(0x8800);
-    Rfu.RfuFunc = rfufunc_80F9F44;
+    RfuPrepareSendBuffer(RFU_COMMAND_0x8800);
+    Rfu.RfuFunc = RfuFunc_HandleBlockSend;
     Rfu.unk_5b = 0;
     return TRUE;
 }
 
-static void rfufunc_80F9F44(void)
+static void RfuFunc_HandleBlockSend(void)
 {
     if (gSendCmd[0] == 0)
     {
-        sub_80F9D04(0x8800);
-        if (Rfu.unk_0c == 1)
+        RfuPrepareSendBuffer(RFU_COMMAND_0x8800);
+        if (Rfu.parent_child == MODE_PARENT)
         {
             if (++Rfu.unk_5b > 2)
-                Rfu.RfuFunc = sub_80F9FA8;
+                Rfu.RfuFunc = RfuFunc_SendNextBlock;
         }
         else
         {
-            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == 0x8800)
-                Rfu.RfuFunc = sub_80F9FA8;
+            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFU_COMMAND_0x8800)
+                Rfu.RfuFunc = RfuFunc_SendNextBlock;
         }
     }
 }
-static void sub_80F9FA8(void)
+static void RfuFunc_SendNextBlock(void)
 {
     s32 i;
-    const u8 *src = Rfu.unk_6c.unk_04;
-    gSendCmd[0] = 0x8900 | Rfu.unk_6c.unk_00;
+    const u8 *src = Rfu.cmd_8800_sendbuf.payload;
+    gSendCmd[0] = RFU_COMMAND_0x8900 | Rfu.cmd_8800_sendbuf.next;
     for (i = 0; i < 7; i++)
-        gSendCmd[i + 1] = (src[(i << 1) + Rfu.unk_6c.unk_00 * 12 + 1] << 8) | src[(i << 1) + Rfu.unk_6c.unk_00 * 12 + 0];
-    Rfu.unk_6c.unk_00++;
-    if (Rfu.unk_6c.unk_02 <= Rfu.unk_6c.unk_00)
+        gSendCmd[i + 1] = (src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 1] << 8) | src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 0];
+    Rfu.cmd_8800_sendbuf.next++;
+    if (Rfu.cmd_8800_sendbuf.count <= Rfu.cmd_8800_sendbuf.next)
     {
-        Rfu.unk_6c.unk_10 = 0;
-        Rfu.RfuFunc = rfufunc_80FA020;
+        Rfu.cmd_8800_sendbuf.sending = 0;
+        Rfu.RfuFunc = RfuFunc_SendLastBlock;
     }
 }
 
-static void rfufunc_80FA020(void)
+static void RfuFunc_SendLastBlock(void)
 {
-    const u8 *src = Rfu.unk_6c.unk_04;
+    const u8 *src = Rfu.cmd_8800_sendbuf.payload;
     u8 mpId = GetMultiplayerId();
     s32 i;
-    if (Rfu.unk_0c == 0)
+    if (Rfu.parent_child == MODE_CHILD)
     {
-        gSendCmd[0] = (~0x76ff) | (Rfu.unk_6c.unk_02 - 1);
+        gSendCmd[0] = RFU_COMMAND_0x8900 | (Rfu.cmd_8800_sendbuf.count - 1);
         for (i = 0; i < 7; i++)
-            gSendCmd[i + 1] = (src[(i << 1) + (Rfu.unk_6c.unk_02 - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.unk_6c.unk_02 - 1) * 12 + 0];
-        if ((u8)gRecvCmds[mpId][0] == Rfu.unk_6c.unk_02 - 1)
+            gSendCmd[i + 1] = (src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 0];
+        if ((u8)gRecvCmds[mpId][0] == Rfu.cmd_8800_sendbuf.count - 1)
         {
-            if (Rfu.unk_80[mpId].unk_08 != gUnknown_843EBD4[Rfu.unk_80[mpId].unk_02])
+            if (Rfu.cmd_8800_recvbuf[mpId].receivedFlags != sAllBlocksReceived[Rfu.cmd_8800_recvbuf[mpId].count])
             {
-                sub_80F965C(mpId, Rfu.unk_80[mpId].unk_08);
+                HandleSendFailure(mpId, Rfu.cmd_8800_recvbuf[mpId].receivedFlags);
                 gUnknown_203AC08.unk_64++;
             }
             else
@@ -1273,45 +1277,45 @@ static void rfufunc_80FA020(void)
 bool8 sub_80FA0F8(u8 a0)
 {
     Rfu.unk_5a = a0;
-    sub_80F9D04(0xa100);
+    RfuPrepareSendBuffer(RFU_COMMAND_0xa100);
     return TRUE;
 }
 
-static void sub_80FA114(void)
+static void RfuFunc_End5F00_PowerDownRfu(void)
 {
     rfu_clearAllSlot();
-    sub_80FD52C();
+    rfu_LMAN_powerDownRFU();
     gReceivedRemoteLinkPlayers = 0;
     Rfu.unk_ef = 1;
     Rfu.RfuFunc = NULL;
 }
 
-static void sub_80FA140(void)
+static void RfuFunc_End5F00_ParentDisconnect(void)
 {
     rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
     rfu_waitREQComplete();
-    sub_80FA114();
+    RfuFunc_End5F00_PowerDownRfu();
 }
 
-static void sub_80FA160(void)
+static void RfuFunc_End5F00(void)
 {
-    if (Rfu.unk_0c == 0)
+    if (Rfu.parent_child == MODE_CHILD)
     {
-        sub_80FEB14();
+        rfu_LMAN_requestChangeAgbClockMaster();
         Rfu.unk_ce4 = 2;
     }
     else
-        Rfu.RfuFunc = sub_80FA140;
+        Rfu.RfuFunc = RfuFunc_End5F00_ParentDisconnect;
 }
 
 void LinkRfu_FatalError(void)
 {
-    sub_80FEB14();
+    rfu_LMAN_requestChangeAgbClockMaster();
     Rfu.unk_ce4 = 1;
-    Rfu.unk_ce3 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+    Rfu.bm_DisconnectSlot = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
 }
 
-static void sub_80FA1C4(void)
+static void RfuFunc_WaitAck5F00(void)
 {
     s32 i;
     u8 playerCount = Rfu.playerCount;
@@ -1319,132 +1323,132 @@ static void sub_80FA1C4(void)
 
     for (i = 0; i < MAX_RFU_PLAYERS; i++)
     {
-        if (Rfu.unk_e4[i])
+        if (Rfu.cmd5f00Ack[i])
             count++;
     }
     if (count == playerCount)
     {
-        gBattleTypeFlags &= (u16)~BATTLE_TYPE_20;
-        if (Rfu.unk_0c == 0)
+        gBattleTypeFlags &= ~(BATTLE_TYPE_20 | 0xFFFF0000);
+        if (Rfu.parent_child == MODE_CHILD)
         {
-            Rfu.unk_ee = 3;
-            sub_80FA160();
+            Rfu.errorState = 3;
+            RfuFunc_End5F00();
         }
         else
-            Rfu.RfuFunc = sub_80FA160;
+            Rfu.RfuFunc = RfuFunc_End5F00;
     }
 }
 
-static void sub_80FA224(void)
+static void RfuFunc_BuildCommand5F00(void)
 {
     if (gSendCmd[0] == 0 && !Rfu.unk_ce8)
     {
-        sub_80F9D04(0x5f00);
-        Rfu.RfuFunc = sub_80FA1C4;
+        RfuPrepareSendBuffer(RFU_COMMAND_0x5f00);
+        Rfu.RfuFunc = RfuFunc_WaitAck5F00;
     }
 }
 
-static void sub_80FA25C(u8 taskId)
+static void Task_WaitRfuFuncAndSetBuildCmd5F00(u8 taskId)
 {
     if (Rfu.RfuFunc == NULL)
     {
         Rfu.unk_cd9 = 1;
-        Rfu.RfuFunc = sub_80FA224;
+        Rfu.RfuFunc = RfuFunc_BuildCommand5F00;
         DestroyTask(taskId);
     }
 }
 
-void task_add_05_task_del_08FA224_when_no_RfuFunc(void)
+void Rfu_BeginBuildAndSendCommand5F(void)
 {
-    if (!FuncIsActiveTask(sub_80FA25C))
-        CreateTask(sub_80FA25C, 5);
+    if (!FuncIsActiveTask(Task_WaitRfuFuncAndSetBuildCmd5F00))
+        CreateTask(Task_WaitRfuFuncAndSetBuildCmd5F00, 5);
 }
 
-static void sub_80FA2B0(void)
+static void RfuFunc_Send6600_3(void)
 {
     u8 playerCount;
     u8 i;
 
-    if (GetMultiplayerId() != 0)
+    if (GetMultiplayerId() != 0) // child
     {
-        if (Rfu.unk_124.unk_8c2 == 0 && Rfu.unk_fe > 0x3c)
+        if (Rfu.unk_124.count == 0 && Rfu.cmd_6600_timer > 60)
         {
-            sub_80F9D04(0x6600);
-            Rfu.unk_fe = 0;
+            RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+            Rfu.cmd_6600_timer = 0;
         }
     }
     playerCount = GetLinkPlayerCount();
     for (i = 0; i < playerCount; i++)
     {
-        if (Rfu.unk_e9[i] == 0)
+        if (Rfu.cmd_6600_recvd[i] == 0)
             break;
     }
     if (i == playerCount)
     {
         for (i = 0; i < MAX_RFU_PLAYERS; i++)
-            Rfu.unk_e9[i] = 0;
-        Rfu.unk_100++;
+            Rfu.cmd_6600_recvd[i] = 0;
+        Rfu.cmd_6600_count++;
         Rfu.RfuFunc = NULL;
     }
-    Rfu.unk_fe++;
+    Rfu.cmd_6600_timer++;
 }
 
-static void sub_80FA350(void)
+static void RfuFunc_Send6600_2(void)
 {
-    if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+    if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
     {
-        sub_80F9D04(0x6600);
-        Rfu.RfuFunc = sub_80FA2B0;
+        RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+        Rfu.RfuFunc = RfuFunc_Send6600_3;
     }
 }
 
-static void sub_80FA388(void)
+static void RfuFunc_Send6600_1(void)
 {
     u8 i;
     u8 playerCount;
 
-    if (GetMultiplayerId() != 0)
+    if (GetMultiplayerId() != 0) // child
     {
-        if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+        if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
         {
-            sub_80F9D04(0x6600);
-            Rfu.RfuFunc = sub_80FA2B0;
+            RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+            Rfu.RfuFunc = RfuFunc_Send6600_3;
         }
     }
-    else
+    else // parent
     {
         playerCount = GetLinkPlayerCount();
         for (i = 1; i < playerCount; i++)
         {
-            if (Rfu.unk_e9[i] == 0)
+            if (Rfu.cmd_6600_recvd[i] == 0)
                 break;
         }
         if (i == playerCount)
         {
-            if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+            if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
             {
-                sub_80F9D04(0x6600);
-                Rfu.RfuFunc = sub_80FA350;
+                RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+                Rfu.RfuFunc = RfuFunc_Send6600_2;
             }
         }
     }
 }
 
-void sub_80FA42C(void)
+void LinkRfu_SetRfuFuncToSend6600(void)
 {
     if (Rfu.RfuFunc == NULL)
     {
-        Rfu.RfuFunc = sub_80FA388;
-        Rfu.unk_fe = 0;
+        Rfu.RfuFunc = RfuFunc_Send6600_1;
+        Rfu.cmd_6600_timer = 0;
     }
 }
 
-bool32 sub_80FA44C(u32 a0)
+bool32 RfuSerialNumberIsValid(u32 serialNo)
 {
     s32 i;
-    for (i = 0; gUnknown_843EC8C[i] != a0; i++)
+    for (i = 0; sAcceptedSerialNos[i] != serialNo; i++)
     {
-        if (gUnknown_843EC8C[i] == 0xFFFF)
+        if (sAcceptedSerialNos[i] == 0xFFFF)
             return FALSE;
     }
     return TRUE;
@@ -1453,20 +1457,20 @@ bool32 sub_80FA44C(u32 a0)
 u8 sub_80FA484(bool32 a0)
 {
     if (!a0)
-        return sub_80FEA34(0, 0);
-    sub_80FEA34(1, 0x258);
+        return rfu_LMAN_setLinkRecovery(0, 0);
+    rfu_LMAN_setLinkRecovery(1, 600);
     return 0;
 }
 
 void sub_80FA4A8(void)
 {
     Rfu.unk_cd9 = 1;
-    sub_80FD760(FALSE);
+    rfu_LMAN_stopManager(0);
 }
 
 u8 LinkRfu_GetMultiplayerId(void)
 {
-    if (Rfu.unk_0c == 1)
+    if (Rfu.parent_child == MODE_PARENT)
         return 0;
     return Rfu.unk_cce;
 }
@@ -1507,7 +1511,7 @@ static bool8 sub_80FA528(void)
                 }
 
             }
-            else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED)
+            else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED)
             {
                 rfu_clearSlot(TYPE_NI_RECV, i);
             }
@@ -1541,9 +1545,9 @@ bool32 sub_80FA5D4(void)
     return FALSE;
 }
 
-bool32 sub_80FA634(u16 a0, const u8 *a1)
+bool32 TrainerIdAndNameStillInPartnersList(u16 trainerId, const u8 *trainerName)
 {
-    u8 r1 = sub_80FBC70(a1, a0);
+    u8 r1 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId);
     if (r1 == 0xFF)
         return TRUE;
     if (Rfu.unk_cd1[r1] == 9)
@@ -1551,27 +1555,27 @@ bool32 sub_80FA634(u16 a0, const u8 *a1)
     return FALSE;
 }
 
-void sub_80FA670(u8 a0, u16 a1, const u8 *a2)
+void SendByteToPartnerByIdAndName(u8 value, u16 trainerId, const u8 *trainerName)
 {
-    u8 r4 = sub_80FBC70(a2, a1);
-    Rfu.unk_cd1[r4] = a0;
-    rfu_clearSlot(TYPE_NI_SEND, r4);
-    rfu_NI_setSendData(1 << r4, 8, Rfu.unk_cd1 + r4, 1);
+    u8 slotNo = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId);
+    Rfu.unk_cd1[slotNo] = value;
+    rfu_clearSlot(TYPE_NI_SEND, slotNo);
+    rfu_NI_setSendData(1 << slotNo, 8, Rfu.unk_cd1 + slotNo, 1);
 }
 
-void sub_80FA6BC(void)
+void LinkRfuNIsend8(void)
 {
     Rfu.unk_c85 = 8;
-    rfu_clearSlot(TYPE_NI_SEND, Rfu.unk_c3e);
-    rfu_NI_setSendData(1 << Rfu.unk_c3e, 8, &Rfu.unk_c85, 1);
+    rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot);
+    rfu_NI_setSendData(1 << Rfu.child_slot, 8, &Rfu.unk_c85, 1);
 }
 
-u32 sub_80FA6FC(u16 a0, const u8 *a1)
+u32 WaitSendByteToPartnerByIdAndName(u16 trainerId, const u8 *trainerName)
 {
-    u8 r0 = sub_80FBC70(a1, a0);
+    u8 r0 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId);
     if (r0 == 0xFF)
         return 2;
-    if (gRfuSlotStatusNI[r0]->send.state == 0)
+    if (gRfuSlotStatusNI[r0]->send.state == SLOT_STATE_READY)
         return 1;
     return 0;
 }
@@ -1597,18 +1601,18 @@ static s32 sub_80FA788(void)
     s32 retval = 0;
     if (Rfu.unk_c85 == 8)
     {
-        if (gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == SLOT_STATE_SEND_FAILED)
-            rfu_clearSlot(TYPE_NI_SEND, Rfu.unk_c3e);
+        if (gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_FAILED)
+            rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot);
     }
-    if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN)
+    if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN)
     {
-        rfu_clearSlot(TYPE_NI_RECV, Rfu.unk_c3e);
-        sub_80FB9E4(Rfu.unk_c86, 0);
+        rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot);
+        RfuSetErrorStatus(Rfu.unk_c86, 0);
         retval = Rfu.unk_c86;
     }
-    else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED)
+    else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED)
     {
-        rfu_clearSlot(TYPE_NI_RECV, Rfu.unk_c3e);
+        rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot);
         retval = 6;
     }
     return retval;
@@ -1626,20 +1630,20 @@ static void sub_80FA834(u8 taskId)
     switch (gTasks[taskId].data[0])
     {
     case 0:
-        if (sub_80F9C50())
+        if (Cmd8000recvIsFinished())
         {
             ResetBlockReceivedFlags();
-            sub_800B0B4();
+            PrepareLocalLinkPlayerBlock();
             gTasks[taskId].data[0]++;
         }
         break;
     case 1:
-        if (Rfu.unk_0c == 1)
+        if (Rfu.parent_child == MODE_PARENT)
         {
             if (gReceivedRemoteLinkPlayers)
-                sub_80F9D04(0x7800);
+                RfuPrepareSendBuffer(RFU_COMMAND_0x7800);
             else
-                sub_80F9D04(0x7700);
+                RfuPrepareSendBuffer(RFU_COMMAND_0x7700);
             gTasks[taskId].data[0] = 101;
         }
         else
@@ -1654,12 +1658,12 @@ static void sub_80FA834(u8 taskId)
             gTasks[taskId].data[0]++;
         break;
     case 3:
-        if (Rfu.unk_0c == 1)
+        if (Rfu.parent_child == MODE_PARENT)
         {
-            if (sub_80F9C50())
+            if (Cmd8000recvIsFinished())
             {
                 Rfu.unk_5a = 0;
-                sub_80F9D04(0xa100);
+                RfuPrepareSendBuffer(RFU_COMMAND_0xa100);
                 gTasks[taskId].data[0]++;
             }
         }
@@ -1673,7 +1677,7 @@ static void sub_80FA834(u8 taskId)
     case 5:
         for (i = 0; i < Rfu.playerCount; i++)
         {
-            sub_800B110(i);
+            LinkPlayerFromBlock(i);
             Rfu_ResetBlockReceivedFlag(i);
         }
         gTasks[taskId].data[0]++;
@@ -1682,15 +1686,15 @@ static void sub_80FA834(u8 taskId)
         DestroyTask(taskId);
         gReceivedRemoteLinkPlayers = 1;
         Rfu.unk_ce8 = FALSE;
-        sub_80FEA34(1, 0x258);
-        if (Rfu.unk_ce6)
+        rfu_LMAN_setLinkRecovery(1, 600);
+        if (Rfu.unionRoomChatters)
         {
             for (i = 0; i < RFU_CHILD_MAX; i++)
             {
-                if ((Rfu.unk_ce6 >> i) & 1)
+                if ((Rfu.unionRoomChatters >> i) & 1)
                 {
                     Rfu.unk_ce5 = 1 << i;
-                    Rfu.unk_ce6 ^= (1 << i);
+                    Rfu.unionRoomChatters ^= (1 << i);
                 }
             }
         }
@@ -1705,39 +1709,39 @@ static void sub_80FA9D0(u16 a0)
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
         if ((a0 >> i) & 1)
-            Rfu.unk_cde[i] = 0;
+            Rfu.linkPlayerIdx[i] = 0;
     }
 }
 
-static void sub_80FA9FC(const struct UnkRfuStruct_8010A14 *a0)
+static void ReceiveRfuLinkPlayers(const struct SioInfo *chunk)
 {
     s32 i;
-    Rfu.playerCount = a0->unk_0f;
+    Rfu.playerCount = chunk->playerCount;
     for (i = 0; i < RFU_CHILD_MAX; i++)
-        Rfu.unk_cde[i] = a0->unk_10[i];
+        Rfu.linkPlayerIdx[i] = chunk->linkPlayerIdx[i];
     for (i = 0; i < MAX_RFU_PLAYERS; i++)
     {
-        gLinkPlayers[i] = a0->unk_14[i];
-        sub_800B284(gLinkPlayers + i);
+        gLinkPlayers[i] = chunk->linkPlayers[i];
+        IntlConvertLinkPlayerName(gLinkPlayers + i);
     }
 }
 
-static void sub_80FAA58(void *a0)
+static void ValidateAndReceivePokemonSioInfo(void *recvBuffer)
 {
-    if (strcmp("PokemonSioInfo", ((struct UnkRfuStruct_8010A14 *)a0)->unk_00) == 0)
+    if (strcmp("PokemonSioInfo", recvBuffer) == 0)
     {
-        sub_80FA9FC(a0);
-        CpuFill16(0, a0, sizeof(struct UnkRfuStruct_8010A14));
+        ReceiveRfuLinkPlayers(recvBuffer);
+        CpuFill16(0, recvBuffer, sizeof(struct SioInfo));
         ResetBlockReceivedFlag(0);
     }
 }
 
-static void sub_80FAA94(u8 taskId)
+static void Task_ExchangeLinkPlayers(u8 taskId)
 {
     s32 i;
     struct LinkPlayerBlock *r2;
-    struct UnkRfuStruct_8010A14 *r5;
-    u8 r4 = Rfu.unk_cde[gUnknown_843EC38[Rfu.unk_ce9]];
+    struct SioInfo *r5;
+    u8 r4 = Rfu.linkPlayerIdx[gUnknown_843EC38[Rfu.unk_ce9]];
     if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2)
     {
         Rfu.unk_ce8 = FALSE;
@@ -1749,7 +1753,7 @@ static void sub_80FAA94(u8 taskId)
         if (gSendCmd[0] == 0)
         {
             ResetBlockReceivedFlag(r4);
-            sub_80F9D04(0x7800);
+            RfuPrepareSendBuffer(RFU_COMMAND_0x7800);
             gTasks[taskId].data[0]++;
         }
         break;
@@ -1763,42 +1767,43 @@ static void sub_80FAA94(u8 taskId)
             ResetBlockReceivedFlag(r4);
             r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4];
             gLinkPlayers[r4] = r2->linkPlayer;
-            sub_800B284(gLinkPlayers + r4);
+            IntlConvertLinkPlayerName(gLinkPlayers + r4);
             gTasks[taskId].data[0]++;
         }
         break;
     case 3:
-        r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
-        memcpy(r5->unk_00, "PokemonSioInfo", sizeof("PokemonSioInfo"));
-        r5->unk_0f = Rfu.playerCount;
+        // Prepare send block
+        r5 = (struct SioInfo *)gBlockSendBuffer;
+        memcpy(r5->magic, "PokemonSioInfo", sizeof("PokemonSioInfo"));
+        r5->playerCount = Rfu.playerCount;
         for (i = 0; i < RFU_CHILD_MAX; i++)
-            r5->unk_10[i] = Rfu.unk_cde[i];
-        memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers);
+            r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i];
+        memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers);
         gTasks[taskId].data[0]++;
         // fallthrough
     case 4:
-        r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
-        r5->unk_0f = Rfu.playerCount;
+        r5 = (struct SioInfo *)gBlockSendBuffer;
+        r5->playerCount = Rfu.playerCount;
         for (i = 0; i < RFU_CHILD_MAX; i++)
-            r5->unk_10[i] = Rfu.unk_cde[i];
-        memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers);
+            r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i];
+        memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers);
         if (SendBlock(0, gBlockSendBuffer, 0xa0))
             gTasks[taskId].data[0]++;
         break;
     case 5:
         if (IsLinkTaskFinished() && GetBlockReceivedStatus() & 1)
         {
-            CpuFill16(0, gBlockRecvBuffer, sizeof(struct UnkRfuStruct_8010A14));
+            CpuFill16(0, gBlockRecvBuffer, sizeof(struct SioInfo));
             ResetBlockReceivedFlag(0);
             Rfu.unk_ce8 = FALSE;
-            if (Rfu.unk_ce6)
+            if (Rfu.unionRoomChatters)
             {
                 for (i = 0; i < RFU_CHILD_MAX; i++)
                 {
-                    if ((Rfu.unk_ce6 >> i) & 1)
+                    if ((Rfu.unionRoomChatters >> i) & 1)
                     {
                         Rfu.unk_ce5 = 1 << i;
-                        Rfu.unk_ce6 ^= (1 << i);
+                        Rfu.unionRoomChatters ^= (1 << i);
                         Rfu.unk_ce8 = TRUE;
                         break;
                     }
@@ -1819,7 +1824,7 @@ static void sub_80FACF0(u8 taskId)
     case 0:
         if (Rfu.playerCount)
         {
-            sub_800B0B4();
+            PrepareLocalLinkPlayerBlock();
             SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock));
             gTasks[taskId].data[0]++;
         }
@@ -1831,7 +1836,7 @@ static void sub_80FACF0(u8 taskId)
     case 2:
         if (GetBlockReceivedStatus() & 1)
         {
-            sub_80FA9FC((const struct UnkRfuStruct_8010A14 *)gBlockRecvBuffer);
+            ReceiveRfuLinkPlayers((const struct SioInfo *)gBlockRecvBuffer);
             ResetBlockReceivedFlag(0);
             gReceivedRemoteLinkPlayers = 1;
             DestroyTask(taskId);
@@ -1840,51 +1845,51 @@ static void sub_80FACF0(u8 taskId)
     }
 }
 
-static void sub_80FAD98(void)
+static void RfuCheckErrorStatus(void)
 {
-    if (Rfu.unk_ee == 1 && gUnknown_3005E10.unk_02 == 0)
+    if (Rfu.errorState == 1 && lman.childClockSlave_flag == 0)
     {
         if (gMain.callback2 == c2_mystery_gift_e_reader_run)
             gWirelessCommType = 2;
         SetMainCallback2(CB2_LinkError);
         gMain.savedCallback = CB2_LinkError;
-        sub_800ACBC((Rfu.unk_0a << 16) | (Rfu.unk_10 << 8) | Rfu.unk_12, Rfu.unk_124.unk_8c2, Rfu.unk_9e8.unk_232, sub_80FB9F4() == 2);
-        Rfu.unk_ee = 2;
+        SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.unk_9e8.count, RfuGetErrorStatus() == 2);
+        Rfu.errorState = 2;
         CloseLink();
     }
-    else if (Rfu.unk_9e8.unk_233 == 1 || Rfu.unk_124.unk_8c3 == 1)
+    else if (Rfu.unk_9e8.full == 1 || Rfu.unk_124.full == 1)
     {
-        if (gUnknown_3005E10.unk_02)
-            sub_80FEB14();
-        sub_80FB9E4(1, 0x7000);
-        sub_80FB0E8(0x7000);
+        if (lman.childClockSlave_flag)
+            rfu_LMAN_requestChangeAgbClockMaster();
+        RfuSetErrorStatus(1, 0x7000);
+        GetLinkmanErrorParams(0x7000);
     }
 }
 
 static void rfu_REQ_recvData_then_sendData(void)
 {
-    if (gUnknown_3005E10.unk_06 == 1)
+    if (lman.parent_child == MODE_PARENT)
     {
         rfu_REQ_recvData();
         rfu_waitREQComplete();
-        LinkRfu_REQ_SendData_HandleParentRelationship(0);
+        rfu_LMAN_REQ_sendData(RFU_CHILD_CLOCK_SLAVE_OFF);
     }
 }
 
-bool32 sub_80FAE94(void)
+bool32 LinkRfuMain1(void)
 {
     bool32 retval = FALSE;
-    Rfu.unk_ccd = 0;
-    sub_80FDA30(Random());
+    Rfu.parentId = 0;
+    rfu_LMAN_manager_entity(Random());
     if (Rfu.unk_ef == 0)
     {
-        switch (Rfu.unk_0c)
+        switch (Rfu.parent_child)
         {
         case 1:
             sub_80F911C();
             break;
         case 0:
-            retval = sub_80F9514();
+            retval = RfuProcessEnqueuedRecvBlock();
             break;
         case 2:
             rfu_REQ_recvData_then_sendData();
@@ -1894,19 +1899,19 @@ bool32 sub_80FAE94(void)
     return retval;
 }
 
-bool32 sub_80FAEF0(void)
+bool32 LinkRfuMain2(void)
 {
     bool32 retval = FALSE;
     if (Rfu.unk_ef == 0)
     {
-        if (Rfu.unk_0c == 1)
+        if (Rfu.parent_child == MODE_PARENT)
             retval = sub_80F9204();
-        sub_80FAD98();
+        RfuCheckErrorStatus();
     }
     return retval;
 }
 
-static void sub_80FAF1C(void)
+static void CopyPlayerNameToUnameBuffer(void)
 {
     StringCopy(gHostRFUtgtUnameBuffer, gSaveBlock2Ptr->playerName);
 }
@@ -1914,94 +1919,96 @@ static void sub_80FAF1C(void)
 void ClearAndInitHostRFUtgtGname(void)
 {
     memset(&gHostRFUtgtGnameBuffer, 0, RFU_GAME_NAME_LENGTH);
-    InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, 0, 0, 0);
+    InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, 0, FALSE, 0);
 }
 
-void SetHostRFUtgtGname(u8 a0, u32 a1, u32 a2)
+void SetHostRFUtgtGname(u8 activity, u32 child_sprite_genders, u32 started)
 {
-    InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, a0, a2, a1);
+    InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, activity, started, child_sprite_genders);
 }
 
-void sub_80FAF74(bool32 a0, bool32 a1)
+void SetGnameBufferWonderFlags(bool32 hasNews, bool32 hasCard)
 {
-    gHostRFUtgtGnameBuffer.unk_00.unk_00_4 = a0;
-    gHostRFUtgtGnameBuffer.unk_00.unk_00_5 = a1;
+    gHostRFUtgtGnameBuffer.unk_00.hasNews = hasNews;
+    gHostRFUtgtGnameBuffer.unk_00.hasCard = hasCard;
 }
 
-void sub_80FAFA0(u32 type, u32 species, u32 level)
+void RfuUpdatePlayerGnameStateAndSend(u32 type, u32 species, u32 level)
 {
     gHostRFUtgtGnameBuffer.type = type;
     gHostRFUtgtGnameBuffer.species = species;
     gHostRFUtgtGnameBuffer.level = level;
 }
 
-void sub_80FAFE0(u8 a0)
+void UpdateGameData_GroupLockedIn(bool8 started)
 {
-    gHostRFUtgtGnameBuffer.unk_0a_7 = a0;
-    rfu_REQ_configGameData(0, 2, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer);
+    gHostRFUtgtGnameBuffer.started = started;
+    rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer);
 }
 
-void sub_80FB008(u8 a0, u32 a1, u32 a2)
+void UpdateGameDataWithActivitySpriteGendersFlag(u8 activity, u32 child_sprite_genders, u32 started)
 {
-    if (a0)
-        SetHostRFUtgtGname(a0, a1, a2);
-    rfu_REQ_configGameData(0, 2, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer);
+    if (activity)
+        SetHostRFUtgtGname(activity, child_sprite_genders, started);
+    rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer);
 }
 
 void sub_80FB030(u32 linkPlayerCount)
 {
     s32 i;
-    u32 r5;
-    u32 r7;
-    s32 r8;
+    u32 numConnectedChildren;
+    u32 child_sprite_genders;
+    s32 bm_child_slots;
 
-    if (sub_80F9800()->unk_0a_0 == 0x45)
+    if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
     {
-        r5 = 0;
-        r7 = 0;
-        r8 = Rfu.unk_ce2 ^ Rfu.unk_ce3;
+        numConnectedChildren = 0;
+        child_sprite_genders = 0;
+        bm_child_slots = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot;
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
-            if ((r8 >> i) & 1)
+            if ((bm_child_slots >> i) & 1)
             {
-                r7 |= ((
-                    0x80 | ((gLinkPlayers[Rfu.unk_cde[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.unk_cde[i]].trainerId & 7)) << (r5 << 3));
-                r5++;
-                if (r5 == linkPlayerCount - 1)
+                // The 0x80 prevents this element from being incorrectly read as a 0.
+                child_sprite_genders |= ((
+                    0x80 | ((gLinkPlayers[Rfu.linkPlayerIdx[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.linkPlayerIdx[i]].trainerId & 7)
+                ) << (numConnectedChildren << 3));
+                numConnectedChildren++;
+                if (numConnectedChildren == linkPlayerCount - 1)
                     break;
             }
         }
-        sub_80FB008(0x45, r7, 0);
+        UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, child_sprite_genders, 0);
     }
 }
 
-static void sub_80FB0E8(u32 a0)
+static void GetLinkmanErrorParams(u32 msg)
 {
-    if (Rfu.unk_ee == 0)
+    if (Rfu.errorState == 0)
     {
-        Rfu.unk_10 = gUnknown_3005E10.unk_14;
-        Rfu.unk_12 = gUnknown_3005E10.unk_16;
-        Rfu.unk_0a = a0;
-        Rfu.unk_ee = 1;
+        Rfu.linkman_param[0] = lman.param[0];
+        Rfu.linkman_param[1] = lman.param[1];
+        Rfu.linkman_msg = msg;
+        Rfu.errorState = 1;
     }
 }
 
-static void sub_80FB118(void)
+static void ResetErrorState(void)
 {
-    Rfu.unk_ee = 0;
+    Rfu.errorState = 0;
 }
 
 void sub_80FB128(bool32 a0)
 {
     if (!a0)
-        Rfu.unk_ee = 0;
+        Rfu.errorState = 0;
     else
-        Rfu.unk_ee = 4;
+        Rfu.errorState = 4;
 }
 
 static void sub_80FB154(void)
 {
-    sub_80FBE20(gUnknown_3005E10.unk_00, 1);
+    sub_80FBE20(lman.acceptSlot_flag, 1);
     Rfu.RfuFunc = NULL;
 }
 
@@ -2010,25 +2017,25 @@ static void sub_80FB174(void)
     Rfu.RfuFunc = sub_80FB154;
 }
 
-static void sub_80FB184(u8 a0, u8 unused1)
+static void LmanCallback_Parent2(u8 msg, u8 param_count)
 {
     u8 i;
-    u8 r6 = 0;
-    switch (a0)
+    u8 bmDisconnectFlag = 0;
+    switch (msg)
     {
-    case 0x00:
-        Rfu.unk_04 = 2;
+    case LMAN_MSG_INITIALIZE_COMPLETED:
+        Rfu.state = 2;
         break;
-    case 0x10:
+    case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED:
         break;
-    case 0x11:
-        sub_80FB564(gUnknown_3005E10.unk_14);
+    case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED:
+        sub_80FB564(lman.param[0]);
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
-            if ((gUnknown_3005E10.unk_14 >> i) & 1)
+            if ((lman.param[0] >> i) & 1)
             {
                 struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname;
-                if (structPtr->unk_0a_0 == sub_80F9800()->unk_0a_0)
+                if (structPtr->activity == GetHostRFUtgtGname()->activity)
                 {
                     Rfu.unk_cd1[i] = 0;
                     Rfu.unk_cd5[i] = 0;
@@ -2036,60 +2043,64 @@ static void sub_80FB184(u8 a0, u8 unused1)
                 }
                 else
                 {
-                    r6 |= (1 << i);
+                    bmDisconnectFlag |= (1 << i);
                 }
             }
         }
-        if (r6)
+        if (bmDisconnectFlag)
         {
-            rfu_REQ_disconnect(r6);
+            rfu_REQ_disconnect(bmDisconnectFlag);
             rfu_waitREQComplete();
         }
         break;
-    case 0x12:
+    case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED:
         break;
-    case 0x13:
+    case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED:
         break;
-    case 0x14:
-        if (Rfu.unk_ce7 != gUnknown_3005E10.unk_00)
+    case LMAN_MSG_END_WAIT_CHILD_NAME:
+        if (Rfu.acceptSlot_flag != lman.acceptSlot_flag)
         {
-            rfu_REQ_disconnect(Rfu.unk_ce7 ^ gUnknown_3005E10.unk_00);
+            rfu_REQ_disconnect(Rfu.acceptSlot_flag ^ lman.acceptSlot_flag);
             rfu_waitREQComplete();
         }
-        Rfu.unk_04 = 0x11;
+        Rfu.state = 17;
         break;
-    case 0x31:
-        Rfu.unk_f0 = 1;
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY:
+        Rfu.linkLossRecoveryState = 1;
         break;
-    case 0x32:
-        Rfu.unk_f0 = 3;
+    case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
+        Rfu.linkLossRecoveryState = 3;
         break;
-    case 0x30:
-    case 0x33:
-        Rfu.unk_f0 = 4;
-        Rfu.unk_ce2 &= ~gUnknown_3005E10.unk_14;
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED:
+    case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
+        Rfu.linkLossRecoveryState = 4;
+        Rfu.bm_PartnerFlags &= ~lman.param[0];
         if (gReceivedRemoteLinkPlayers == 1)
         {
-            if (Rfu.unk_ce2 == 0)
-                sub_80FB0E8(a0);
+            if (Rfu.bm_PartnerFlags == 0)
+                GetLinkmanErrorParams(msg);
             else
                 sub_80FB174();
         }
-        sub_80FB9E4(2, a0);
+        RfuSetErrorStatus(2, msg);
         break;
     case 0x34:
         break;
-    case 0x42 ... 0x44:
+    case LMAN_MSG_RFU_POWER_DOWN:
+    case LMAN_MSG_MANAGER_STOPPED:
+    case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET:
         break;
-    case 0xf3:
-        sub_80FB9E4(1, a0);
-        sub_80FB0E8(a0);
+    case LMAN_MSG_LMAN_API_ERROR_RETURN:
+        RfuSetErrorStatus(1, msg);
+        GetLinkmanErrorParams(msg);
         Rfu.unk_ef = 1;
         break;
-    case 0xf0 ... 0xf2:
-    case 0xff:
-        sub_80FB0E8(a0);
-        sub_80FB9E4(1, a0);
+    case LMAN_MSG_REQ_API_ERROR:
+    case LMAN_MSG_WATCH_DOG_TIMER_ERROR:
+    case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA:
+    case LMAN_MSG_RFU_FATAL_ERROR:
+        GetLinkmanErrorParams(msg);
+        RfuSetErrorStatus(1, msg);
         Rfu.unk_cdb = 1;
         break;
     }
@@ -2097,80 +2108,84 @@ static void sub_80FB184(u8 a0, u8 unused1)
 
 static const u8 unref_843EDF3[] = _("　あきと");
 
-static void sub_80FB37C(u8 a0, u8 unused1)
+static void LmanCallback_Child(u8 msg, u8 param_count)
 {
-    switch (a0)
+    switch (msg)
     {
-    case 0x00:
-        Rfu.unk_04 = 6;
+    case LMAN_MSG_INITIALIZE_COMPLETED:
+        Rfu.state = 6;
         break;
-    case 0x20:
-        Rfu.unk_ccd = gUnknown_3005E10.unk_14;
+    case LMAN_MSG_PARENT_FOUND:
+        Rfu.parentId = lman.param[0];
         break;
-    case 0x21:
+    case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED:
         break;
-    case 0x22:
-        Rfu.unk_c3e = gUnknown_3005E10.unk_14;
+    case LMAN_MSG_CONNECT_PARENT_SUCCESSED:
+        Rfu.child_slot = lman.param[0];
         break;
-    case 0x23:
-        sub_80FB9E4(2, a0);
+    case LMAN_MSG_CONNECT_PARENT_FAILED:
+        RfuSetErrorStatus(2, msg);
         break;
-    case 0x24:
-        Rfu.unk_04 = 11;
+    case LMAN_MSG_CHILD_NAME_SEND_COMPLETED:
+        Rfu.state = 11;
         Rfu.unk_c85 = 0;
         Rfu.unk_c86 = 0;
-        rfu_setRecvBuffer(TYPE_NI, Rfu.unk_c3e, &Rfu.unk_c86, 1);
-        rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, 70);
+        rfu_setRecvBuffer(TYPE_NI, Rfu.child_slot, &Rfu.unk_c86, 1);
+        rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f));
         break;
-    case 0x25:
-        sub_80FB9E4(2, 0x25);
+    case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED:
+        RfuSetErrorStatus(2, msg);
         break;
-    case 0x30:
-        Rfu.unk_f0 = 2;
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED:
+        Rfu.linkLossRecoveryState = 2;
         if (Rfu.unk_c86 == 6)
             break;
-    case 0x33:
-        if (Rfu.unk_f0 != 2)
-            Rfu.unk_f0 = 4;
+    case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
+        if (Rfu.linkLossRecoveryState != 2)
+            Rfu.linkLossRecoveryState = 4;
         if (Rfu.unk_c86 != 9)
-            sub_80FB9E4(2, a0);
-        nullsub_87("LINK LOSS DISCONNECT!", 5, 5);
+            RfuSetErrorStatus(2, msg);
+        rfu_dbg_print_str("LINK LOSS DISCONNECT!", 5, 5);
         if (gReceivedRemoteLinkPlayers == 1)
-            sub_80FB0E8(a0);
+            GetLinkmanErrorParams(msg);
         break;
-    case 0x31:
-        Rfu.unk_f0 = 1;
-        nullsub_87("LINK LOSS RECOVERY NOW", 5, 5);
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY:
+        Rfu.linkLossRecoveryState = 1;
+        rfu_dbg_print_str("LINK LOSS RECOVERY NOW", 5, 5);
         break;
-    case 0x32:
-        Rfu.unk_f0 = 3;
+    case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
+        Rfu.linkLossRecoveryState = 3;
         Rfu.unk_c3c = 1;
         break;
     case 0x34:
         break;
-    case 0x42 ... 0x44:
+    case LMAN_MSG_RFU_POWER_DOWN:
+    case LMAN_MSG_MANAGER_STOPPED:
+    case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET:
         break;
-    case 0xF3:
-        sub_80FB9E4(1, a0);
-        sub_80FB0E8(a0);
+    case LMAN_MSG_LMAN_API_ERROR_RETURN:
+        RfuSetErrorStatus(1, msg);
+        GetLinkmanErrorParams(msg);
         Rfu.unk_ef = 1;
         break;
-    case 0xF0 ... 0xF2:
-    case 0xFF:
-        sub_80FB9E4(1, a0);
-        sub_80FB0E8(a0);
+    case LMAN_MSG_REQ_API_ERROR:
+    case LMAN_MSG_WATCH_DOG_TIMER_ERROR:
+    case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA:
+    case LMAN_MSG_RFU_FATAL_ERROR:
+        RfuSetErrorStatus(1, msg);
+        GetLinkmanErrorParams(msg);
         Rfu.unk_cdb = 1;
         break;
     }
 }
 
-static void sub_80FB564(s32 a0)
+static void sub_80FB564(s32 bmConnectedFlag)
 {
     s32 i;
 
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if ((a0 >> i) & 1)
+        if ((bmConnectedFlag >> i) & 1)
         {
             Rfu.unk_cea[i] = 0;
             Rfu.unk_cee[i] = 0xFF;
@@ -2178,17 +2193,17 @@ static void sub_80FB564(s32 a0)
     }
 }
 
-static u8 sub_80FB5A0(s32 a0)
+static u8 GetNewChildrenInUnionRoomChat(s32 bmNewChildSlot)
 {
     u8 ret = 0;
     u8 i;
 
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if ((a0 >> i) & 1)
+        if ((bmNewChildSlot >> i) & 1)
         {
             struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname;
-            if (structPtr->unk_0a_0 == 0x45)
+            if (structPtr->activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
                 ret |= (1 << i);
         }
     }
@@ -2196,73 +2211,73 @@ static u8 sub_80FB5A0(s32 a0)
     return ret;
 }
 
-static void sub_80FB5EC(u8 a0, u8 unused1)
+static void LmanCallback_Parent(u8 msg, u8 param_count)
 {
     u8 r1;
 
-    switch (a0)
+    switch (msg)
     {
-    case 0x00:
-        Rfu.unk_04 = 0x11;
+    case LMAN_MSG_INITIALIZE_COMPLETED:
+        Rfu.state = 17;
         break;
-    case 0x10:
-        sub_80FB9E4(4, 0);
+    case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED:
+        RfuSetErrorStatus(4, 0);
         break;
-    case 0x11:
-        if (sub_80F9800()->unk_0a_0 == 0x45 && Rfu.unk_cd9 == 0)
+    case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED:
+        if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && Rfu.unk_cd9 == 0)
         {
-            u8 idx = sub_80FB5A0(gUnknown_3005E10.unk_14);
-            if (idx != 0)
+            u8 bmAcceptSlot = GetNewChildrenInUnionRoomChat(lman.param[0]);
+            if (bmAcceptSlot != 0)
             {
-                r1 = 1 << sub_80F886C(idx);
-                if (Rfu.unk_ce6 == 0 && !Rfu.unk_ce8)
+                r1 = 1 << sub_80F886C(bmAcceptSlot);
+                if (Rfu.unionRoomChatters == 0 && !Rfu.unk_ce8)
                 {
                     Rfu.unk_ce5 = r1;
-                    Rfu.unk_ce6 |= (r1 ^ idx);
+                    Rfu.unionRoomChatters |= (r1 ^ bmAcceptSlot);
                     Rfu.unk_ce8 = TRUE;
                 }
                 else
                 {
-                    Rfu.unk_ce6 |= idx;
+                    Rfu.unionRoomChatters |= bmAcceptSlot;
                 }
             }
-            if (idx != gUnknown_3005E10.unk_14)
+            if (bmAcceptSlot != lman.param[0])
             {
-                Rfu.unk_ce3 |= (idx ^ gUnknown_3005E10.unk_14);
+                Rfu.bm_DisconnectSlot |= (bmAcceptSlot ^ lman.param[0]);
                 Rfu.unk_ce4 = 2;
             }
         }
-        else if (sub_80F9800()->unk_0a_0 == 0x54)
+        else if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM))
         {
-            rfu_REQ_disconnect(gUnknown_3005E10.unk_00);
+            rfu_REQ_disconnect(lman.acceptSlot_flag);
             rfu_waitREQComplete();
         }
-        sub_80FB564(gUnknown_3005E10.unk_14);
+        sub_80FB564(lman.param[0]);
         break;
-    case 0x12:
+    case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED:
         break;
-    case 0x13:
+    case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED:
         break;
-    case 0x14:
-        if (sub_80F9800()->unk_0a_0 != 0x45 && gUnknown_3005E10.unk_01 > 1)
+    case LMAN_MSG_END_WAIT_CHILD_NAME:
+        if (GetHostRFUtgtGname()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1)
         {
-            r1 = 1 << sub_80F886C(gUnknown_3005E10.unk_14);
-            rfu_REQ_disconnect(gUnknown_3005E10.unk_00 ^ r1);
+            r1 = 1 << sub_80F886C(lman.param[0]);
+            rfu_REQ_disconnect(lman.acceptSlot_flag ^ r1);
             rfu_waitREQComplete();
         }
-        if (Rfu.unk_04 == 0xF)
-            Rfu.unk_04 = 0x10;
+        if (Rfu.state == 0xF)
+            Rfu.state = 16;
         break;
-    case 0x20:
-        Rfu.unk_ccd = gUnknown_3005E10.unk_14;
+    case LMAN_MSG_PARENT_FOUND:
+        Rfu.parentId = lman.param[0];
         break;
-    case 0x21:
+    case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED:
         break;
-    case 0x22:
-        Rfu.unk_c3e = gUnknown_3005E10.unk_14;
+    case LMAN_MSG_CONNECT_PARENT_SUCCESSED:
+        Rfu.child_slot = lman.param[0];
         break;
-    case 0x23:
-        Rfu.unk_04 = 0x12;
+    case LMAN_MSG_CONNECT_PARENT_FAILED:
+        Rfu.state = 18;
         if (Rfu.unk_ccf < 2)
         {
             Rfu.unk_ccf++;
@@ -2270,67 +2285,72 @@ static void sub_80FB5EC(u8 a0, u8 unused1)
         }
         else
         {
-            sub_80FB9E4(2, a0);
+            RfuSetErrorStatus(2, msg);
         }
         break;
-    case 0x24:
-        Rfu.unk_04 = 0xD;
-        sub_80FB9E4(3, 0);
-        rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, sizeof(Rfu.unk_c3f));
+    case LMAN_MSG_CHILD_NAME_SEND_COMPLETED:
+        Rfu.state = 13;
+        RfuSetErrorStatus(3, 0);
+        rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f));
         break;
-    case 0x25:
-        sub_80FB9E4(2, a0);
+    case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED:
+        RfuSetErrorStatus(2, msg);
         break;
-    case 0x31:
-        if (gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14)
-            Rfu.unk_f0 = 1;
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY:
+        if (lman.acceptSlot_flag & lman.param[0])
+            Rfu.linkLossRecoveryState = 1;
         break;
-    case 0x32:
-        Rfu.unk_f0 = 3;
+    case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
+        Rfu.linkLossRecoveryState = 3;
         if (gRfuLinkStatus->parentChild == MODE_CHILD)
             Rfu.unk_c3c = 1;
         break;
-    case 0x30:
-        Rfu.unk_f0 = 2;
-    case 0x33:
-        if (Rfu.unk_f0 != 2)
-            Rfu.unk_f0 = 4;
-        if (Rfu.unk_0c == 1)
+    case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED:
+        Rfu.linkLossRecoveryState = 2;
+        // fallthrough
+    case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
+        if (Rfu.linkLossRecoveryState != 2)
+            Rfu.linkLossRecoveryState = 4;
+        if (Rfu.parent_child == MODE_PARENT)
         {
             if (gReceivedRemoteLinkPlayers == 1)
             {
-                Rfu.unk_ce2 &= ~(gUnknown_3005E10.unk_14);
-                if (Rfu.unk_ce2 == 0)
-                    sub_80FB0E8(a0);
+                Rfu.bm_PartnerFlags &= ~(lman.param[0]);
+                if (Rfu.bm_PartnerFlags == 0)
+                    GetLinkmanErrorParams(msg);
                 else
                     sub_80FB174();
             }
         }
         else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1)
         {
-            sub_80FB0E8(a0);
-            sub_80FD760(0);
+            GetLinkmanErrorParams(msg);
+            rfu_LMAN_stopManager(0);
         }
 
-        if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && gUnknown_3005E10.unk_07 == 0 && FuncIsActiveTask(sub_80F8B34) == TRUE)
-            Rfu.unk_04 = 0x11;
+        if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && lman.pcswitch_flag == 0 && FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE)
+            Rfu.state = 17;
 
-        sub_80FB9E4(2, a0);
+        RfuSetErrorStatus(2, msg);
         break;
-    case 0x40:
-        Rfu.unk_ce3 = 0;
+    case LMAN_MSG_LINK_DISCONNECTED_BY_USER:
+        Rfu.bm_DisconnectSlot = 0;
         break;
-    case 0x42 ... 0x44:
+    case LMAN_MSG_RFU_POWER_DOWN:
+    case LMAN_MSG_MANAGER_STOPPED:
+    case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET:
         break;
-    case 0xF3:
-        sub_80FB9E4(1, a0);
-        sub_80FB0E8(a0);
+    case LMAN_MSG_LMAN_API_ERROR_RETURN:
+        RfuSetErrorStatus(1, msg);
+        GetLinkmanErrorParams(msg);
         Rfu.unk_ef = 1;
         break;
-    case 0xF0 ... 0xF2:
-    case 0xFF:
-        sub_80FB0E8(a0);
-        sub_80FB9E4(1, a0);
+    case LMAN_MSG_REQ_API_ERROR:
+    case LMAN_MSG_WATCH_DOG_TIMER_ERROR:
+    case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA:
+    case LMAN_MSG_RFU_FATAL_ERROR:
+        GetLinkmanErrorParams(msg);
+        RfuSetErrorStatus(1, msg);
         Rfu.unk_cdb = 0;
         break;
     }
@@ -2341,21 +2361,21 @@ void sub_80FB9D0(void)
     Rfu.unk_ce4 = 2;
 }
 
-void sub_80FB9E4(u8 a0, u16 a1)
+void RfuSetErrorStatus(u8 a0, u16 msg)
 {
     Rfu.unk_f1 = a0;
-    Rfu.unk_0a = a1;
+    Rfu.linkman_msg = msg;
 }
 
-u8 sub_80FB9F4(void)
+u8 RfuGetErrorStatus(void)
 {
     return Rfu.unk_f1;
 }
 
-bool32 sub_80FBA00(void)
+bool32 RfuIsErrorStatus1or2(void)
 {
-    u32 var = sub_80FB9F4() - 1;
-    if (var < 2)
+    u32 var = RfuGetErrorStatus();
+    if (var == 1 || var == 2)
         return TRUE;
     else
         return FALSE;
@@ -2368,12 +2388,12 @@ bool32 GetRfuUnkCE8(void)
 
 bool8 Rfu_IsMaster(void)
 {
-    return Rfu.unk_0c;
+    return Rfu.parent_child;
 }
 
 void RFUVSync(void)
 {
-    LinkRfu_syncVBlank_();
+    rfu_LMAN_syncVBlank();
 }
 
 void sub_80FBA44(void)
@@ -2400,7 +2420,7 @@ static void sub_80FBA78(void)
     if (IsWirelessAdapterConnected())
     {
         gLinkType = LINKTYPE_0x1111;
-        sub_800B1F4();
+        SetWirelessCommType1();
         OpenLink();
         SeedRng(gMain.vblankCounter2);
         for (i = 0; i < RFU_CHILD_MAX; i++)
@@ -2411,25 +2431,25 @@ static void sub_80FBA78(void)
         AnimateSprites();
         BuildOamBuffer();
         UpdatePaletteFade();
-        sub_80FBB20();
+        LinkRfu_CreateIdleTask();
         SetMainCallback2(sub_80FBB74);
     }
 }
 
-bool32 sub_80FBB0C(void)
+bool32 IsUnionRoomListenTaskActive(void)
 {
-    return FuncIsActiveTask(sub_80F8B34);
+    return FuncIsActiveTask(Task_LinkRfu_UnionRoomListen);
 }
 
-void sub_80FBB20(void)
+void LinkRfu_CreateIdleTask(void)
 {
-    if (!FuncIsActiveTask(nullsub_89))
-        Rfu.unk_66 = CreateTask(nullsub_89, 0);
+    if (!FuncIsActiveTask(Task_idle))
+        Rfu.unk_66 = CreateTask(Task_idle, 0);
 }
 
-void sub_80FBB4C(void)
+void LinkRfu_DestroyIdleTask(void)
 {
-    if (FuncIsActiveTask(nullsub_89) == TRUE)
+    if (FuncIsActiveTask(Task_idle) == TRUE)
         DestroyTask(Rfu.unk_66);
 }
 
@@ -2441,35 +2461,35 @@ static void sub_80FBB74(void)
     UpdatePaletteFade();
 }
 
-void sub_80FBB8C(u32 a0)
+void InitializeRfuLinkManager_LinkLeader(u32 availSlots)
 {
-    Rfu.unk_0c = 1;
-    sub_80FAF1C();
-    sub_80FD430(sub_80FB184, NULL);
+    Rfu.parent_child = MODE_PARENT;
+    CopyPlayerNameToUnameBuffer();
+    rfu_LMAN_initializeManager(LmanCallback_Parent2, NULL);
     sRfuReqConfig = sRfuReqConfigTemplate;
-    sRfuReqConfig.availSlotFlag = sAvailSlots[a0 - 1];
-    sub_80F8E74();
+    sRfuReqConfig.availSlot_flag = sAvailSlots[availSlots - 1];
+    CreateTask_LinkLeaderSearchForChildren();
 }
 
-void sub_80FBBD8(void)
+void InitializeRfuLinkManager_JoinGroup(void)
 {
-    Rfu.unk_0c = 0;
-    sub_80FAF1C();
-    sub_80FD430(sub_80FB37C, sub_80F8D20);
-    sub_80F8F10();
+    Rfu.parent_child = MODE_CHILD;
+    CopyPlayerNameToUnameBuffer();
+    rfu_LMAN_initializeManager(LmanCallback_Child, MscCallback_Child);
+    CreateTask_JoinGroupSearchForParent();
 }
 
-void sub_80FBC00(void)
+void InitializeRfuLinkManager_EnterUnionRoom(void)
 {
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return;
-    Rfu.unk_0c = 2;
-    sub_80FAF1C();
-    sub_80FD430(sub_80FB5EC, NULL);
+    Rfu.parent_child = 2;
+    CopyPlayerNameToUnameBuffer();
+    rfu_LMAN_initializeManager(LmanCallback_Parent, NULL);
     sRfuReqConfig = sRfuReqConfigTemplate;
-    sRfuReqConfig.unk_11 = 0;
-    sRfuReqConfig.unk_12 = 0x258;
-    Rfu.unk_67 = CreateTask(sub_80F8B34, 1);
+    sRfuReqConfig.linkRecovery_enable = 0;
+    sRfuReqConfig.linkRecovery_period = 600;
+    Rfu.unk_67 = CreateTask(Task_LinkRfu_UnionRoomListen, 1);
 }
 
 static u16 ReadU16(const void *ptr)
@@ -2478,17 +2498,24 @@ static u16 ReadU16(const void *ptr)
     return (ptr_[1] << 8) | (ptr_[0]);
 }
 
-static u8 sub_80FBC70(const u8 *a0, u16 a1)
+/*
+ * ================================================================
+ * Looks up the player by uname and pid. Returns the index in
+ * gRfuLinkStatus->partner of the first match with a valid slot ID.
+ * Returns 0xFF if not found.
+ * ================================================================
+ */
+static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId)
 {
     u8 i;
     u8 ret = 0xFF;
 
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        u16 trainerId = ReadU16(((struct GFtgtGname *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId);
-        if (sub_80FA44C(gRfuLinkStatus->partner[i].serialNo)
-            && !StringCompare(a0, gRfuLinkStatus->partner[i].uname)
-            && a1 == trainerId)
+        u16 partnerTrainerId = ReadU16(((struct GFtgtGname *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId);
+        if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[i].serialNo)
+            && !StringCompare(trainerName, gRfuLinkStatus->partner[i].uname)
+            && trainerId == partnerTrainerId)
         {
             ret = i;
             if (gRfuLinkStatus->partner[i].slot != 0xFF)
@@ -2499,21 +2526,21 @@ static u8 sub_80FBC70(const u8 *a0, u16 a1)
     return ret;
 }
 
-static void sub_80FBCF8(u32 a0)
+static void RfuReqDisconnectSlot(u32 bmDisconnectSlot)
 {
-    rfu_REQ_disconnect(a0);
+    rfu_REQ_disconnect(bmDisconnectSlot);
     rfu_waitREQComplete();
-    Rfu.unk_ce2 &= ~(a0);
+    Rfu.bm_PartnerFlags &= ~(bmDisconnectSlot);
     rfu_clearSlot(TYPE_UNI_SEND, Rfu.unk_cda);
-    rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, 70);
-    Rfu.unk_cda = sub_80F886C(Rfu.unk_ce2);
+    rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, 70);
+    Rfu.unk_cda = sub_80F886C(Rfu.bm_PartnerFlags);
 }
 
-void sub_80FBD4C(const u8 *ptr, u16 a1)
+void RequestDisconnectSlotByTrainerNameAndId(const u8 *trainerName, u16 trainerId)
 {
-    u8 var = sub_80FBC70(ptr, a1);
+    u8 var = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId);
     if (var != 0xFF)
-        sub_80FBCF8(1 << var);
+        RfuReqDisconnectSlot(1 << var);
 }
 
 void sub_80FBD6C(u32 a0)
@@ -2525,7 +2552,7 @@ void sub_80FBD6C(u32 a0)
 
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
-            if (Rfu.unk_cde[i] == a0 && (Rfu.unk_ce2 >> i) & 1)
+            if (Rfu.linkPlayerIdx[i] == a0 && (Rfu.bm_PartnerFlags >> i) & 1)
                 var |= 1 << i;
         }
         if (var)
@@ -2537,7 +2564,7 @@ static void sub_80FBDB8(u8 taskId)
 {
     if (gSendCmd[0] == 0 && !Rfu.unk_ce8)
     {
-        sub_80F9D04(0xED00);
+        RfuPrepareSendBuffer(RFU_COMMAND_0xed00);
         gSendCmd[1] = gTasks[taskId].data[0];
         gSendCmd[2] = gTasks[taskId].data[1];
         Rfu.playerCount -= gUnknown_843EC41[gTasks[taskId].data[0]];
@@ -2562,35 +2589,35 @@ static void sub_80FBE20(u32 a0, u32 a1)
     gTasks[taskId].data[1] = a1;
 }
 
-static void sub_80FBE80(u8 taskId)
+static void Task_RfuReconnectWithParent(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
 
-    if (sub_80F8EA4())
+    if (RfuStateIs7AndPlayerIsChild())
     {
-        u8 id = sub_80FBC70((u8*)data, ReadU16(&data[8]));
+        u8 id = GetPartnerIndexByNameAndTrainerID((u8*)data, ReadU16(&data[8]));
         if (id != 0xFF)
         {
             if (gRfuLinkStatus->partner[id].slot != 0xFF)
             {
-                Rfu.unk_c3d = id;
-                if (sub_80F8ECC())
+                Rfu.reconnectedParentIdx = id;
+                if (IsParentSuccessfullyReconnected())
                     DestroyTask(taskId);
             }
-            else if (sub_80F9800()->unk_0a_0 == 0x15 || sub_80F9800()->unk_0a_0 == 0x16)
+            else if (GetHostRFUtgtGname()->activity == ACTIVITY_WCARD2 || GetHostRFUtgtGname()->activity == ACTIVITY_WNEWS2)
             {
                 data[15]++;
             }
             else
             {
-                sub_80FB9E4(2, 0x7000);
+                RfuSetErrorStatus(2, 0x7000);
                 DestroyTask(taskId);
             }
         }
         else
         {
             data[15]++;
-            Rfu.unk_c3d = id;
+            Rfu.reconnectedParentIdx = id;
         }
     }
     else
@@ -2600,47 +2627,47 @@ static void sub_80FBE80(u8 taskId)
 
     if (data[15] > 240)
     {
-        sub_80FB9E4(2, 0x7000);
+        RfuSetErrorStatus(2, 0x7000);
         DestroyTask(taskId);
     }
 }
 
-void sub_80FBF54(const u8 *src, u16 trainerId)
+void CreateTask_RfuReconnectWithParent(const u8 *trainerName, u16 trainerId)
 {
     u8 taskId;
     s16 *data;
 
     Rfu.unk_f1 = 0;
-    taskId = CreateTask(sub_80FBE80, 3);
+    taskId = CreateTask(Task_RfuReconnectWithParent, 3);
     data = gTasks[taskId].data;
-    StringCopy((u8*)(data), src);
+    StringCopy((u8*)(data), trainerName);
     data[8] = trainerId;
 }
 
-static bool32 sub_80FBF98(s16 a1, struct GFtgtGname *structPtr)
+static bool32 ShouldRejectPartnerConnectionBasedOnActivity(s16 activity, struct GFtgtGname *partnerGname)
 {
-    if (sub_80F9800()->unk_0a_0 == 0x45)
+    if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
     {
-        if (structPtr->unk_0a_0 != 0x45)
+        if (partnerGname->activity != (ACTIVITY_CHAT | IN_UNION_ROOM))
             return TRUE;
     }
-    else if (structPtr->unk_0a_0 != 0x40)
+    else if (partnerGname->activity != IN_UNION_ROOM)
     {
         return TRUE;
     }
-    else if (a1 == 0x44)
+    else if (activity == (ACTIVITY_TRADE | IN_UNION_ROOM))
     {
-        struct GFtgtGname *structPtr2 = (struct GFtgtGname *)&Rfu.unk_104.gname;
-        if (structPtr2->species == SPECIES_EGG)
+        struct GFtgtGname *myTradeGname = (struct GFtgtGname *)&Rfu.unk_104.gname;
+        if (myTradeGname->species == SPECIES_EGG)
         {
-            if (structPtr->species == structPtr2->species)
+            if (partnerGname->species == myTradeGname->species)
                 return FALSE;
             else
                 return TRUE;
         }
-        else if (structPtr->species != structPtr2->species
-                 || structPtr->level != structPtr2->level
-                 || structPtr->type != structPtr2->type)
+        else if (partnerGname->species != myTradeGname->species
+                 || partnerGname->level != myTradeGname->level
+                 || partnerGname->type != myTradeGname->type)
         {
             return TRUE;
         }
@@ -2656,34 +2683,34 @@ static void sub_80FC028(u8 taskId)
 
     if (++gTasks[taskId].data[0] > 300)
     {
-        sub_80FB9E4(2, 0x7000);
+        RfuSetErrorStatus(2, 0x7000);
         DestroyTask(taskId);
     }
 
-    if (Rfu.unk_ccd != 0 && gUnknown_3005E10.unk_06 == 0)
+    if (Rfu.parentId != 0 && lman.parent_child == MODE_CHILD)
     {
         u16 trainerId = ReadU16(((struct GFtgtGname *)&Rfu.unk_104.gname)->unk_00.playerTrainerId);
-        u8 id = sub_80FBC70(Rfu.unk_104.uname, trainerId);
+        u8 id = GetPartnerIndexByNameAndTrainerID(Rfu.unk_104.uname, trainerId);
         if (id != 0xFF)
         {
-            if (!sub_80FBF98(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname))
+            if (!ShouldRejectPartnerConnectionBasedOnActivity(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname))
             {
-                if (gRfuLinkStatus->partner[id].slot != 0xFF && !sub_80FD610(gRfuLinkStatus->partner[id].id, 0x5A))
+                if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 90))
                 {
-                    Rfu.unk_04 = 0xA;
+                    Rfu.state = 10;
                     DestroyTask(taskId);
                 }
             }
             else
             {
-                sub_80FB9E4(2, 0x7000);
+                RfuSetErrorStatus(2, 0x7000);
                 DestroyTask(taskId);
             }
         }
     }
 }
 
-void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2)
+void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 activity)
 {
     u8 taskId, taskId2;
 
@@ -2691,11 +2718,11 @@ void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2)
     Rfu.unk_f1 = 0;
     StringCopy(Rfu.unk_104.uname, name);
     memcpy(Rfu.unk_104.gname, structPtr, RFU_GAME_NAME_LENGTH);
-    sub_80FEB3C();
+    rfu_LMAN_forceChangeSP();
     taskId = CreateTask(sub_80FC028, 2);
-    gTasks[taskId].data[1] = a2;
-    taskId2 = FindTaskIdByFunc(sub_80F8B34);
-    if (a2 == 0x45)
+    gTasks[taskId].data[1] = activity;
+    taskId2 = FindTaskIdByFunc(Task_LinkRfu_UnionRoomListen);
+    if (activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
     {
         if (taskId2 != 0xFF)
             gTasks[taskId2].data[7] = 1;
@@ -2709,7 +2736,7 @@ void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2)
 
 bool8 sub_80FC1B0(void)
 {
-    if (Rfu.unk_f0 == 1)
+    if (Rfu.linkLossRecoveryState == 1)
         return TRUE;
     else
         return FALSE;
@@ -2721,19 +2748,19 @@ bool32 sub_80FC1CC(void)
 
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if ((gUnknown_3005E10.unk_00 >> i) & 1 && Rfu.unk_cd1[i] == 0)
+        if ((lman.acceptSlot_flag >> i) & 1 && Rfu.unk_cd1[i] == 0)
             return FALSE;
     }
 
     return TRUE;
 }
 
-static void sub_80FC208(void)
+static void rfu_dbg_clear(void)
 {
     s32 i;
 
     for (i = 0; i < 20; i++)
-        nullsub_87("                              ", 0, i);
+        rfu_dbg_print_str("                              ", 0, i);
 }
 
 static const char gUnknown_843EE47[16] = {
@@ -2749,44 +2776,44 @@ static const char gUnknown_843EE57[9] = {
 static const char gUnknown_843EE60[] = {' ', '\0'};
 static const char gUnknown_843EE62[] = {'*', '\0'};
 
-static void sub_80FC228(void)
+static void rfu_dbg_print_status(void)
 {
     s32 i, j;
 
-    nullsub_88(GetBlockReceivedStatus(), 0x1C, 0x13, 2);
-    nullsub_88(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1);
-    nullsub_88(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1);
-    if (Rfu.unk_0c == 1)
+    rfu_dbg_print_num(GetBlockReceivedStatus(), 0x1C, 0x13, 2);
+    rfu_dbg_print_num(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1);
+    rfu_dbg_print_num(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1);
+    if (Rfu.parent_child == MODE_PARENT)
     {
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
             if ((gRfuLinkStatus->getNameFlag >> i) & 1)
             {
-                nullsub_88(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
-                nullsub_87((void*) &gRfuLinkStatus->partner[i].gname, 6, i + 3);
-                nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
+                rfu_dbg_print_num(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
+                rfu_dbg_print_str((void*) &gRfuLinkStatus->partner[i].gname, 6, i + 3);
+                rfu_dbg_print_str(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
             }
         }
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
             for (j = 0; j < 14; j++)
             {
-                nullsub_88(Rfu.unk_14[i][j], j * 2, i + 11, 2);
+                rfu_dbg_print_num(Rfu.unk_14[i][j], j * 2, i + 11, 2);
             }
         }
-        nullsub_87("NOWSLOT", 1, 0xF);
+        rfu_dbg_print_str("NOWSLOT", 1, 0xF);
     }
     else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0)
     {
         for (i = 0; i < RFU_CHILD_MAX; i++)
         {
-            nullsub_88(0, 1, i + 3, 4);
-            nullsub_87(gUnknown_843EE47, 6, i + 3);
-            nullsub_87(gUnknown_843EE57, 0x16, i + 3);
+            rfu_dbg_print_num(0, 1, i + 3, 4);
+            rfu_dbg_print_str(gUnknown_843EE47, 6, i + 3);
+            rfu_dbg_print_str(gUnknown_843EE57, 0x16, i + 3);
         }
-        nullsub_88(gRfuLinkStatus->partner[Rfu.unk_c3e].serialNo, 1, 3, 4);
-        nullsub_87(gRfuLinkStatus->partner[Rfu.unk_c3e].gname, 6, 3);
-        nullsub_87(gRfuLinkStatus->partner[Rfu.unk_c3e].uname, 0x16, 3);
+        rfu_dbg_print_num(gRfuLinkStatus->partner[Rfu.child_slot].serialNo, 1, 3, 4);
+        rfu_dbg_print_str(gRfuLinkStatus->partner[Rfu.child_slot].gname, 6, 3);
+        rfu_dbg_print_str(gRfuLinkStatus->partner[Rfu.child_slot].uname, 0x16, 3);
     }
     else
     {
@@ -2794,16 +2821,16 @@ static void sub_80FC228(void)
         {
             if (gRfuLinkStatus->partner[i].slot != 0xFF)
             {
-                nullsub_88(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
-                nullsub_88(gRfuLinkStatus->partner[i].id, 6, i + 3, 4);
-                nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
+                rfu_dbg_print_num(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
+                rfu_dbg_print_num(gRfuLinkStatus->partner[i].id, 6, i + 3, 4);
+                rfu_dbg_print_str(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
             }
         }
         for (; i < RFU_CHILD_MAX; i++)
         {
-            nullsub_88(0, 1, i + 3, 4);
-            nullsub_87(gUnknown_843EE47, 6, i + 3);
-            nullsub_87(gUnknown_843EE57, 0x16, i + 3);
+            rfu_dbg_print_num(0, 1, i + 3, 4);
+            rfu_dbg_print_str(gUnknown_843EE47, 6, i + 3);
+            rfu_dbg_print_str(gUnknown_843EE57, 0x16, i + 3);
         }
     }
 }
@@ -2824,15 +2851,15 @@ static const char gUnknown_843EEA8[][8] = {
 
 static u32 sub_80FC44C(void)
 {
-    return Rfu.unk_9e8.unk_232;
+    return Rfu.unk_9e8.count;
 }
 
 u32 GetRfuRecvQueueLength(void)
 {
-    return Rfu.unk_124.unk_8c2;
+    return Rfu.unk_124.count;
 }
 
-static void nullsub_89(u8 taskId)
+static void Task_idle(u8 taskId)
 {
 
 }
diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c
index 69b6603a8..d3f6e93db 100644
--- a/src/link_rfu_3.c
+++ b/src/link_rfu_3.c
@@ -166,7 +166,7 @@ static const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = {
     SpriteCallbackDummy
 };
 
-void sub_80FC478(struct UnkRfuStruct_2_Sub_124 *ptr)
+void RFU_queue_20_70_reset(struct UnkRfuStruct_2_Sub_124 *queue)
 {
     s32 i;
     s32 j;
@@ -175,16 +175,16 @@ void sub_80FC478(struct UnkRfuStruct_2_Sub_124 *ptr)
     {
         for (j = 0; j < 70; j++)
         {
-            ptr->unk_00[i][j] = 0;
+            queue->slots[i][j] = 0;
         }
     }
-    ptr->unk_8c1 = 0;
-    ptr->unk_8c0 = 0;
-    ptr->unk_8c2 = 0;
-    ptr->unk_8c3 = 0;
+    queue->send_slot = 0;
+    queue->recv_slot = 0;
+    queue->count = 0;
+    queue->full = 0;
 }
 
-void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr)
+void RFU_queue_40_14_reset(struct UnkRfuStruct_2_Sub_9e8 *ptr)
 {
     s32 i;
     s32 j;
@@ -193,16 +193,16 @@ void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr)
     {
         for (j = 0; j < 14; j++)
         {
-            ptr->unk_00[i][j] = 0;
+            ptr->slots[i][j] = 0;
         }
     }
-    ptr->unk_231 = 0;
-    ptr->unk_230 = 0;
-    ptr->unk_232 = 0;
-    ptr->unk_233 = 0;
+    ptr->send_slot = 0;
+    ptr->recv_slot = 0;
+    ptr->count = 0;
+    ptr->full = 0;
 }
 
-static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr)
+static void RFU_queue_2_256_reset(struct UnkRfuStruct_Sub_Unused *ptr)
 {
     s32 i;
     s32 j;
@@ -211,29 +211,29 @@ static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr)
     {
         for (j = 0; j < 256; j++)
         {
-            ptr->unk_00[i][j] = 0;
+            ptr->slots[i][j] = 0;
         }
     }
-    ptr->unk_201 = 0;
-    ptr->unk_200 = 0;
-    ptr->unk_202 = 0;
-    ptr->unk_203 = 0;
+    ptr->send_slot = 0;
+    ptr->recv_slot = 0;
+    ptr->count = 0;
+    ptr->full = 0;
 }
 
-void sub_80FC588(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
+void RFU_queue_20_70_recv(struct UnkRfuStruct_2_Sub_124 *queue, u8 *data)
 {
     s32 i;
     u16 imeBak;
     u8 count;
 
-    if (q1->unk_8c2 < 20)
+    if (queue->count < 20)
     {
         imeBak = REG_IME;
         REG_IME = 0;
         count = 0;
         for (i = 0; i < 70; i += 14)
         {
-            if (q2[i] == 0 && q2[i + 1] == 0)
+            if (data[i] == 0 && data[i + 1] == 0)
             {
                 count++;
             }
@@ -242,36 +242,36 @@ void sub_80FC588(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
         {
             for (i = 0; i < 70; i++)
             {
-                q1->unk_00[q1->unk_8c0][i] = q2[i];
+                queue->slots[queue->recv_slot][i] = data[i];
             }
-            q1->unk_8c0++;
-            q1->unk_8c0 %= 20;
-            q1->unk_8c2++;
+            queue->recv_slot++;
+            queue->recv_slot %= 20;
+            queue->count++;
             for (i = 0; i < 70; i++)
             {
-                q2[i] = 0;
+                data[i] = 0;
             }
         }
         REG_IME = imeBak;
     }
     else
     {
-        q1->unk_8c3 = 1;
+        queue->full = 1;
     }
 }
 
-void sub_80FC63C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
+void RFU_queue_40_14_recv(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *data)
 {
     s32 i;
     u16 imeBak;
 
-    if (q1->unk_232 < 40)
+    if (queue->count < 40)
     {
         imeBak = REG_IME;
         REG_IME = 0;
         for (i = 0; i < 14; i++)
         {
-            if (q2[i] != 0)
+            if (data[i] != 0)
             {
                 break;
             }
@@ -280,57 +280,57 @@ void sub_80FC63C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
         {
             for (i = 0; i < 14; i++)
             {
-                q1->unk_00[q1->unk_230][i] = q2[i];
+                queue->slots[queue->recv_slot][i] = data[i];
             }
-            q1->unk_230++;
-            q1->unk_230 %= 40;
-            q1->unk_232++;
+            queue->recv_slot++;
+            queue->recv_slot %= 40;
+            queue->count++;
             for (i = 0; i < 14; i++)
             {
-                q2[i] = 0;
+                data[i] = 0;
             }
         }
         REG_IME = imeBak;
     }
     else
     {
-        q1->unk_233 = 1;
+        queue->full = 1;
     }
 }
 
-bool8 sub_80FC6E8(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
+bool8 RFU_queue_20_70_send(struct UnkRfuStruct_2_Sub_124 *queue, u8 *dest)
 {
     u16 imeBak;
     s32 i;
 
     imeBak = REG_IME;
     REG_IME = 0;
-    if (q1->unk_8c0 == q1->unk_8c1 || q1->unk_8c3 != 0)
+    if (queue->recv_slot == queue->send_slot || queue->full)
     {
         for (i = 0; i < 70; i++)
         {
-            q2[i] = 0;
+            dest[i] = 0;
         }
         REG_IME = imeBak;
         return FALSE;
     }
     for (i = 0; i < 70; i++)
     {
-        q2[i] = q1->unk_00[q1->unk_8c1][i];
+        dest[i] = queue->slots[queue->send_slot][i];
     }
-    q1->unk_8c1++;
-    q1->unk_8c1 %= 20;
-    q1->unk_8c2--;
+    queue->send_slot++;
+    queue->send_slot %= 20;
+    queue->count--;
     REG_IME = imeBak;
     return TRUE;
 }
 
-bool8 sub_80FC79C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
+bool8 RFU_queue_40_14_send(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *dest)
 {
     s32 i;
     u16 imeBak;
 
-    if (q1->unk_230 == q1->unk_231 || q1->unk_233 != 0)
+    if (queue->recv_slot == queue->send_slot || queue->full != 0)
     {
         return FALSE;
     }
@@ -338,98 +338,98 @@ bool8 sub_80FC79C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
     REG_IME = 0;
     for (i = 0; i < 14; i++)
     {
-        q2[i] = q1->unk_00[q1->unk_231][i];
+        dest[i] = queue->slots[queue->send_slot][i];
     }
-    q1->unk_231++;
-    q1->unk_231 %= 40;
-    q1->unk_232--;
+    queue->send_slot++;
+    queue->send_slot %= 40;
+    queue->count--;
     REG_IME = imeBak;
     return TRUE;
 }
 
-void sub_80FC828(struct UnkRfuStruct_2_Sub_c1c *q1, const u8 *q2)
+void RFU_queue_2_14_recv(struct UnkRfuStruct_2_Sub_c1c *queue, const u8 *data)
 {
     s32 i;
 
-    if (q2[1] == 0)
+    if (data[1] == 0)
     {
-        sub_80FC888(q1, NULL);
+        RFU_queue_2_14_send(queue, NULL);
     }
     else
     {
         for (i = 0; i < 14; i++)
         {
-            q1->unk_00[q1->unk_1c][i] = q2[i];
+            queue->slots[queue->recv_slot][i] = data[i];
         }
-        q1->unk_1c++;
-        q1->unk_1c %= 2;
-        if (q1->unk_1e < 2)
+        queue->recv_slot++;
+        queue->recv_slot %= 2;
+        if (queue->count < 2)
         {
-            q1->unk_1e++;
+            queue->count++;
         }
         else
         {
-            q1->unk_1d = q1->unk_1c;
+            queue->send_slot = queue->recv_slot;
         }
     }
 }
 
-bool8 sub_80FC888(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2)
+bool8 RFU_queue_2_14_send(struct UnkRfuStruct_2_Sub_c1c *queue, u8 *dest)
 {
     s32 i;
 
-    if (q1->unk_1e == 0)
+    if (queue->count == 0)
     {
         return FALSE;
     }
-    if (q2 != NULL)
+    if (dest != NULL)
     {
         for (i = 0; i < 14; i++)
         {
-            q2[i] = q1->unk_00[q1->unk_1d][i];
+            dest[i] = queue->slots[queue->send_slot][i];
         }
     }
-    q1->unk_1d++;
-    q1->unk_1d %= 2;
-    q1->unk_1e--;
+    queue->send_slot++;
+    queue->send_slot %= 2;
+    queue->count--;
     return TRUE;
 }
 
-static void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
+static void RFU_queue_2_256_recv(struct UnkRfuStruct_Sub_Unused *queue, u8 *data)
 {
     s32 i;
 
-    if (q1->unk_202 < 2)
+    if (queue->count < 2)
     {
         for (i = 0; i < 256; i++)
         {
-            q1->unk_00[q1->unk_200][i] = q2[i];
+            queue->slots[queue->recv_slot][i] = data[i];
         }
-        q1->unk_200++;
-        q1->unk_200 %= 2;
-        q1->unk_202++;
+        queue->recv_slot++;
+        queue->recv_slot %= 2;
+        queue->count++;
     }
     else
     {
-        q1->unk_203 = 1;
+        queue->full = 1;
     }
 }
 
-static bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
+static bool8 RFU_queue_2_256_send(struct UnkRfuStruct_Sub_Unused *queue, u8 *send)
 {
     s32 i;
 
-    if (q1->unk_200 == q1->unk_201 || q1->unk_203)
+    if (queue->recv_slot == queue->send_slot || queue->full)
     {
         return FALSE;
     }
     for (i = 0; i < 256; i++)
     {
-        q2[i] = q1->unk_00[q1->unk_201][i];
+        send[i] = queue->slots[queue->send_slot][i];
     }
-    q1->unk_201++;
-    q1->unk_201 %= 2;
-    q1->unk_202--;
+    queue->send_slot++;
+    queue->send_slot %= 2;
+    queue->count--;
     return TRUE;
 }
 
@@ -438,7 +438,7 @@ static void sub_80FC9B8(u8 *q1, u8 mode)
     s32 i;
     u8 rval;
     u16 r5 = 0;
-    static u8 _3002018;
+    static u8 counter;
 
     switch (mode)
     {
@@ -470,11 +470,11 @@ static void sub_80FC9B8(u8 *q1, u8 mode)
         case 3:
             for (i = 0; i < 200; i++)
             {
-                q1[i] = i + 1 + _3002018;
-                r5 += (i + 1 + _3002018) & 0xFF;
+                q1[i] = i + 1 + counter;
+                r5 += (i + 1 + counter) & 0xFF;
             }
             *((u16 *)(q1 + i)) = r5;
-            _3002018++;
+            counter++;
             break;
     }
 }
@@ -603,7 +603,7 @@ static u8 GetConnectedChildStrength(u8 maxFlags)
 }
 #endif
 
-void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 r2, s32 r3)
+void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 started, s32 child_sprite_genders)
 {
     s32 i;
 
@@ -613,30 +613,37 @@ void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 r2, s32 r3
     }
     for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        data->unk_04[i] = r3;
-        r3 >>= 8;
+        data->child_sprite_gender[i] = child_sprite_genders;
+        child_sprite_genders >>= 8;
     }
     data->playerGender = gSaveBlock2Ptr->playerGender;
-    data->unk_0a_0 = activity;
-    data->unk_0a_7 = r2;
-    data->unk_00.unk_00_0 = GAME_LANGUAGE;
-    data->unk_00.unk_01_2 = GAME_VERSION;
-    data->unk_00.unk_00_4 = 0;
-    data->unk_00.unk_00_5 = 0;
+    data->activity = activity;
+    data->started = started;
+    data->unk_00.language = GAME_LANGUAGE;
+    data->unk_00.version = GAME_VERSION;
+    data->unk_00.hasNews = FALSE;
+    data->unk_00.hasCard = FALSE;
     data->unk_00.unk_00_6 = 0;
     data->unk_00.isChampion = FlagGet(FLAG_SYS_CAN_LINK_WITH_RS);
     data->unk_00.hasNationalDex = IsNationalPokedexEnabled();
     data->unk_00.gameClear = FlagGet(FLAG_SYS_GAME_CLEAR);
 }
 
-bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx)
+/*
+ * ==========================================================
+ * Returns 1 if parent, 0 if child or neutral.
+ * If partner serial number is valid, copies gname and uname.
+ * Otherwise, blanks these.
+ * ==========================================================
+ */
+bool8 LinkRfu_GetNameIfCompatible(struct GFtgtGname *gname, u8 *uname, u8 idx)
 {
     bool8 retVal;
 
-    if (gUnknown_3005E10.unk_06 == 1)
+    if (lman.parent_child == MODE_PARENT)
     {
         retVal = TRUE;
-        if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1))
+        if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1))
         {
             memcpy(gname, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH);
             memcpy(uname, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH);
@@ -650,7 +657,7 @@ bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx)
     else
     {
         retVal = FALSE;
-        if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo))
+        if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[idx].serialNo))
         {
             memcpy(gname, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH);
             memcpy(uname, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH);
@@ -664,7 +671,13 @@ bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx)
     return retVal;
 }
 
-bool8 sub_80FCCF4(struct GFtgtGname *gname, u8 *uname, u8 idx)
+/*
+ * ==========================================================
+ * Specific check for serial number 0x7F7D,
+ * which comes from ???
+ * ==========================================================
+ */
+bool8 LinkRfu_GetNameIfSerial7F7D(struct GFtgtGname *gname, u8 *uname, u8 idx)
 {
     bool8 retVal = FALSE;
     if (gRfuLinkStatus->partner[idx].serialNo == 0x7F7D)
@@ -824,7 +837,7 @@ void UpdateWirelessStatusIndicatorSprite(void)
         gMain.oamBuffer[125].paletteNum = sprite->oam.paletteNum;
         gMain.oamBuffer[125].tileNum = sprite->data[6] + sprite->anims[sprite->data[2]][sprite->data[4]].frame.imageValue;
         CpuCopy16(gMain.oamBuffer + 125, (struct OamData *)OAM + 125, sizeof(struct OamData));
-        if (sub_80FB9F4() == 1)
+        if (RfuGetErrorStatus() == 1)
         {
             DestroyWirelessStatusIndicatorSprite();
         }
diff --git a/src/list_menu.c b/src/list_menu.c
index 6c4d50961..9439d712c 100644
--- a/src/list_menu.c
+++ b/src/list_menu.c
@@ -8,9 +8,7 @@
 #include "main.h"
 #include "task.h"
 #include "graphics.h"
-#include "decompress.h"
 #include "palette.h"
-#include "malloc.h"
 #include "strings.h"
 #include "sound.h"
 #include "pokemon_icon.h"
@@ -258,7 +256,7 @@ void DestroyListMenuTask(u8 listTaskId, u16 *cursorPos, u16 *itemsAbove)
     if (itemsAbove != NULL)
         *itemsAbove = list->itemsAbove;
 
-    if (list->taskId != TASK_NONE)
+    if (list->taskId != TAIL_SENTINEL)
         ListMenuRemoveCursorObject(list->taskId, list->template.cursorKind - 2);
 
     DestroyTask(listTaskId);
@@ -348,7 +346,7 @@ static u8 ListMenuInitInternal(const struct ListMenuTemplate *listMenuTemplate,
     list->itemsAbove = itemsAbove;
     list->unk_1C = 0;
     list->unk_1D = 0;
-    list->taskId = TASK_NONE;
+    list->taskId = TAIL_SENTINEL;
     list->unk_1F = 0;
     gListMenuOverride.cursorPal = list->template.cursorPal;
     gListMenuOverride.fillValue = list->template.fillValue;
@@ -415,17 +413,17 @@ static void ListMenuDrawCursor(struct ListMenu *list)
     switch (list->template.cursorKind)
     {
     case 0:
-        ListMenuPrint(list, gFameCheckerText_ListMenuCursor, x, y);
+        ListMenuPrint(list, gText_SelectorArrow2, x, y);
         break;
     case 1:
         break;
     case 2:
-        if (list->taskId == TASK_NONE)
+        if (list->taskId == TAIL_SENTINEL)
             list->taskId = ListMenuAddCursorObject(list, 0);
         ListMenuUpdateCursorObject(list->taskId, GetWindowAttribute(list->template.windowId, WINDOW_TILEMAP_LEFT) * 8 - 1, GetWindowAttribute(list->template.windowId, WINDOW_TILEMAP_TOP) * 8 + y - 1, 0);
         break;
     case 3:
-        if (list->taskId == TASK_NONE)
+        if (list->taskId == TAIL_SENTINEL)
             list->taskId = ListMenuAddCursorObject(list, 1);
         ListMenuUpdateCursorObject(list->taskId, GetWindowAttribute(list->template.windowId, WINDOW_TILEMAP_LEFT) * 8 + x, GetWindowAttribute(list->template.windowId, WINDOW_TILEMAP_TOP) * 8 + y, 1);
         break;
@@ -763,7 +761,7 @@ void sub_8107CF8(u8 windowId, u16 speciesId, u32 personality, u16 x, u16 y)
     BlitBitmapToWindow(windowId, GetMonIconPtr(speciesId, personality, 1), x, y, 32, 32);
 }
 
-void sub_8107D38(u8 palOffset, u8 palId)
+void ListMenuLoadStdPalAt(u8 palOffset, u8 palId)
 {
     const u16 *palette;
 
diff --git a/src/load_save.c b/src/load_save.c
index 9c30494f8..7ab28ffc3 100644
--- a/src/load_save.c
+++ b/src/load_save.c
@@ -8,7 +8,6 @@
 #include "item.h"
 #include "save_location.h"
 #include "berry_powder.h"
-#include "item.h"
 #include "overworld.h"
 #include "quest_log.h"
 
@@ -284,8 +283,8 @@ void ApplyNewEncryptionKeyToAllEncryptedData(u32 encryptionKey)
 {
     int i;
 
-    for(i = 0; i < 4; i++)
-        ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->unkArray[i].unk4, encryptionKey);
+    for(i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++)
+        ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->trainerTower[i].bestTime, encryptionKey);
 
     sub_8054F38(encryptionKey);
     ApplyNewEncryptionKeyToBagItems_(encryptionKey);
diff --git a/src/mail.c b/src/mail.c
index dbdf48ac7..b5c0343b3 100644
--- a/src/mail.c
+++ b/src/mail.c
@@ -506,10 +506,10 @@ static bool8 DoInitMailView(void)
         SetVBlankCallback(NULL);
         ScanlineEffect_Stop();
         SetGpuReg(REG_OFFSET_DISPCNT, 0);
-        if (gPlayerPcMenuManager.unk_9 == 0)
-            HelpSystem_SetSomeVariable2(34);
+        if (gPlayerPcMenuManager.notInRoom == FALSE)
+            SetHelpContext(HELPCONTEXT_BEDROOM_PC_MAILBOX);
         else
-            HelpSystem_SetSomeVariable2(30);
+            SetHelpContext(HELPCONTEXT_PLAYERS_PC_MAILBOX);
         break;
     case 1:
         CpuFill16(0, (void *)OAM, OAM_SIZE);
diff --git a/src/main.c b/src/main.c
index b88326cda..77f668e6f 100644
--- a/src/main.c
+++ b/src/main.c
@@ -9,7 +9,6 @@
 #include "random.h"
 #include "dma3.h"
 #include "gba/flash_internal.h"
-#include "battle.h"
 #include "help_system.h"
 #include "sound.h"
 #include "new_menu_helpers.h"
@@ -17,12 +16,11 @@
 #include "overworld.h"
 #include "sprite.h"
 #include "play_time.h"
-#include "pokemon.h"
 #include "intro.h"
 #include "battle_controllers.h"
 #include "scanline_effect.h"
 #include "save_failed_screen.h"
-#include "battle.h"
+#include "quest_log.h"
 
 extern u32 intr_main[];
 
@@ -80,9 +78,6 @@ static IntrFunc * const sTimerIntrFunc = gIntrTable + 0x7;
 EWRAM_DATA u8 gDecompressionBuffer[0x4000] = {0};
 EWRAM_DATA u16 gTrainerId = 0;
 
-extern bool8 gWirelessCommType;
-extern bool8 gUnknown_3005E88;
-
 static void UpdateLinkAndCallCallbacks(void);
 static void InitMainCallbacks(void);
 static void CallCallbacks(void);
@@ -181,7 +176,7 @@ static void InitMainCallbacks(void)
     gSaveBlock2Ptr = &gSaveBlock2;
     gSaveBlock1Ptr = &gSaveBlock1;
     gSaveBlock2.encryptionKey = 0;
-    gUnknown_3005E88 = FALSE;
+    gUnknown_3005E88 = 0;
 }
 
 static void CallCallbacks(void)
diff --git a/src/map_preview_screen.c b/src/map_preview_screen.c
index bb748ae91..1788b17cc 100644
--- a/src/map_preview_screen.c
+++ b/src/map_preview_screen.c
@@ -14,12 +14,12 @@
 #include "overworld.h"
 #include "event_data.h"
 #include "map_preview_screen.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 
-static EWRAM_DATA bool8 gUnknown_203ABEC = FALSE;
-static EWRAM_DATA bool8 gUnknown_203ABED = FALSE;
+static EWRAM_DATA bool8 sHasVisitedMapBefore = FALSE;
+static EWRAM_DATA bool8 sAllocedBg0TilemapBuffer = FALSE;
 
-static void sub_80F83D0(u8 taskId);
+static void Task_RunMapPreviewScreenForest(u8 taskId);
 
 static const u8 gViridianForestMapPreviewPalette[] = INCBIN_U8("data/map_preview/viridian_forest_pal.gbapal");
 static const u8 gViridianForestMapPreviewTiles[] = INCBIN_U8("data/map_preview/viridian_forest_tiles.4bpp.lz");
@@ -88,7 +88,7 @@ static const u8 gAlteringCaveMapPreviewTilemap[] = INCBIN_U8("data/map_preview/a
 static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     [MPS_VIRIDIAN_FOREST] = {
         .mapsec = MAPSEC_VIRIDIAN_FOREST,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_VIRIDIAN_FOREST,
         .tilesptr = gViridianForestMapPreviewTiles,
         .tilemapptr = gViridianForestMapPreviewTilemap,
@@ -96,7 +96,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_MT_MOON] = {
         .mapsec = MAPSEC_MT_MOON,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_MT_MOON_1F,
         .tilesptr = gMtMoonMapPreviewTiles,
         .tilemapptr = gMtMoonMapPreviewTilemap,
@@ -104,7 +104,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_DIGLETTS_CAVE] = {
         .mapsec = MAPSEC_DIGLETTS_CAVE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_DIGLETTS_CAVE_B1F,
         .tilesptr = gDiglettsCaveMapPreviewTiles,
         .tilemapptr = gDiglettsCaveMapPreviewTilemap,
@@ -112,7 +112,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_ROCK_TUNNEL] = {
         .mapsec = MAPSEC_ROCK_TUNNEL,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_ROCK_TUNNEL_1F,
         .tilesptr = gRockTunnelMapPreviewTiles,
         .tilemapptr = gRockTunnelMapPreviewTilemap,
@@ -120,7 +120,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_POKEMON_TOWER] = {
         .mapsec = MAPSEC_POKEMON_TOWER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_POKEMON_TOWER_1F,
         .tilesptr = gPokemonTowerMapPreviewTiles,
         .tilemapptr = gPokemonTowerMapPreviewTilemap,
@@ -128,7 +128,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_SAFARI_ZONE] = {
         .mapsec = MAPSEC_KANTO_SAFARI_ZONE,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_SAFARI_ZONE_CENTER,
         .tilesptr = gKantoSafariZoneMapPreviewTiles,
         .tilemapptr = gKantoSafariZoneMapPreviewTilemap,
@@ -136,7 +136,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_SEAFOAM_ISLANDS] = {
         .mapsec = MAPSEC_SEAFOAM_ISLANDS,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEAFOAM_ISLANDS_1F,
         .tilesptr = gSeafoamIslandsMapPreviewTiles,
         .tilemapptr = gSeafoamIslandsMapPreviewTilemap,
@@ -144,7 +144,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_POKEMON_MANSION] = {
         .mapsec = MAPSEC_POKEMON_MANSION,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_POKEMON_MANSION_1F,
         .tilesptr = gPokemonMansionMapPreviewTiles,
         .tilemapptr = gPokemonMansionMapPreviewTilemap,
@@ -152,7 +152,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_ROCKET_HIDEOUT] = {
         .mapsec = MAPSEC_ROCKET_HIDEOUT,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_ROCKET_HIDEOUT_B1F,
         .tilesptr = gRocketHideoutMapPreviewTiles,
         .tilemapptr = gRocketHideoutMapPreviewTilemap,
@@ -160,7 +160,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_SILPH_CO] = {
         .mapsec = MAPSEC_SILPH_CO,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SILPH_CO_1F,
         .tilesptr = gSilphCoMapPreviewTiles,
         .tilemapptr = gSilphCoMapPreviewTilemap,
@@ -168,7 +168,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_VICTORY_ROAD] = {
         .mapsec = MAPSEC_KANTO_VICTORY_ROAD,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_VICTORY_ROAD_1F,
         .tilesptr = gKantoVictoryRoadMapPreviewTiles,
         .tilemapptr = gKantoVictoryRoadMapPreviewTilemap,
@@ -176,7 +176,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_CERULEAN_CAVE] = {
         .mapsec = MAPSEC_CERULEAN_CAVE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_CERULEAN_CAVE_1F,
         .tilesptr = gCeruleanCaveMapPreviewTiles,
         .tilemapptr = gCeruleanCaveMapPreviewTilemap,
@@ -184,7 +184,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_POWER_PLANT] = {
         .mapsec = MAPSEC_POWER_PLANT,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_POWER_PLANT,
         .tilesptr = gPowerPlantMapPreviewTiles,
         .tilemapptr = gPowerPlantMapPreviewTilemap,
@@ -192,7 +192,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_MT_EMBER] = {
         .mapsec = MAPSEC_MT_EMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_MT_EMBER_EXTERIOR,
         .tilesptr = gMtEmberMapPreviewTiles,
         .tilemapptr = gMtEmberMapPreviewTilemap,
@@ -200,7 +200,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_ROCKET_WAREHOUSE] = {
         .mapsec = MAPSEC_ROCKET_WAREHOUSE,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_THREE_ISLAND_BERRY_FOREST,
         .tilesptr = gRocketWarehouseMapPreviewTiles,
         .tilemapptr = gRocketWarehouseMapPreviewTilemap,
@@ -208,7 +208,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_MONEAN_CHAMBER] = {
         .mapsec = MAPSEC_MONEAN_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -216,7 +216,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_DOTTED_HOLE] = {
         .mapsec = MAPSEC_DOTTED_HOLE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SIX_ISLAND_DOTTED_HOLE_1F,
         .tilesptr = gDottedHoleMapPreviewTiles,
         .tilemapptr = gDottedHoleMapPreviewTilemap,
@@ -224,7 +224,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_BERRY_FOREST] = {
         .mapsec = MAPSEC_BERRY_FOREST,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_THREE_ISLAND_BERRY_FOREST,
         .tilesptr = gBerryForestMapPreviewTiles,
         .tilemapptr = gBerryForestMapPreviewTilemap,
@@ -232,7 +232,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_ICEFALL_CAVE] = {
         .mapsec = MAPSEC_ICEFALL_CAVE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_FOUR_ISLAND_ICEFALL_CAVE_ENTRANCE,
         .tilesptr = gIcefallCaveMapPreviewTiles,
         .tilemapptr = gIcefallCaveMapPreviewTilemap,
@@ -240,7 +240,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_LOST_CAVE] = {
         .mapsec = MAPSEC_LOST_CAVE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_FIVE_ISLAND_LOST_CAVE_ENTRANCE,
         .tilesptr = gLostCaveMapPreviewTiles,
         .tilemapptr = gLostCaveMapPreviewTilemap,
@@ -248,7 +248,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_ALTERING_CAVE] = {
         .mapsec = MAPSEC_ALTERING_CAVE,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SIX_ISLAND_ALTERING_CAVE,
         .tilesptr = gAlteringCaveMapPreviewTiles,
         .tilemapptr = gAlteringCaveMapPreviewTilemap,
@@ -256,7 +256,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_PATTERN_BUSH] = {
         .mapsec = MAPSEC_PATTERN_BUSH,
-        .forceFirstTime = TRUE,
+        .type = MPS_TYPE_FOREST,
         .flagId = FLAG_WORLD_MAP_SIX_ISLAND_PATTERN_BUSH,
         .tilesptr = gViridianForestMapPreviewTiles,
         .tilemapptr = gViridianForestMapPreviewTilemap,
@@ -264,7 +264,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_LIPTOO_CHAMBER] = {
         .mapsec = MAPSEC_LIPTOO_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -272,7 +272,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_WEEPTH_CHAMBER] = {
         .mapsec = MAPSEC_WEEPTH_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -280,7 +280,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_TDILFORD_CHAMBER] = {
         .mapsec = MAPSEC_DILFORD_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -288,7 +288,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_SCUFIB_CHAMBER] = {
         .mapsec = MAPSEC_SCUFIB_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -296,7 +296,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_RIXY_CHAMBER] = {
         .mapsec = MAPSEC_RIXY_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -304,7 +304,7 @@ static const struct MapPreviewScreen sMapPreviewScreenData[MPS_COUNT] = {
     },
     [MPS_VIAPOIS_CHAMBER] = {
         .mapsec = MAPSEC_VIAPOIS_CHAMBER,
-        .forceFirstTime = FALSE,
+        .type = MPS_TYPE_CAVE,
         .flagId = FLAG_WORLD_MAP_SEVEN_ISLAND_TANOBY_RUINS_MONEAN_CHAMBER,
         .tilesptr = gMoneanChamberMapPreviewTiles,
         .tilemapptr = gMoneanChamberMapPreviewTilemap,
@@ -328,7 +328,7 @@ static const struct BgTemplate sMapPreviewBgTemplate[1] = {
     }
 };
 
-static u8 sub_80F80E4(u8 mapsec)
+static u8 GetMapPreviewScreenIdx(u8 mapsec)
 {
     s32 i;
 
@@ -342,20 +342,20 @@ static u8 sub_80F80E4(u8 mapsec)
     return MPS_COUNT;
 }
 
-bool8 sub_80F8110(u8 mapsec, u8 forceFirstTime)
+bool8 MapHasPreviewScreen(u8 mapsec, u8 type)
 {
     u8 idx;
 
-    idx = sub_80F80E4(mapsec);
+    idx = GetMapPreviewScreenIdx(mapsec);
     if (idx != MPS_COUNT)
     {
-        if (forceFirstTime == 2)
+        if (type == MPS_TYPE_ANY)
         {
             return TRUE;
         }
         else
         {
-            return sMapPreviewScreenData[idx].forceFirstTime == forceFirstTime ? TRUE : FALSE;
+            return sMapPreviewScreenData[idx].type == type ? TRUE : FALSE;
         }
     }
     else
@@ -364,29 +364,29 @@ bool8 sub_80F8110(u8 mapsec, u8 forceFirstTime)
     }
 }
 
-bool8 sub_80F8154(u8 mapsec, u8 forceFirstTime)
+bool32 MapHasPreviewScreen_HandleQLState2(u8 mapsec, u8 type)
 {
-    if (gQuestLogState == 2)
+    if (gQuestLogState == QL_STATE_2)
     {
         return FALSE;
     }
     else
     {
-        return sub_80F8110(mapsec, forceFirstTime);
+        return MapHasPreviewScreen(mapsec, type);
     }
 }
 
-void sub_80F8180(void)
+void MapPreview_InitBgs(void)
 {
     InitBgsFromTemplates(0, sMapPreviewBgTemplate, NELEMS(sMapPreviewBgTemplate));
     ShowBg(0);
 }
 
-void sub_80F819C(u8 mapsec)
+void MapPreview_LoadGfx(u8 mapsec)
 {
     u8 idx;
 
-    idx = sub_80F80E4(mapsec);
+    idx = GetMapPreviewScreenIdx(mapsec);
     if (idx != MPS_COUNT)
     {
        ResetTempTileDataBuffers();
@@ -395,55 +395,55 @@ void sub_80F819C(u8 mapsec)
        if (GetBgTilemapBuffer(0) == NULL)
        {
            SetBgTilemapBuffer(0, Alloc(BG_SCREEN_SIZE));
-           gUnknown_203ABED = TRUE;
+           sAllocedBg0TilemapBuffer = TRUE;
        }
        else
        {
-           gUnknown_203ABED = FALSE;
+           sAllocedBg0TilemapBuffer = FALSE;
        }
        CopyToBgTilemapBuffer(0, sMapPreviewScreenData[idx].tilemapptr, 0, 0x000);
        CopyBgTilemapBufferToVram(0);
     }
 }
 
-void sub_80F8234(s32 windowId)
+void MapPreview_Unload(s32 windowId)
 {
     RemoveWindow(windowId);
-    if (gUnknown_203ABED)
+    if (sAllocedBg0TilemapBuffer)
     {
         Free(GetBgTilemapBuffer(0));
     }
 }
 
-bool32 sub_80F8258(void)
+bool32 MapPreview_IsGfxLoadFinished(void)
 {
     return FreeTempTileDataBuffersIfPossible();
 }
 
-void sub_80F8268(u8 mapsec)
+void MapPreview_StartForestTransition(u8 mapsec)
 {
     u8 taskId;
 
-    taskId = CreateTask(sub_80F83D0, 0);
+    taskId = CreateTask(Task_RunMapPreviewScreenForest, 0);
     gTasks[taskId].data[2] = GetBgAttribute(0, BG_ATTR_PRIORITY);
     gTasks[taskId].data[4] = GetGpuReg(REG_OFFSET_BLDCNT);
     gTasks[taskId].data[5] = GetGpuReg(REG_OFFSET_BLDALPHA);
     gTasks[taskId].data[3] = GetGpuReg(REG_OFFSET_DISPCNT);
     gTasks[taskId].data[6] = GetGpuReg(REG_OFFSET_WININ);
     gTasks[taskId].data[7] = GetGpuReg(REG_OFFSET_WINOUT);
-    gTasks[taskId].data[10] = sub_80F856C(mapsec);
+    gTasks[taskId].data[10] = MapPreview_GetDuration(mapsec);
     gTasks[taskId].data[8] = 16;
     gTasks[taskId].data[9] = 0;
     SetBgAttribute(0, BG_ATTR_PRIORITY, 0);
     SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG0 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD);
     SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0));
-    SetGpuRegBits(REG_OFFSET_WININ, 0x2020);
-    SetGpuRegBits(REG_OFFSET_WINOUT, 0x0020);
-    gTasks[taskId].data[11] = sub_80F8318(mapsec);
+    SetGpuRegBits(REG_OFFSET_WININ, WININ_WIN0_CLR | WININ_WIN1_CLR);
+    SetGpuRegBits(REG_OFFSET_WINOUT, WINOUT_WIN01_CLR);
+    gTasks[taskId].data[11] = MapPreview_CreateMapNameWindow(mapsec);
     ScriptContext2_Enable();
 }
 
-u16 sub_80F8318(u8 mapsec)
+u16 MapPreview_CreateMapNameWindow(u8 mapsec)
 {
     u16 windowId;
     u32 xctr;
@@ -452,18 +452,18 @@ u16 sub_80F8318(u8 mapsec)
     windowId = AddWindow(&sMapNameWindow);
     FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
     PutWindowTilemap(windowId);
-    color[0] = 1; // Access violation
-    color[1] = 4; // Access violation
-    color[2] = 3; // Access violation
+    color[0] = TEXT_COLOR_WHITE; // Access violation
+    color[1] = TEXT_COLOR_RED; // Access violation
+    color[2] = TEXT_COLOR_LIGHT_GREY; // Access violation
     GetMapName(gStringVar4, mapsec, 0);
     xctr = 104 - GetStringWidth(2, gStringVar4, 0);
     AddTextPrinterParameterized4(windowId, 2, xctr / 2, 2, 0, 0, color/* Access violation */, -1, gStringVar4);
     return windowId;
 }
 
-bool32 sub_80F83B0(void)
+bool32 ForestMapPreviewScreenIsRunning(void)
 {
-    if (FuncIsActiveTask(sub_80F83D0) == TRUE)
+    if (FuncIsActiveTask(Task_RunMapPreviewScreenForest) == TRUE)
     {
         return FALSE;
     }
@@ -473,7 +473,7 @@ bool32 sub_80F83B0(void)
     }
 }
 
-static void sub_80F83D0(u8 taskId)
+static void Task_RunMapPreviewScreenForest(u8 taskId)
 {
     s16 * data;
 
@@ -481,7 +481,7 @@ static void sub_80F83D0(u8 taskId)
     switch (data[0])
     {
     case 0:
-        if (!sub_80F8258() && !IsDma3ManagerBusyWithBgCopy())
+        if (!MapPreview_IsGfxLoadFinished() && !IsDma3ManagerBusyWithBgCopy())
         {
             CopyWindowToVram(data[11], 3);
             data[0]++;
@@ -490,7 +490,7 @@ static void sub_80F83D0(u8 taskId)
     case 1:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            sub_807DC00();
+            FadeInFromBlack();
             data[0]++;
         }
         break;
@@ -539,7 +539,7 @@ static void sub_80F83D0(u8 taskId)
     case 5:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            sub_80F8234(data[11]);
+            MapPreview_Unload(data[11]);
             SetBgAttribute(0, BG_ATTR_PRIORITY, data[2]);
             SetGpuReg(REG_OFFSET_DISPCNT, data[3]);
             SetGpuReg(REG_OFFSET_BLDCNT, data[4]);
@@ -556,7 +556,7 @@ const struct MapPreviewScreen * GetDungeonMapPreviewScreenInfo(u8 mapsec)
 {
     u8 idx;
 
-    idx = sub_80F80E4(mapsec);
+    idx = GetMapPreviewScreenIdx(mapsec);
     if (idx == MPS_COUNT)
     {
         return NULL;
@@ -567,18 +567,18 @@ const struct MapPreviewScreen * GetDungeonMapPreviewScreenInfo(u8 mapsec)
     }
 }
 
-u16 sub_80F856C(u8 mapsec)
+u16 MapPreview_GetDuration(u8 mapsec)
 {
     u8 idx;
     u16 flagId;
 
-    idx = sub_80F80E4(mapsec);
+    idx = GetMapPreviewScreenIdx(mapsec);
     if (idx == MPS_COUNT)
     {
         return 0;
     }
     flagId = sMapPreviewScreenData[idx].flagId;
-    if (!sMapPreviewScreenData[idx].forceFirstTime)
+    if (sMapPreviewScreenData[idx].type == MPS_TYPE_CAVE)
     {
         if (!FlagGet(flagId))
         {
@@ -590,7 +590,7 @@ u16 sub_80F856C(u8 mapsec)
         }
     }
     else {
-        if (gUnknown_203ABEC)
+        if (sHasVisitedMapBefore)
         {
             return 120;
         }
@@ -601,15 +601,15 @@ u16 sub_80F856C(u8 mapsec)
     }
 }
 
-void sub_80F85BC(u16 flagId)
+void MapPreview_SetFlag(u16 flagId)
 {
     if (!FlagGet(flagId))
     {
-        gUnknown_203ABEC = TRUE;
+        sHasVisitedMapBefore = TRUE;
     }
     else
     {
-        gUnknown_203ABEC = FALSE;
+        sHasVisitedMapBefore = FALSE;
     }
     FlagSet(flagId);
 }
diff --git a/src/menews_jisan.c b/src/menews_jisan.c
index d8971f6a2..f3b8fca78 100644
--- a/src/menews_jisan.c
+++ b/src/menews_jisan.c
@@ -54,7 +54,7 @@ void MENewsJisanStepCounter(void)
     }
 }
 
-u16 Special_GetMENewsJisanItemAndState(void)
+u16 GetMENewsJisanItemAndState(void)
 {
     u16 *r6 = &gSpecialVar_Result;
     struct MENewsJisanStruct *r4 = GetMENewsJisanStructPtr();
diff --git a/src/menu.c b/src/menu.c
index 5a0da28b9..b7c3f54eb 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -1,12 +1,8 @@
 #include "global.h"
 #include "bg.h"
-#include "malloc.h"
 #include "menu.h"
 #include "menu_helpers.h"
-#include "new_menu_helpers.h"
-#include "string_util.h"
 #include "strings.h"
-#include "task.h"
 #include "text_window.h"
 #include "window.h"
 #include "sound.h"
@@ -307,7 +303,7 @@ static void Menu_RedrawCursor(u8 oldPos, u8 newPos)
     width = GetMenuCursorDimensionByFont(sMenu.fontId, 0);
     height = GetMenuCursorDimensionByFont(sMenu.fontId, 1);
     FillWindowPixelRect(sMenu.windowId, 1, sMenu.left, sMenu.optionHeight * oldPos + sMenu.top, width, height);
-    AddTextPrinterParameterized(sMenu.windowId, sMenu.fontId, gFameCheckerText_ListMenuCursor, sMenu.left, sMenu.optionHeight * newPos + sMenu.top, 0, 0);
+    AddTextPrinterParameterized(sMenu.windowId, sMenu.fontId, gText_SelectorArrow2, sMenu.left, sMenu.optionHeight * newPos + sMenu.top, 0, 0);
 }
 
 u8 Menu_MoveCursor(s8 cursorDelta)
@@ -649,7 +645,7 @@ static void MultichoiceGrid_RedrawCursor(u8 oldCursorPos, u8 newCursorPos)
     FillWindowPixelRect(sMenu.windowId, PIXEL_FILL(1), xPos, yPos, cursorWidth, cursorHeight);
     xPos = (newCursorPos % sMenu.columns) * sMenu.optionWidth + sMenu.left;
     yPos = (newCursorPos / sMenu.columns) * sMenu.optionHeight + sMenu.top;
-    AddTextPrinterParameterized(sMenu.windowId, sMenu.fontId, gFameCheckerText_ListMenuCursor, xPos, yPos, 0, 0);
+    AddTextPrinterParameterized(sMenu.windowId, sMenu.fontId, gText_SelectorArrow2, xPos, yPos, 0, 0);
 }
 
 static u8 MultichoiceGrid_MoveCursor(s8 deltaX, s8 deltaY)
diff --git a/src/menu_indicators.c b/src/menu_indicators.c
index c07aaf772..3044fb8b4 100644
--- a/src/menu_indicators.c
+++ b/src/menu_indicators.c
@@ -3,7 +3,6 @@
 #include "task.h"
 #include "decompress.h"
 #include "palette.h"
-#include "strings.h"
 #include "sprite.h"
 #include "trig.h"
 #include "list_menu.h"
diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c
index 29a296255..507bcf2b4 100644
--- a/src/metatile_behavior.c
+++ b/src/metatile_behavior.c
@@ -16,39 +16,12 @@ static const bool8 sTileSurfable[METATILE_COUNT] = {
     [MB_SOUTHWARD_CURRENT] = TRUE
 };
 
-static const u8 sTileBitAttributes[] = {
-    0x00,
-    0x01,
-    0x02,
-    0x04,
-    0x08,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0x00
+static const u8 sTileBitAttributes[32] = {
+    [0] = 0x00,
+    [1] = 0x01,
+    [2] = 0x02,
+    [3] = 0x04,
+    [4] = 0x08,
 };
 
 bool8 MetatileBehavior_UnusedReturnTrue(u8 metatileBehavior)
@@ -769,7 +742,7 @@ bool8 MetatileBehavior_UnusedReturnFalse_11(u8 metatileBehavior) { return FALSE;
 bool8 MetatileBehavior_UnusedReturnFalse_12(u8 metatileBehavior) { return FALSE; }
 bool8 MetatileBehavior_UnusedReturnFalse_13(u8 metatileBehavior) { return FALSE; }
 
-bool8 sub_805A2BC(u8 arg1, u8 arg2)
+bool8 TestMetatileAttributeBit(u8 arg1, u8 arg2)
 {
     if(sTileBitAttributes[arg1] & arg2)
         return TRUE;
diff --git a/src/mevent.c b/src/mevent.c
index afad326b5..9eabcad61 100644
--- a/src/mevent.c
+++ b/src/mevent.c
@@ -9,7 +9,7 @@
 #include "decompress.h"
 #include "link.h"
 #include "link_rfu.h"
-#include "unk_815c27c.h"
+#include "ereader_helpers.h"
 #include "util.h"
 #include "script.h"
 #include "event_data.h"
@@ -21,77 +21,65 @@
 #include "mystery_gift_menu.h"
 #include "help_system.h"
 #include "mevent.h"
+#include "strings.h"
 
 struct MEventTaskData1
 {
-    u16 t00;
+    u16 stateAdvanceDelay;
     u16 t02;
     u16 t04;
     u16 t06;
     u8 state;
-    u8 t09;
+    u8 textOrReceiveState;
     u8 t0A;
     u8 t0B;
     u8 t0C;
     u8 t0D;
-    u8 t0E;
+    u8 initialSendResult;
     struct MEvent_Str_2 *t10;
 };
 
-void sub_8143910(u8 taskId);
-bool32 sub_8143E64(const struct MEWonderNewsData * src);
-void sub_8143E9C(void);
-void sub_8143ED0(void);
-bool32 sub_8144018(const struct MEWonderCardData * src);
-void BlankSavedWonderCard(void);
-void BlankMEventBuffer2(void);
-void sub_8144824(u32, u32, u32 *, s32);
-void sub_8144790(void);
-
-extern const u8 gUnknown_841DE52[];
-extern const u8 gUnknown_841DE53[];
-extern const u8 gUnknown_841DE54[];
-extern const u8 gUnknown_841DE7C[];
-extern const u8 gUnknown_841DE7D[];
-extern const u8 gUnknown_841DE95[];
-extern const u8 gUnknown_841DE96[];
-extern const u8 gUnknown_841DE97[];
-extern const u8 gUnknown_841DE98[];
-extern const u8 gUnknown_841DE99[];
-extern const u8 gUnknown_841DE9A[];
-extern const u8 gUnknown_841DE9B[];
-extern const u8 gUnknown_841DE9C[];
+static void Task_EReaderComm(u8 taskId);
+static bool32 IsReceivedWonderNewsHeaderValid(const struct MEWonderNewsData * src);
+static void BlankWonderNews(void);
+static void BlankMENewsJisan(void);
+static bool32 IsReceivedWonderCardHeaderValid(const struct MEWonderCardData * src);
+static void BlankSavedWonderCard(void);
+static void BlankMEventBuffer2(void);
+static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 *idsList, s32 count);
+static void BlankBuffer344(void);
+
 extern const u8 gUnknownSerialData_Start[];
 extern const u8 gUnknownSerialData_End[];
 
-const u16 gUnknown_8466F00[] = {
-    0x02a7,
-    0x02a8,
-    0x02a9,
-    0x02aa,
-    0x02ab,
-    0x02ac,
-    0x02ad,
-    0x02ae,
-    0x02af,
-    0x02b0,
-    0x02b1,
-    0x02b2,
-    0x02b3,
-    0x02b4,
-    0x02b5,
-    0x02b6,
-    0x02b7,
-    0x02b8,
-    0x02b9,
-    0x02ba
+static const u16 sGiftItemFlagIds[] = {
+    FLAG_GOT_AURORA_TICKET,
+    FLAG_GOT_MYSTIC_TICKET,
+    FLAG_0x2A9,
+    FLAG_0x2AA,
+    FLAG_0x2AB,
+    FLAG_0x2AC,
+    FLAG_0x2AD,
+    FLAG_0x2AE,
+    FLAG_0x2AF,
+    FLAG_0x2B0,
+    FLAG_0x2B1,
+    FLAG_0x2B2,
+    FLAG_0x2B3,
+    FLAG_0x2B4,
+    FLAG_0x2B5,
+    FLAG_0x2B6,
+    FLAG_0x2B7,
+    FLAG_0x2B8,
+    FLAG_0x2B9,
+    FLAG_0x2BA
 };
 
-struct MEvent_Str_1 gUnknown_3005ED0;
+struct MEvent_Str_1 sMEventSendToEReaderManager;
 
-static EWRAM_DATA bool32 gUnknown_203F3BC = FALSE;
+static EWRAM_DATA bool32 sReceivedWonderCardIsValid = FALSE;
 
-void sub_81435DC(struct MEvent_Str_1 *mgr, size_t size, const void * data)
+void SendUnknownSerialData_Init(struct MEvent_Str_1 *mgr, size_t size, const void * data)
 {
     vu16 imeBak = REG_IME;
     REG_IME = 0;
@@ -106,7 +94,7 @@ void sub_81435DC(struct MEvent_Str_1 *mgr, size_t size, const void * data)
     mgr->data = data;
 }
 
-void sub_8143644(struct MEvent_Str_1 *unused)
+void SendUnknownSerialData_Teardown(struct MEvent_Str_1 *unused)
 {
     vu16 imeBak = REG_IME;
     REG_IME = 0;
@@ -116,15 +104,15 @@ void sub_8143644(struct MEvent_Str_1 *unused)
     REG_IME = imeBak;
 }
 
-u8 sub_8143674(struct MEvent_Str_1 *mgr)
+u8 SendUnknownSerialData_Run(struct MEvent_Str_1 *mgr)
 {
     u8 resp = 0;
     mgr->status = EReaderHandleTransfer(1, mgr->size, mgr->data, 0);
-    if ((mgr->status & 0x13) == 0x10)
+    if ((mgr->status & 0x13) == 0x10) // checksum OK and xfer off
         resp = 1;
-    if (mgr->status & 8)
+    if (mgr->status & 8) // cancelled by player
         resp = 2;
-    if (mgr->status & 4)
+    if (mgr->status & 4) // timed out
         resp = 3;
     gShouldAdvanceLinkState = 0;
     return resp;
@@ -161,32 +149,32 @@ static bool32 IsEReaderConnectionSane(void)
     return FALSE;
 }
 
-u32 sub_8143770(u8 * r4, u16 * r5)
+static u32 EReaderReceive(u8 * state_p, u16 * receiveDelay)
 {
-    if ((*r4 == 3 || *r4 == 4 || *r4 == 5) && HasLinkErrorOccurred())
+    if ((*state_p == 3 || *state_p == 4 || *state_p == 5) && HasLinkErrorOccurred())
     {
-        *r4 = 0;
+        *state_p = 0;
         return 3;
     }
-    switch (*r4)
+    switch (*state_p)
     {
         case 0:
             if (IsLinkMaster() && GetLinkPlayerCount_2() > 1)
             {
-                *r4 = 1;
+                *state_p = 1;
                 ;
             }
             else if (JOY_NEW(B_BUTTON))
             {
-                *r4 = 0;
+                *state_p = 0;
                 return 1;
             }
             break;
         case 1:
-            if (++(*r5) > 5)
+            if (++(*receiveDelay) > 5)
             {
-                *r5 = 0;
-                *r4 = 2;
+                *receiveDelay = 0;
+                *state_p = 2;
             }
             break;
         case 2:
@@ -194,19 +182,19 @@ u32 sub_8143770(u8 * r4, u16 * r5)
             {
                 PlaySE(SE_PINPON);
                 CheckShouldAdvanceLinkState();
-                *r5 = 0;
-                *r4 = 3;
+                *receiveDelay = 0;
+                *state_p = 3;
             }
             else if (JOY_NEW(B_BUTTON))
             {
-                *r4 = 0;
+                *state_p = 0;
                 return 1;
             }
             break;
         case 3:
-            if (++(*r5) > 30)
+            if (++(*receiveDelay) > 30)
             {
-                *r4 = 0;
+                *state_p = 0;
                 return 5;
             }
             else if (IsLinkConnectionEstablished())
@@ -215,24 +203,24 @@ u32 sub_8143770(u8 * r4, u16 * r5)
                 {
                     if (IsLinkPlayerDataExchangeComplete())
                     {
-                        *r4 = 0;
+                        *state_p = 0;
                         return 2;
                     }
                     else
-                        *r4 = 4;
+                        *state_p = 4;
                 }
                 else
-                    *r4 = 3;
+                    *state_p = 3;
             }
             break;
         case 4:
-            sub_800AA80(0);
-            *r4 = 5;
+            Link_StartSend5FFFwithParam(0);
+            *state_p = 5;
             break;
         case 5:
             if (!gReceivedRemoteLinkPlayers)
             {
-                *r4 = 0;
+                *state_p = 0;
                 return 4;
             }
             break;
@@ -242,19 +230,19 @@ u32 sub_8143770(u8 * r4, u16 * r5)
 
 void task_add_00_ereader(void)
 {
-    u8 taskId = CreateTask(sub_8143910, 0);
+    u8 taskId = CreateTask(Task_EReaderComm, 0);
     struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data;
     data->state = 0;
-    data->t09 = 0;
+    data->textOrReceiveState = 0;
     data->t0A = 0;
     data->t0B = 0;
     data->t0C = 0;
     data->t0D = 0;
-    data->t00 = 0;
+    data->stateAdvanceDelay = 0;
     data->t02 = 0;
     data->t04 = 0;
     data->t06 = 0;
-    data->t0E = 0;
+    data->initialSendResult = 0;
     data->t10 = AllocZeroed(sizeof(struct MEvent_Str_2));
 }
 
@@ -273,22 +261,22 @@ static bool32 AdvanceDelayTimerCheckTimeout(u16 * a0, u16 a1)
     return FALSE;
 }
 
-void sub_8143910(u8 taskId)
+static void Task_EReaderComm(u8 taskId)
 {
     struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data;
     switch (data->state)
     {
         case 0:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE52))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ReceiveMysteryGiftWithEReader))
                 data->state = 1;
             break;
         case 1:
             ResetTTDataBuffer();
-            ResetDelayTimer(&data->t00);
+            ResetDelayTimer(&data->stateAdvanceDelay);
             data->state = 2;
             break;
         case 2:
-            if (AdvanceDelayTimerCheckTimeout(&data->t00, 10))
+            if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10))
                 data->state = 3;
             break;
         case 3:
@@ -301,22 +289,22 @@ void sub_8143910(u8 taskId)
                 data->state = 13;
             break;
         case 4:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE53))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_SelectConnectFromEReaderMenu))
             {
-                AddTextPrinterToWindow1(gUnknown_841DE54);
-                ResetDelayTimer(&data->t00);
+                AddTextPrinterToWindow1(gJPText_SelectConnectWithGBA);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 data->state = 5;
             }
             break;
         case 5:
-            if (AdvanceDelayTimerCheckTimeout(&data->t00, 90))
+            if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 90))
             {
                 ResetTTDataBuffer();
                 data->state = 6;
             }
             else if (JOY_NEW(B_BUTTON))
             {
-                ResetDelayTimer(&data->t00);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 PlaySE(SE_SELECT);
                 data->state = 23;
             }
@@ -326,12 +314,12 @@ void sub_8143910(u8 taskId)
             {
                 PlaySE(SE_SELECT);
                 CloseLink();
-                ResetDelayTimer(&data->t00);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 data->state = 23;
             }
             else if (GetLinkPlayerCount_2() > 1)
             {
-                ResetDelayTimer(&data->t00);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 CloseLink();
                 data->state = 7;
             }
@@ -339,72 +327,80 @@ void sub_8143910(u8 taskId)
             {
                 PlaySE(SE_SELECT);
                 CloseLink();
-                ResetDelayTimer(&data->t00);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 data->state = 8;
             }
-            else if (AdvanceDelayTimerCheckTimeout(&data->t00, 10))
+            else if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10))
             {
                 CloseLink();
                 ResetTTDataBuffer();
-                ResetDelayTimer(&data->t00);
+                ResetDelayTimer(&data->stateAdvanceDelay);
             }
             break;
         case 7:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7C))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_LinkIsIncorrect))
                 data->state = 4;
             break;
         case 8:
-            AddTextPrinterToWindow1(gUnknown_841DE95);
-            sub_81435DC(&gUnknown_3005ED0, gUnknownSerialData_End - gUnknownSerialData_Start, gUnknownSerialData_Start);
+            AddTextPrinterToWindow1(gJPText_Connecting);
+            SendUnknownSerialData_Init(&sMEventSendToEReaderManager, gUnknownSerialData_End - gUnknownSerialData_Start, gUnknownSerialData_Start);
             data->state = 9;
             break;
         case 9:
-            data->t0E = sub_8143674(&gUnknown_3005ED0);
-            if (data->t0E != 0)
+            data->initialSendResult = SendUnknownSerialData_Run(&sMEventSendToEReaderManager);
+            if (data->initialSendResult != 0)
                 data->state = 10;
             break;
         case 10:
-            sub_8143644(&gUnknown_3005ED0);
-            if (data->t0E == 3)
+            SendUnknownSerialData_Teardown(&sMEventSendToEReaderManager);
+            if (data->initialSendResult == 3)
+                // Error
                 data->state = 20;
-            else if (data->t0E == 1)
+            else if (data->initialSendResult == 1)
             {
-                ResetDelayTimer(&data->t00);
-                AddTextPrinterToWindow1(gUnknown_841DE9B);
+                // OK
+                ResetDelayTimer(&data->stateAdvanceDelay);
+                AddTextPrinterToWindow1(gJPText_PleaseWaitAMoment);
                 data->state = 11;
             }
             else
+                // Try again
                 data->state = 0;
             break;
         case 11:
-            if (AdvanceDelayTimerCheckTimeout(&data->t00, 840))
+            if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 840))
                 data->state = 12;
             break;
         case 12:
             ResetTTDataBuffer();
-            AddTextPrinterToWindow1(gUnknown_841DE98);
+            AddTextPrinterToWindow1(gJPText_AllowEReaderToLoadCard);
             data->state = 13;
             break;
         case 13:
-            switch (sub_8143770(&data->t09, &data->t00))
+            switch (EReaderReceive(&data->textOrReceiveState, &data->stateAdvanceDelay))
             {
                 case 0:
+                    // Running
                     break;
                 case 2:
-                    AddTextPrinterToWindow1(gUnknown_841DE95);
+                    // Done
+                    AddTextPrinterToWindow1(gJPText_Connecting);
                     data->state = 14;
                     break;
                 case 1:
+                    // Cancelled
                     PlaySE(SE_SELECT);
                     CloseLink();
                     data->state = 23;
                     break;
                 case 5:
+                    // Error Try Again
                     CloseLink();
                     data->state = 21;
                     break;
                 case 3:
                 case 4:
+                    // Error CheckLink
                     CloseLink();
                     data->state = 20;
                     break;
@@ -423,55 +419,55 @@ void sub_8143910(u8 taskId)
             }
             break;
         case 15:
-            data->t0E = ValidateTrainerTowerData((struct EReaderTrainerHillSet *)gDecompressionBuffer);
-            sub_800AA80(data->t0E);
+            data->initialSendResult = ValidateTrainerTowerData((struct EReaderTrainerTowerSet *)gDecompressionBuffer);
+            Link_StartSend5FFFwithParam(data->initialSendResult);
             data->state = 16;
             break;
         case 16:
             if (!gReceivedRemoteLinkPlayers)
             {
-                if (data->t0E == 1)
+                if (data->initialSendResult == 1)
                     data->state = 17;
                 else
                     data->state = 20;
             }
             break;
         case 17:
-            if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerHillSet *)gDecompressionBuffer))
+            if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerTowerSet *)gDecompressionBuffer))
             {
-                AddTextPrinterToWindow1(gUnknown_841DE99);
-                ResetDelayTimer(&data->t00);
+                AddTextPrinterToWindow1(gJPText_ConnectionComplete);
+                ResetDelayTimer(&data->stateAdvanceDelay);
                 data->state = 18;
             }
             else
                 data->state = 22;
             break;
         case 18:
-            if (AdvanceDelayTimerCheckTimeout(&data->t00, 120))
+            if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 120))
             {
-                AddTextPrinterToWindow1(gUnknown_841DE9A);
-                PlayFanfare(258);
+                AddTextPrinterToWindow1(gJPText_NewTrainerHasComeToSevii);
+                PlayFanfare(MUS_FANFA4);
                 data->state = 19;
             }
             break;
         case 19:
-            if (IsFanfareTaskInactive() &&JOY_NEW(A_BUTTON | B_BUTTON))
+            if (IsFanfareTaskInactive() && JOY_NEW(A_BUTTON | B_BUTTON))
                 data->state = 26;
             break;
         case 23:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7D))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_CardReadingHasBeenHalted))
                 data->state = 26;
             break;
         case 20:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE96))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ConnectionErrorCheckLink))
                 data->state = 0;
             break;
         case 21:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE97))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ConnectionErrorTryAgain))
                 data->state = 0;
             break;
         case 22:
-            if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE9C))
+            if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_WriteErrorUnableToSaveData))
                 data->state = 0;
             break;
         case 26:
@@ -483,10 +479,10 @@ void sub_8143910(u8 taskId)
     }
 }
 
-void sub_8143D24(void)
+void InitMEventData(void)
 {
     CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers, sizeof(gSaveBlock1Ptr->mysteryEventBuffers));
-    sub_8143ED0();
+    BlankMENewsJisan();
     EC_ResetMEventProfileMaybe();
 }
 
@@ -517,14 +513,14 @@ u16 * GetMEventProfileECWordsMaybe(void)
 
 void DestroyWonderNews(void)
 {
-    sub_8143E9C();
+    BlankWonderNews();
 }
 
-bool32 sub_8143DC8(const struct MEWonderNewsData * src)
+bool32 OverwriteSavedWonderNewsWithReceivedNews(const struct MEWonderNewsData * src)
 {
-    if (!sub_8143E64(src))
+    if (!IsReceivedWonderNewsHeaderValid(src))
         return FALSE;
-    sub_8143E9C();
+    BlankWonderNews();
     gSaveBlock1Ptr->mysteryEventBuffers.menews.data = *src;
     gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData));
     return TRUE;
@@ -534,14 +530,14 @@ bool32 ValidateReceivedWonderNews(void)
 {
     if (CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData)) != gSaveBlock1Ptr->mysteryEventBuffers.menews.crc)
         return FALSE;
-    if (!sub_8143E64(&gSaveBlock1Ptr->mysteryEventBuffers.menews.data))
+    if (!IsReceivedWonderNewsHeaderValid(&gSaveBlock1Ptr->mysteryEventBuffers.menews.data))
         return FALSE;
     return TRUE;
 }
 
-bool32 sub_8143E64(const struct MEWonderNewsData * data)
+static bool32 IsReceivedWonderNewsHeaderValid(const struct MEWonderNewsData * data)
 {
-    if (data->unk_00 == 0)
+    if (data->newsId == 0)
         return FALSE;
     return TRUE;
 }
@@ -549,24 +545,24 @@ bool32 sub_8143E64(const struct MEWonderNewsData * data)
 bool32 WonderNews_Test_Unk_02(void)
 {
     const struct MEWonderNewsData * data = &gSaveBlock1Ptr->mysteryEventBuffers.menews.data;
-    if (data->unk_02 == 0)
+    if (data->shareState == 0)
         return FALSE;
     return TRUE;
 }
 
-void sub_8143E9C(void)
+static void BlankWonderNews(void)
 {
     CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->mysteryEventBuffers.menews.data));
     gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = 0;
 }
 
-void sub_8143ED0(void)
+static void BlankMENewsJisan(void)
 {
     CpuFill32(0, GetMENewsJisanStructPtr(), sizeof(struct MENewsJisanStruct));
     MENewsJisanReset();
 }
 
-bool32 sub_8143EF4(const u8 * src)
+bool32 MEvent_HaveAlreadyReceivedWonderNews(const u8 * src)
 {
     const u8 * r5 = (const u8 *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data;
     u32 i;
@@ -584,22 +580,23 @@ void DestroyWonderCard(void)
 {
     BlankSavedWonderCard();
     BlankMEventBuffer2();
-    sub_8144790();
+    BlankBuffer344();
     ClearRamScript();
-    sub_806E2D0();
-    sub_806E370();
+    ResetMysteryEventFlags();
+    ResetMysteryEventVars();
     ClearEReaderTrainer(&gSaveBlock2Ptr->battleTower.ereaderTrainer);
 }
 
-bool32 sub_8143F68(const struct MEWonderCardData * data)
+bool32 OverwriteSavedWonderCardWithReceivedCard(const struct MEWonderCardData * data)
 {
     struct MEventBuffer_3430_Sub * r2;
     struct MEWonderCardData * r1;
-    if (!sub_8144018(data))
+    if (!IsReceivedWonderCardHeaderValid(data))
         return FALSE;
     DestroyWonderCard();
     memcpy(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, data, sizeof(struct MEWonderCardData));
     gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData));
+    // Annoying hack to match
     r2 = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
     r1 = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     r2->unk_06 = r1->unk_02;
@@ -610,24 +607,24 @@ bool32 ValidateReceivedWonderCard(void)
 {
     if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc != CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData)))
         return FALSE;
-    if (!sub_8144018(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data))
+    if (!IsReceivedWonderCardHeaderValid(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data))
         return FALSE;
-    if (!sub_8069DFC())
+    if (!ValidateRamScript())
         return FALSE;
     return TRUE;
 }
 
-bool32 sub_8144018(const struct MEWonderCardData * data)
+static bool32 IsReceivedWonderCardHeaderValid(const struct MEWonderCardData * data)
 {
-    if (data->unk_00 == 0)
+    if (data->cardId == 0)
         return FALSE;
     if (data->unk_08_0 > 2)
         return FALSE;
-    if (!(data->unk_08_6 == 0 || data->unk_08_6 == 1 || data->unk_08_6 == 2))
+    if (!(data->shareState == 0 || data->shareState == 1 || data->shareState == 2))
         return FALSE;
     if (data->unk_08_2 > 7)
         return FALSE;
-    if (data->unk_09 > 7)
+    if (data->recvMonCapacity > 7)
         return FALSE;
     return TRUE;
 }
@@ -635,18 +632,18 @@ bool32 sub_8144018(const struct MEWonderCardData * data)
 bool32 WonderCard_Test_Unk_08_6(void)
 {
     const struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
-    if (data->unk_08_6 == 0)
+    if (data->shareState == 0)
         return FALSE;
     return TRUE;
 }
 
-void BlankSavedWonderCard(void)
+static void BlankSavedWonderCard(void)
 {
     CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData));
     gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = 0;
 }
 
-void BlankMEventBuffer2(void)
+static void BlankMEventBuffer2(void)
 {
     CpuFill32(0, sav1_get_mevent_buffer_2(), 18 * sizeof(u16));
     gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.crc = 0;
@@ -655,17 +652,17 @@ void BlankMEventBuffer2(void)
 u16 GetWonderCardFlagId(void)
 {
     if (ValidateReceivedWonderCard())
-        return gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00;
+        return gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.cardId;
     return 0;
 }
 
-void sub_814410C(struct MEWonderCardData * buffer)
+void MEvent_WonderCardResetUnk08_6(struct MEWonderCardData * buffer)
 {
-    if (buffer->unk_08_6 == 1)
-        buffer->unk_08_6 = 0;
+    if (buffer->shareState == 1)
+        buffer->shareState = 0;
 }
 
-bool32 sub_8144124(u16 a0)
+static bool32 IsCardIdInValidRange(u16 a0)
 {
     if (a0 >= 1000 && a0 < 1020)
         return TRUE;
@@ -675,33 +672,33 @@ bool32 sub_8144124(u16 a0)
 bool32 CheckReceivedGiftFromWonderCard(void)
 {
     u16 value = GetWonderCardFlagId();
-    if (!sub_8144124(value))
+    if (!IsCardIdInValidRange(value))
         return FALSE;
-    if (FlagGet(gUnknown_8466F00[value - 1000]) == TRUE)
+    if (FlagGet(sGiftItemFlagIds[value - 1000]) == TRUE)
         return FALSE;
     return TRUE;
 }
 
-s32 sub_8144184(const struct MEventBuffer_3430_Sub * data, s32 size)
+static s32 CountReceivedDistributionMons(const struct MEventBuffer_3430_Sub * data, s32 size)
 {
     s32 r3 = 0;
     s32 i;
     for (i = 0; i < size; i++)
     {
-        if (data->unk_08[1][i] && data->unk_08[0][i])
+        if (data->distributedMons[1][i] && data->distributedMons[0][i])
             r3++;
     }
     return r3;
 }
 
-bool32 sub_81441AC(const struct MEventBuffer_3430_Sub * data1, const u16 * data2, s32 size)
+static bool32 HasPlayerAlreadyReceivedDistributedMon(const struct MEventBuffer_3430_Sub * data1, const u16 * data2, s32 size)
 {
     s32 i;
     for (i = 0; i < size; i++)
     {
-        if (data1->unk_08[1][i] == data2[1])
+        if (data1->distributedMons[1][i] == data2[1])
             return TRUE;
-        if (data1->unk_08[0][i] == data2[0])
+        if (data1->distributedMons[0][i] == data2[0])
             return TRUE;
     }
     return FALSE;
@@ -718,7 +715,7 @@ static bool32 IsWonderCardSpeciesValid(const u16 * data)
     return TRUE;
 }
 
-s32 sub_8144218(void)
+static s32 ValidateCardAndCountMonsReceived(void)
 {
     struct MEWonderCardData * data;
     if (!ValidateReceivedWonderCard())
@@ -726,24 +723,24 @@ s32 sub_8144218(void)
     data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     if (data->unk_08_0 != 1)
         return 0;
-    return sub_8144184(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data->unk_09);
+    return CountReceivedDistributionMons(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data->recvMonCapacity);
 }
 
-bool32 sub_8144254(const u16 * data)
+bool32 MEvent_ReceiveDistributionMon(const u16 * data)
 {
     struct MEWonderCardData * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
-    s32 size = buffer->unk_09;
+    s32 capacity = buffer->recvMonCapacity;
     s32 i;
     if (!IsWonderCardSpeciesValid(data))
         return FALSE;
-    if (sub_81441AC(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data, size))
+    if (HasPlayerAlreadyReceivedDistributedMon(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data, capacity))
         return FALSE;
-    for (i = 0; i < size; i++)
+    for (i = 0; i < capacity; i++)
     {
-        if (gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] == 0 && gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] == 0)
+        if (gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[1][i] == 0 && gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[0][i] == 0)
         {
-            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] = data[1];
-            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] = data[0];
+            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[1][i] = data[1];
+            gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[0][i] = data[0];
             return TRUE;
         }
     }
@@ -771,9 +768,9 @@ void BuildMEventClientHeader(struct MEventClientHeaderStruct * data)
     if (ValidateReceivedWonderCard())
     {
         // Populate fields
-        data->id = GetSavedWonderCard()->unk_00;
+        data->id = GetSavedWonderCard()->cardId;
         data->unk_20 = *sav1_get_mevent_buffer_2();
-        data->unk_44 = GetSavedWonderCard()->unk_09;
+        data->maxDistributionMons = GetSavedWonderCard()->recvMonCapacity;
     }
     else
         data->id = 0;
@@ -815,14 +812,14 @@ u32 sub_8144418(const u16 * a0, const struct MEventClientHeaderStruct * a1, void
     return 2;
 }
 
-u32 sub_8144434(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused)
+u32 MEvent_CanPlayerReceiveDistributionMon(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused)
 {
-    s32 r4 = a1->unk_44 - sub_8144184(&a1->unk_20, a1->unk_44);
-    if (r4 == 0)
+    s32 numSpaces = a1->maxDistributionMons - CountReceivedDistributionMons(&a1->unk_20, a1->maxDistributionMons);
+    if (numSpaces == 0)
         return 1;
-    if (sub_81441AC(&a1->unk_20, a0, a1->unk_44))
+    if (HasPlayerAlreadyReceivedDistributedMon(&a1->unk_20, a0, a1->maxDistributionMons))
         return 3;
-    if (r4 == 1)
+    if (numSpaces == 1)
         return 4;
     return 2;
 }
@@ -838,9 +835,9 @@ bool32 sub_8144474(const struct MEventClientHeaderStruct * a0, const u16 * a1)
     return TRUE;
 }
 
-s32 sub_814449C(const struct MEventClientHeaderStruct * a0)
+static s32 GetNumReceivedDistributionMons(const struct MEventClientHeaderStruct * a0)
 {
-    return sub_8144184(&a0->unk_20, a0->unk_44);
+    return CountReceivedDistributionMons(&a0->unk_20, a0->maxDistributionMons);
 }
 
 u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command)
@@ -848,22 +845,23 @@ u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command)
     switch (command)
     {
         case 0:
-            return a0->unk_20.unk_00;
+            return a0->unk_20.linkWins;
         case 1:
-            return a0->unk_20.unk_02;
+            return a0->unk_20.linkLosses;
         case 2:
-            return a0->unk_20.unk_04;
+            return a0->unk_20.linkTrades;
         case 3:
-            return sub_814449C(a0);
+            return GetNumReceivedDistributionMons(a0);
         case 4:
-            return a0->unk_44;
+            return a0->maxDistributionMons;
         default:
              AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 825);
             return 0;
     }
 }
 
-void sub_814451C(u32 command)
+// Increments an interaction count in the save block
+static void IncrementBattleCardCount(u32 command)
 {
     struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
     if (data->unk_08_0 == 2)
@@ -872,13 +870,13 @@ void sub_814451C(u32 command)
         switch (command)
         {
             case 0:
-                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_00;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkWins;
                 break;
             case 1:
-                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_02;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkLosses;
                 break;
             case 2:
-                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_04;
+                dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkTrades;
                 break;
             case 3:
                 break;
@@ -896,7 +894,7 @@ void sub_814451C(u32 command)
     }
 }
 
-u16 sub_81445C0(u32 command)
+u16 MEvent_GetBattleCardCount(u32 command)
 {
     switch (command)
     {
@@ -906,7 +904,7 @@ u16 sub_81445C0(u32 command)
             if (data->unk_08_0 == 2)
             {
                 struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
-                return buffer->unk_00;
+                return buffer->linkWins;
             }
             break;
         }
@@ -916,7 +914,7 @@ u16 sub_81445C0(u32 command)
             if (data->unk_08_0 == 2)
             {
                 struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
-                return buffer->unk_02;
+                return buffer->linkLosses;
             }
             break;
         }
@@ -926,7 +924,7 @@ u16 sub_81445C0(u32 command)
             if (data->unk_08_0 == 2)
             {
                 struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data;
-                return buffer->unk_04;
+                return buffer->linkTrades;
             }
             break;
         }
@@ -934,14 +932,14 @@ u16 sub_81445C0(u32 command)
         {
             struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 1)
-                return sub_8144218();
+                return ValidateCardAndCountMonsReceived();
             break;
         }
         case 4:
         {
             struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data;
             if (data->unk_08_0 == 1)
-                return data->unk_09;
+                return data->recvMonCapacity;
             break;
         }
     }
@@ -949,38 +947,38 @@ u16 sub_81445C0(u32 command)
     return 0;
 }
 
-void sub_81446C4(void)
+void ResetReceivedWonderCardFlag(void)
 {
-    gUnknown_203F3BC = FALSE;
+    sReceivedWonderCardIsValid = FALSE;
 }
 
-bool32 sub_81446D0(u16 a0)
+bool32 MEventHandleReceivedWonderCard(u16 cardId)
 {
-    gUnknown_203F3BC = FALSE;
-    if (a0 == 0)
+    sReceivedWonderCardIsValid = FALSE;
+    if (cardId == 0)
         return FALSE;
     if (!ValidateReceivedWonderCard())
         return FALSE;
-    if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00 != a0)
+    if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.cardId != cardId)
         return FALSE;
-    gUnknown_203F3BC = TRUE;
+    sReceivedWonderCardIsValid = TRUE;
     return TRUE;
 }
 
-void sub_8144714(u32 a0, u32 a1)
+void MEvent_RecordIdOfWonderCardSenderByEventType(u32 eventId, u32 trainerId)
 {
-    if (gUnknown_203F3BC)
+    if (sReceivedWonderCardIsValid)
     {
-        switch (a0)
+        switch (eventId)
         {
-            case 2:
-                sub_8144824(2, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[1], 5);
+            case 2: // trade
+                RecordIdOfWonderCardSender(2, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[1], 5);
                 break;
-            case 0:
-                sub_8144824(0, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
+            case 0: // link win
+                RecordIdOfWonderCardSender(0, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
                 break;
-            case 1:
-                sub_8144824(1, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
+            case 1: // link loss
+                RecordIdOfWonderCardSender(1, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5);
                 break;
             default:
                  AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 988);
@@ -988,43 +986,48 @@ void sub_8144714(u32 a0, u32 a1)
     }
 }
 
-void sub_8144790(void)
+static void BlankBuffer344(void)
 {
     CpuFill32(0, gSaveBlock1Ptr->mysteryEventBuffers.unk_344, sizeof(gSaveBlock1Ptr->mysteryEventBuffers.unk_344));
 }
 
-bool32 sub_81447BC(u32 a0, u32 * a1, s32 size)
+// Looks up trainerId in an array idsList with count elements.
+// If trainerId is found, rearranges idsList to put it in the front.
+// Otherwise, drops the last element of the list and inserts
+// trainerId at the front.
+// Returns TRUE in the latter case.
+static bool32 PlaceTrainerIdAtFrontOfList(u32 trainerId, u32 * idsList, s32 count)
 {
     s32 i;
     s32 j;
 
-    for (i = 0; i < size; i++)
+    for (i = 0; i < count; i++)
     {
-        if (a1[i] == a0)
+        if (idsList[i] == trainerId)
             break;
     }
-    if (i == size)
+    if (i == count)
     {
-        for (j = size - 1; j > 0; j--)
+        for (j = count - 1; j > 0; j--)
         {
-            a1[j] = a1[j - 1];
+            idsList[j] = idsList[j - 1];
         }
-        a1[0] = a0;
+        idsList[0] = trainerId;
         return TRUE;
     }
     else
     {
         for (j = i; j > 0; j--)
         {
-            a1[j] = a1[j - 1];
+            idsList[j] = idsList[j - 1];
         }
-        a1[0] = a0;
+        idsList[0] = trainerId;
         return FALSE;
     }
 }
 
-void sub_8144824(u32 a0, u32 a1, u32 * a2, s32 a3)
+static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 * idsList, s32 count)
 {
-    if (sub_81447BC(a1, a2, a3))
-        sub_814451C(a0);
+    if (PlaceTrainerIdAtFrontOfList(trainerId, idsList, count))
+        IncrementBattleCardCount(eventId);
 }
diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c
deleted file mode 100644
index 3de09ab44..000000000
--- a/src/mevent_8145654.c
+++ /dev/null
@@ -1,793 +0,0 @@
-#include "global.h"
-#include "constants/species.h"
-#include "bg.h"
-#include "gpu_regs.h"
-#include "palette.h"
-#include "decompress.h"
-#include "malloc.h"
-#include "menu.h"
-#include "new_menu_helpers.h"
-#include "pokemon_icon.h"
-#include "mystery_gift_menu.h"
-#include "menu_indicators.h"
-#include "string_util.h"
-#include "link_rfu.h"
-#include "mevent.h"
-#include "battle_anim.h"
-
-struct UnkStruct_8467FB8
-{
-    u8 textPal1:4;
-    u8 textPal2:4;
-    u8 textPal3:4;
-    u8 textPal4:4;
-    const u8 * tiles;
-    const u8 * map;
-    const u16 * pal;
-};
-
-struct UnkStruct_203F3C8_02DC
-{
-    u8 unk_00;
-    u8 unk_01[41];
-    u8 unk_42[4];
-};
-
-struct UnkStruct_203F3C8
-{
-    /*0000*/ struct MEWonderCardData unk_0000;
-    /*014c*/ struct MEventBuffer_3430_Sub unk_014C;
-    /*0170*/ const struct UnkStruct_8467FB8 * unk_0170;
-    /*0174*/ u8 unk_0174;
-    /*0175*/ u8 unk_0175;
-    /*0176*/ u16 unk_0176[3];
-    /*017C*/ u8 unk_017C;
-    /*017D*/ u8 unk_017D[7][2];
-    /*018B*/ u8 unk_018B[41];
-    /*01B4*/ u8 unk_01B4[41];
-    /*01DD*/ u8 unk_01DD[7];
-    /*01E4*/ u8 unk_01E4[4][41];
-    /*0288*/ u8 unk_0288[41];
-    /*02B1*/ u8 unk_02B1[41];
-    /*02DC*/ struct UnkStruct_203F3C8_02DC unk_02DC[8];
-    /*045C*/ u8 buffer_045C[0x1000];
-};
-
-EWRAM_DATA struct UnkStruct_203F3C8 * gUnknown_203F3C8 = NULL;
-
-void sub_8145A98(void);
-void sub_8145D18(u8 whichWindow);
-void sub_8146060(void);
-void sub_81461D8(void);
-
-const u8 gUnknown_8467068[][3] = {
-    {0, 2, 3},
-    {0, 1, 2}
-};
-const u8 ALIGNED(4) gUnknown_8467070[3] = {7, 4, 7};
-const struct WindowTemplate gUnknown_8467074[] = {
-    {0x01, 0x01, 0x01, 0x19, 0x04, 0x0f, 0x029c},
-    {0x01, 0x01, 0x06, 0x1c, 0x08, 0x0f, 0x01bc},
-    {0x01, 0x01, 0x0e, 0x1c, 0x05, 0x0f, 0x0130}
-};
-
-const u16 gUnknown_846708C[] = INCBIN_U16("data/graphics/mevent/pal_46708C.gbapal");
-const u16 gUnknown_84670AC[] = INCBIN_U16("data/graphics/mevent/pal_4670AC.gbapal");
-const u16 gUnknown_84670CC[] = INCBIN_U16("data/graphics/mevent/pal_4670CC.gbapal");
-const u16 gUnknown_84670EC[] = INCBIN_U16("data/graphics/mevent/pal_4670EC.gbapal");
-const u16 gUnknown_846710C[] = INCBIN_U16("data/graphics/mevent/pal_46710C.gbapal");
-const u16 gUnknown_846712C[] = INCBIN_U16("data/graphics/mevent/pal_46712C.gbapal");
-const u16 gUnknown_846714C[] = INCBIN_U16("data/graphics/mevent/pal_46714C.gbapal");
-const u16 gUnknown_846716C[] = INCBIN_U16("data/graphics/mevent/pal_46716C.gbapal");
-const u8 gUnknown_846718C[] = INCBIN_U8("data/graphics/mevent/gfx_46718C.4bpp.lz");
-const u8 gUnknown_8467288[] = INCBIN_U8("data/graphics/mevent/tilemap_467288.bin.lz");
-const u8 gUnknown_846737C[] = INCBIN_U8("data/graphics/mevent/gfx_46737C.4bpp.lz");
-const u8 gUnknown_8467470[] = INCBIN_U8("data/graphics/mevent/tilemap_467470.bin.lz");
-const u8 gUnknown_8467558[] = INCBIN_U8("data/graphics/mevent/gfx_467558.4bpp.lz");
-const u8 gUnknown_846762C[] = INCBIN_U8("data/graphics/mevent/tilemap_46762C.bin.lz");
-const u8 gUnknown_8467700[] = INCBIN_U8("data/graphics/mevent/gfx_467700.4bpp.lz");
-const u8 gUnknown_8467934[] = INCBIN_U8("data/graphics/mevent/tilemap_467934.bin.lz");
-const u8 gUnknown_8467A7C[] = INCBIN_U8("data/graphics/mevent/gfx_467A7C.4bpp.lz");
-const u8 gUnknown_8467CAC[] = INCBIN_U8("data/graphics/mevent/tilemap_467CAC.bin.lz");
-const u16 gUnknown_8467DF4[] = INCBIN_U16("data/graphics/mevent/pal_467DF4.gbapal");
-const u16 gUnknown_8467E14[] = INCBIN_U16("data/graphics/mevent/pal_467E14.gbapal");
-const u16 gUnknown_8467E34[] = INCBIN_U16("data/graphics/mevent/pal_467E34.gbapal");
-const u16 gUnknown_8467E54[] = INCBIN_U16("data/graphics/mevent/pal_467E54.gbapal");
-const u16 gUnknown_8467E74[] = INCBIN_U16("data/graphics/mevent/pal_467E74.gbapal");
-const u16 gUnknown_8467E94[] = INCBIN_U16("data/graphics/mevent/pal_467E94.gbapal");
-const u16 gUnknown_8467EB4[] = INCBIN_U16("data/graphics/mevent/pal_467EB4.gbapal");
-const u16 gUnknown_8467ED4[] = INCBIN_U16("data/graphics/mevent/pal_467ED4.gbapal");
-const u32 gUnknown_8467EF4[] = INCBIN_U32("data/graphics/mevent/gfx_467EF4.4bpp.lz");
-
-const struct CompressedSpriteSheet gUnknown_8467F58 = {
-    gUnknown_8467EF4, 0x100, 0x8000
-};
-const struct SpritePalette gUnknown_8467F60[] = {
-    {gUnknown_8467DF4, 0x8000},
-    {gUnknown_8467E14, 0x8000},
-    {gUnknown_8467E34, 0x8000},
-    {gUnknown_8467E54, 0x8000},
-    {gUnknown_8467E74, 0x8000},
-    {gUnknown_8467E94, 0x8000},
-    {gUnknown_8467EB4, 0x8000},
-    {gUnknown_8467ED4, 0x8000}
-};
-const struct SpriteTemplate gUnknown_8467FA0 = {
-    0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy
-};
-const struct UnkStruct_8467FB8 gUnknown_8467FB8[8] = {
-    {1, 0, 0, 0, gUnknown_846718C, gUnknown_8467288, gUnknown_846708C},
-    {1, 0, 0, 1, gUnknown_846737C, gUnknown_8467470, gUnknown_84670AC},
-    {1, 0, 0, 2, gUnknown_8467558, gUnknown_846762C, gUnknown_84670CC},
-    {1, 0, 0, 3, gUnknown_8467558, gUnknown_846762C, gUnknown_84670EC},
-    {1, 0, 0, 4, gUnknown_8467558, gUnknown_846762C, gUnknown_846710C},
-    {1, 0, 0, 5, gUnknown_8467558, gUnknown_846762C, gUnknown_846712C},
-    {1, 0, 0, 6, gUnknown_8467700, gUnknown_8467934, gUnknown_846714C},
-    {1, 0, 0, 7, gUnknown_8467A7C, gUnknown_8467CAC, gUnknown_846716C}
-};
-
-bool32 InitWonderCardResources(struct MEWonderCardData * r5, struct MEventBuffer_3430_Sub * r6)
-{
-    if (r5 == NULL || r6 == NULL)
-        return FALSE;
-    gUnknown_203F3C8 = AllocZeroed(sizeof(struct UnkStruct_203F3C8));
-    if (gUnknown_203F3C8 == NULL)
-        return FALSE;
-    gUnknown_203F3C8->unk_0000 = *r5;
-    gUnknown_203F3C8->unk_014C = *r6;
-    if (gUnknown_203F3C8->unk_0000.unk_08_2 >= NELEMS(gUnknown_8467FB8))
-        gUnknown_203F3C8->unk_0000.unk_08_2 = 0;
-    if (gUnknown_203F3C8->unk_0000.unk_08_0 >= NELEMS(gUnknown_8467070))
-        gUnknown_203F3C8->unk_0000.unk_08_0 = 0;
-    if (gUnknown_203F3C8->unk_0000.unk_09 > NELEMS(gUnknown_203F3C8->unk_017D))
-        gUnknown_203F3C8->unk_0000.unk_09 = 0;
-    gUnknown_203F3C8->unk_0170 = &gUnknown_8467FB8[gUnknown_203F3C8->unk_0000.unk_08_2];
-    return TRUE;
-}
-
-void DestroyWonderCardResources(void)
-{
-    if (gUnknown_203F3C8 != NULL)
-    {
-        *gUnknown_203F3C8 = (struct UnkStruct_203F3C8){};
-        Free(gUnknown_203F3C8);
-        gUnknown_203F3C8 = NULL;
-    }
-}
-
-s32 FadeToWonderCardMenu(void)
-{
-    if (gUnknown_203F3C8 == NULL)
-        return -1;
-    switch(gUnknown_203F3C8->unk_0174)
-    {
-        case 0:
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
-            break;
-        case 1:
-            if (UpdatePaletteFade())
-                return 0;
-            break;
-        case 2:
-            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(1);
-            CopyBgTilemapBufferToVram(2);
-            DecompressAndCopyTileDataToVram(2, gUnknown_203F3C8->unk_0170->tiles, 0, 0x008, 0);
-            gUnknown_203F3C8->unk_0176[0] = AddWindow(&gUnknown_8467074[0]);
-            gUnknown_203F3C8->unk_0176[1] = AddWindow(&gUnknown_8467074[1]);
-            gUnknown_203F3C8->unk_0176[2] = AddWindow(&gUnknown_8467074[2]);
-            break;
-        case 3:
-            if (FreeTempTileDataBuffersIfPossible())
-                return 0;
-            gPaletteFade.bufferTransferDisabled = TRUE;
-            LoadPalette(gUnknown_203F3C8->unk_0170->pal, 0x10, 0x20);
-            LZ77UnCompWram(gUnknown_203F3C8->unk_0170->map, gUnknown_203F3C8->buffer_045C);
-            CopyRectToBgTilemapBufferRect(2, gUnknown_203F3C8->buffer_045C, 0, 0, 30, 20, 0, 0, 30, 20, 1, 0x008, 0);
-            CopyBgTilemapBufferToVram(2);
-            break;
-        case 4:
-            sub_8145A98();
-            break;
-        case 5:
-            sub_8145D18(0);
-            sub_8145D18(1);
-            sub_8145D18(2);
-            CopyBgTilemapBufferToVram(1);
-            break;
-        case 6:
-            LoadMonIconPalettes();
-            break;
-        case 7:
-            ShowBg(1);
-            ShowBg(2);
-            gPaletteFade.bufferTransferDisabled = FALSE;
-            sub_8146060();
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0);
-            UpdatePaletteFade();
-            break;
-        default:
-            if (UpdatePaletteFade())
-                return 0;
-            gUnknown_203F3C8->unk_0174 = 0;
-            return 1;
-    }
-    ++gUnknown_203F3C8->unk_0174;
-    return 0;
-}
-
-s32 FadeOutFromWonderCard(bool32 flag)
-{
-    if (gUnknown_203F3C8 == NULL)
-        return -1;
-    switch (gUnknown_203F3C8->unk_0174)
-    {
-        case 0:
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
-            break;
-        case 1:
-            if (UpdatePaletteFade())
-                return 0;
-            break;
-        case 2:
-            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(1);
-            CopyBgTilemapBufferToVram(2);
-            break;
-        case 3:
-            HideBg(1);
-            HideBg(2);
-            RemoveWindow(gUnknown_203F3C8->unk_0176[2]);
-            RemoveWindow(gUnknown_203F3C8->unk_0176[1]);
-            RemoveWindow(gUnknown_203F3C8->unk_0176[0]);
-            break;
-        case 4:
-            sub_81461D8();
-            FreeMonIconPalettes();
-            break;
-        case 5:
-            PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag);
-            break;
-        case 6:
-            CopyBgTilemapBufferToVram(0);
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0);
-            break;
-        default:
-            if (UpdatePaletteFade())
-                return 0;
-            gUnknown_203F3C8->unk_0174 = 0;
-            return 1;
-    }
-    ++gUnknown_203F3C8->unk_0174;
-    return 0;
-}
-
-void sub_8145A98(void)
-{
-    u16 i = 0;
-    u16 r6;
-    u16 sp0[3] = {0, 0, 0};
-
-    memcpy(gUnknown_203F3C8->unk_018B, gUnknown_203F3C8->unk_0000.unk_0A, 40);
-    gUnknown_203F3C8->unk_018B[40] = EOS;
-    memcpy(gUnknown_203F3C8->unk_01B4, gUnknown_203F3C8->unk_0000.unk_32, 40);
-    gUnknown_203F3C8->unk_01B4[40] = EOS;
-    if (gUnknown_203F3C8->unk_0000.unk_04 > 999999)
-        gUnknown_203F3C8->unk_0000.unk_04 = 999999;
-    ConvertIntToDecimalStringN(gUnknown_203F3C8->unk_01DD, gUnknown_203F3C8->unk_0000.unk_04, STR_CONV_MODE_LEFT_ALIGN, 6);
-    for (i = 0; i < 4; i++)
-    {
-        memcpy(gUnknown_203F3C8->unk_01E4[i], gUnknown_203F3C8->unk_0000.unk_5A[i], 40);
-        gUnknown_203F3C8->unk_01E4[i][40] = EOS;
-    }
-    memcpy(gUnknown_203F3C8->unk_0288, gUnknown_203F3C8->unk_0000.unk_FA, 40);
-    gUnknown_203F3C8->unk_0288[40] = EOS;
-    switch (gUnknown_203F3C8->unk_0000.unk_08_0)
-    {
-        case 0:
-            memcpy(gUnknown_203F3C8->unk_02B1, gUnknown_203F3C8->unk_0000.unk_122, 40);
-            gUnknown_203F3C8->unk_02B1[40] = EOS;
-            break;
-        case 1:
-            gUnknown_203F3C8->unk_02B1[00] = EOS;
-            break;
-        case 2:
-            gUnknown_203F3C8->unk_02B1[00] = EOS;
-            sp0[0] = gUnknown_203F3C8->unk_014C.unk_00 < 999 ? gUnknown_203F3C8->unk_014C.unk_00 : 999;
-            sp0[1] = gUnknown_203F3C8->unk_014C.unk_02 < 999 ? gUnknown_203F3C8->unk_014C.unk_02 : 999;
-            sp0[2] = gUnknown_203F3C8->unk_014C.unk_04 < 999 ? gUnknown_203F3C8->unk_014C.unk_04 : 999;
-            for (i = 0; i < 8; i++)
-            {
-                memset(gUnknown_203F3C8->unk_02DC[i].unk_42, EOS, 4);
-                memset(gUnknown_203F3C8->unk_02DC[i].unk_01, EOS, 41);
-            }
-            for (i = 0, r6 = 0; i < 40; i++)
-            {
-                if (gUnknown_203F3C8->unk_0000.unk_122[i] != 0xF7)
-                {
-                    gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_01[r6] = gUnknown_203F3C8->unk_0000.unk_122[i];
-                    r6++;
-                }
-                else
-                {
-                    u8 r3 = gUnknown_203F3C8->unk_0000.unk_122[i + 1];
-                    if (r3 > 2)
-                    {
-                        i += 2;
-                    }
-                    else
-                    {
-                        ConvertIntToDecimalStringN(gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_42, sp0[r3], STR_CONV_MODE_LEADING_ZEROS, 3);
-                        gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_00 = gUnknown_203F3C8->unk_0000.unk_122[i + 2];
-                        gUnknown_203F3C8->unk_0175++;
-                        if (gUnknown_203F3C8->unk_0175 > 7)
-                            break;
-                        r6 = 0;
-                        i += 2;
-                    }
-                }
-            }
-    }
-}
-
-void sub_8145D18(u8 whichWindow)
-{
-    s8 sp0C = 0;
-    s32 windowId = gUnknown_203F3C8->unk_0176[whichWindow];
-    PutWindowTilemap(windowId);
-    FillWindowPixelBuffer(windowId, 0);
-    switch (whichWindow)
-    {
-        case 0:
-        {
-            s32 x;
-            AddTextPrinterParameterized3(windowId, 3, 0, 1, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_018B);
-            x = 160 - GetStringWidth(3, gUnknown_203F3C8->unk_01B4, GetFontAttribute(3, 2));
-            if (x < 0)
-                x = 0;
-            AddTextPrinterParameterized3(windowId, 3, x, 17, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_01B4);
-            if (gUnknown_203F3C8->unk_0000.unk_04 != 0)
-            {
-                AddTextPrinterParameterized3(windowId, 2, 166, 17, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_01DD);
-            }
-            break;
-        }
-        case 1:
-            for (; sp0C < 4; sp0C++)
-            {
-                AddTextPrinterParameterized3(windowId, 3, 0, 16 * sp0C + 2, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal2], 0, gUnknown_203F3C8->unk_01E4[sp0C]);
-            }
-            break;
-        case 2:
-            AddTextPrinterParameterized3(windowId, 3, 0, gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0], gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_0288);
-            if (gUnknown_203F3C8->unk_0000.unk_08_0 != 2)
-            {
-                AddTextPrinterParameterized3(windowId, 3, 0, 16 + gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0], gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02B1);
-            }
-            else
-            {
-                s32 x = 0;
-                s32 y = gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0] + 16;
-                s32 spacing = GetFontAttribute(3, 2);
-                for (; sp0C < gUnknown_203F3C8->unk_0175; sp0C++)
-                {
-                    AddTextPrinterParameterized3(windowId, 3, x, y, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02DC[sp0C].unk_01);
-                    if (gUnknown_203F3C8->unk_02DC[sp0C].unk_42[0] != EOS)
-                    {
-                        x += GetStringWidth(3, gUnknown_203F3C8->unk_02DC[sp0C].unk_01, spacing);
-                        AddTextPrinterParameterized3(windowId, 2, x, y, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02DC[sp0C].unk_42);
-                        x += GetStringWidth(3, gUnknown_203F3C8->unk_02DC[sp0C].unk_42, spacing) + gUnknown_203F3C8->unk_02DC[sp0C].unk_00;
-                    }
-                }
-            }
-            break;
-    }
-    CopyWindowToVram(windowId, 3);
-}
-
-void sub_8146060(void)
-{
-    u8 r7 = 0;
-    gUnknown_203F3C8->unk_017C = 0xFF;
-    if (gUnknown_203F3C8->unk_014C.unk_06 != SPECIES_NONE)
-    {
-        gUnknown_203F3C8->unk_017C = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(gUnknown_203F3C8->unk_014C.unk_06), SpriteCallbackDummy, 0xDC, 0x14, 0, FALSE);
-        gSprites[gUnknown_203F3C8->unk_017C].oam.priority = 2;
-    }
-    if (gUnknown_203F3C8->unk_0000.unk_09 != 0 && gUnknown_203F3C8->unk_0000.unk_08_0 == 1)
-    {
-        LoadCompressedSpriteSheetUsingHeap(&gUnknown_8467F58);
-        LoadSpritePalette(&gUnknown_8467F60[gUnknown_203F3C8->unk_0170->textPal4]);
-        for (; r7 < gUnknown_203F3C8->unk_0000.unk_09; r7++)
-        {
-            gUnknown_203F3C8->unk_017D[r7][0] = 0xFF;
-            gUnknown_203F3C8->unk_017D[r7][1] = 0xFF;
-            gUnknown_203F3C8->unk_017D[r7][0] = CreateSprite(&gUnknown_8467FA0, 0xd8 - 32 * r7, 0x90, 8);
-            if (gUnknown_203F3C8->unk_014C.unk_08[0][r7] != 0)
-            {
-                gUnknown_203F3C8->unk_017D[r7][1] = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(gUnknown_203F3C8->unk_014C.unk_08[0][r7]), SpriteCallbackDummy, 0xd8 - 32 * r7, 0x88, 0, 0);
-                gSprites[gUnknown_203F3C8->unk_017D[r7][1]].oam.priority = 2;
-            }
-        }
-    }
-}
-
-void sub_81461D8(void)
-{
-    u8 r6 = 0;
-    if (gUnknown_203F3C8->unk_017C != 0xFF)
-        DestroyMonIcon(&gSprites[gUnknown_203F3C8->unk_017C]);
-    if (gUnknown_203F3C8->unk_0000.unk_09 != 0 && gUnknown_203F3C8->unk_0000.unk_08_0 == 1)
-    {
-        for (; r6 < gUnknown_203F3C8->unk_0000.unk_09; r6++)
-        {
-            if (gUnknown_203F3C8->unk_017D[r6][0] != 0xFF)
-            {
-                DestroySprite(&gSprites[gUnknown_203F3C8->unk_017D[r6][0]]);
-                // This might be a typo.  Uncomment the next line, and comment the one that follows, to get the presumed intended behavior.
-                // if (gUnknown_203F3C8->unk_017D[r6][1] != 0xFF)
-                if (gUnknown_203F3C8->unk_017D[r6][0] != 0xFF)
-                {
-                    DestroyMonIcon(&gSprites[gUnknown_203F3C8->unk_017D[r6][1]]);
-                }
-            }
-        }
-        FreeSpriteTilesByTag(0x8000);
-        FreeSpritePaletteByTag(0x8000);
-    }
-}
-
-struct UnkStruct_203F3CC
-{
-    /*0000*/ struct MEWonderNewsData unk_0000;
-    /*01bc*/ const struct UnkStruct_8467FB8 * unk_01BC;
-    /*01c0*/ u8 unk_01C0_0:1;
-             u8 unk_01C0_1:7;
-    /*01c1*/ u8 unk_01C1;
-    /*01c2*/ u8 unk_01C2_0:1;
-             u8 unk_01C2_1:7;
-    /*01c3*/ u8 unk_01C3_0:1;
-             u8 unk_01C3_1:7;
-    /*01c4*/ u16 unk_01C4;
-    /*01c6*/ u16 unk_01C6;
-    /*01c8*/ u16 unk_01C8[2];
-    /*01cc*/ u8 filler_01CC[2];
-    /*01ce*/ u8 unk_01CE[41];
-    /*01f7*/ u8 unk_01F7[10][41];
-    /*0394*/ struct ScrollArrowsTemplate unk_0394;
-    /*03a4*/ u8 buffer_03A4[0x1000];
-};
-
-EWRAM_DATA struct UnkStruct_203F3CC * gUnknown_203F3CC = NULL;
-
-void sub_8146980(void);
-void sub_8146A30(void);
-void sub_8146B58(void);
-
-const u8 gUnknown_8468038[][3] = {
-    {0, 2, 3},
-    {0, 1, 2}
-};
-const struct WindowTemplate gUnknown_8468040[] = {
-    {0, 1, 0, 28,  3, 15, 0x000},
-    {2, 1, 3, 28, 20, 15, 0x000}
-};
-const struct ScrollArrowsTemplate gUnknown_8468050 = {
-    0x02, 0xe8, 0x18, 0x03, 0xe8, 0x98,
-    0x0000, 0x0002, 0x1000, 0x1000, 0x0,
-};
-
-const u16 gUnknown_8468060[] = INCBIN_U16("data/graphics/mevent/pal_468060.gbapal");
-const u16 gUnknown_8468080[] = INCBIN_U16("data/graphics/mevent/pal_468080.gbapal");
-const u16 gUnknown_84680A0[] = INCBIN_U16("data/graphics/mevent/pal_4680A0.gbapal");
-const u8 gUnknown_84680C0[] = INCBIN_U8("data/graphics/mevent/gfx_4680C0.4bpp.lz");
-const u8 gUnknown_8468140[] = INCBIN_U8("data/graphics/mevent/tilemap_468140.bin.lz");
-const u8 gUnknown_846821C[] = INCBIN_U8("data/graphics/mevent/gfx_46821C.4bpp.lz");
-const u8 gUnknown_846824C[] = INCBIN_U8("data/graphics/mevent/tilemap_46824C.bin.lz");
-const u8 gUnknown_846830C[] = INCBIN_U8("data/graphics/mevent/gfx_46830C.4bpp.lz");
-const u8 gUnknown_846837C[] = INCBIN_U8("data/graphics/mevent/tilemap_46837C.bin.lz");
-const u8 gUnknown_8468448[] = INCBIN_U8("data/graphics/mevent/gfx_468448.4bpp.lz");
-const u8 gUnknown_84684D8[] = INCBIN_U8("data/graphics/mevent/tilemap_4684D8.bin.lz");
-const u8 gUnknown_84685B4[] = INCBIN_U8("data/graphics/mevent/gfx_4685B4.4bpp.lz");
-const u8 gUnknown_8468644[] = INCBIN_U8("data/graphics/mevent/tilemap_468644.bin.lz");
-
-const struct UnkStruct_8467FB8 gUnknown_8468720[] = {
-    {1, 0, 0, 0, gUnknown_84680C0, gUnknown_8468140, gUnknown_8468060},
-    {1, 0, 0, 0, gUnknown_846821C, gUnknown_846824C, gUnknown_84670AC},
-    {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_84670CC},
-    {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_84670EC},
-    {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_846710C},
-    {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_846712C},
-    {1, 0, 0, 0, gUnknown_8468448, gUnknown_84684D8, gUnknown_8468080},
-    {1, 0, 0, 0, gUnknown_84685B4, gUnknown_8468644, gUnknown_84680A0}
-};
-
-bool32 InitWonderNewsResources(const struct MEWonderNewsData * a0)
-{
-    if (a0 == NULL)
-        return FALSE;
-    gUnknown_203F3CC = AllocZeroed(sizeof(struct UnkStruct_203F3CC));
-    if (gUnknown_203F3CC == NULL)
-        return FALSE;
-    gUnknown_203F3CC->unk_0000 = *a0;
-    if (gUnknown_203F3CC->unk_0000.unk_03 >= NELEMS(gUnknown_8468720))
-        gUnknown_203F3CC->unk_0000.unk_03 = 0;
-    gUnknown_203F3CC->unk_01BC = &gUnknown_8468720[gUnknown_203F3CC->unk_0000.unk_03];
-    gUnknown_203F3CC->unk_01C1 = 0xFF;
-    return TRUE;
-}
-
-void DestroyWonderNewsResources(void)
-{
-    if (gUnknown_203F3CC != NULL)
-    {
-        *gUnknown_203F3CC = (struct UnkStruct_203F3CC){};
-        Free(gUnknown_203F3CC);
-        gUnknown_203F3CC = NULL;
-    }
-}
-
-s32 FadeToWonderNewsMenu(void)
-{
-    if (gUnknown_203F3CC == NULL)
-        return -1;
-
-    switch (gUnknown_203F3CC->unk_01C0_1)
-    {
-        case 0:
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
-            break;
-        case 1:
-            if (UpdatePaletteFade())
-                return 0;
-            ChangeBgY(0, 0, 0);
-            ChangeBgY(1, 0, 0);
-            ChangeBgY(2, 0, 0);
-            ChangeBgY(3, 0, 0);
-            SetGpuReg(REG_OFFSET_WIN0H, 0xF0);
-            SetGpuReg(REG_OFFSET_WIN0V, 0x1A98);
-            SetGpuReg(REG_OFFSET_WININ, 0x1F);
-            SetGpuReg(REG_OFFSET_WINOUT, 0x1B);
-            SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
-            break;
-        case 2:
-            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 20);
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(1);
-            CopyBgTilemapBufferToVram(2);
-            CopyBgTilemapBufferToVram(3);
-            DecompressAndCopyTileDataToVram(3, gUnknown_203F3CC->unk_01BC->tiles, 0, 8, 0);
-            gUnknown_203F3CC->unk_01C8[0] = AddWindow(&gUnknown_8468040[0]);
-            gUnknown_203F3CC->unk_01C8[1] = AddWindow(&gUnknown_8468040[1]);
-            break;
-        case 3:
-            if (FreeTempTileDataBuffersIfPossible())
-                return 0;
-            gPaletteFade.bufferTransferDisabled = TRUE;
-            LoadPalette(gUnknown_203F3CC->unk_01BC->pal, 0x10, 0x20);
-            LZ77UnCompWram(gUnknown_203F3CC->unk_01BC->map, gUnknown_203F3CC->buffer_03A4);
-            CopyRectToBgTilemapBufferRect(1, gUnknown_203F3CC->buffer_03A4, 0, 0, 30, 3, 0, 0, 30, 3, 1, 8, 0);
-            CopyRectToBgTilemapBufferRect(3, gUnknown_203F3CC->buffer_03A4, 0, 3, 30, 23, 0, 3, 30, 23, 1, 8, 0);
-            CopyBgTilemapBufferToVram(1);
-            CopyBgTilemapBufferToVram(3);
-            break;
-        case 4:
-            sub_8146980();
-            break;
-        case 5:
-            sub_8146A30();
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(2);
-            break;
-        case 6:
-            ShowBg(1);
-            ShowBg(2);
-            ShowBg(3);
-            gPaletteFade.bufferTransferDisabled = FALSE;
-            gUnknown_203F3CC->unk_01C1 = AddScrollIndicatorArrowPair(&gUnknown_203F3CC->unk_0394, &gUnknown_203F3CC->unk_01C6);
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0);
-            UpdatePaletteFade();
-            break;
-        default:
-            if (UpdatePaletteFade())
-                return 0;
-            gUnknown_203F3CC->unk_01C0_1 = 0;
-            return 1;
-    }
-
-    ++gUnknown_203F3CC->unk_01C0_1;
-    return 0;
-}
-
-s32 FadeOutFromWonderNews(bool32 flag)
-{
-    if (gUnknown_203F3CC == NULL)
-        return -1;
-    switch (gUnknown_203F3CC->unk_01C0_1)
-    {
-        case 0:
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
-            break;
-        case 1:
-            if (UpdatePaletteFade())
-                return 0;
-            ChangeBgY(2, 0, 0);
-            SetGpuReg(REG_OFFSET_WIN0H, 0);
-            SetGpuReg(REG_OFFSET_WIN0V, 0);
-            SetGpuReg(REG_OFFSET_WININ, 0);
-            SetGpuReg(REG_OFFSET_WINOUT, 0);
-            ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
-            break;
-        case 2:
-            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
-            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 24);
-            FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 24);
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(1);
-            CopyBgTilemapBufferToVram(2);
-            CopyBgTilemapBufferToVram(3);
-            break;
-        case 3:
-            HideBg(1);
-            HideBg(2);
-            RemoveWindow(gUnknown_203F3CC->unk_01C8[1]);
-            RemoveWindow(gUnknown_203F3CC->unk_01C8[0]);
-            break;
-        case 4:
-            ChangeBgY(2, 0, 0);
-            ChangeBgY(3, 0, 0);
-            if (gUnknown_203F3CC->unk_01C1 != 0xFF)
-            {
-                RemoveScrollIndicatorArrowPair(gUnknown_203F3CC->unk_01C1);
-                gUnknown_203F3CC->unk_01C1 = 0xFF;
-            }
-            break;
-        case 5:
-            PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag);
-            break;
-        case 6:
-            MG_DrawCheckerboardPattern();
-            CopyBgTilemapBufferToVram(0);
-            CopyBgTilemapBufferToVram(3);
-            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0);
-            break;
-        default:
-            if (UpdatePaletteFade())
-                return 0;
-            gUnknown_203F3CC->unk_01C0_1 = 0;
-            return 1;
-    }
-    ++gUnknown_203F3CC->unk_01C0_1;
-    return 0;
-}
-
-void MENews_RemoveScrollIndicatorArrowPair(void)
-{
-    if (!gUnknown_203F3CC->unk_01C0_0 && gUnknown_203F3CC->unk_01C1 != 0xFF)
-    {
-        RemoveScrollIndicatorArrowPair(gUnknown_203F3CC->unk_01C1);
-        gUnknown_203F3CC->unk_01C1 = 0xFF;
-        gUnknown_203F3CC->unk_01C0_0 = TRUE;
-    }
-}
-
-
-void MENews_AddScrollIndicatorArrowPair(void)
-{
-    if (gUnknown_203F3CC->unk_01C0_0)
-    {
-        gUnknown_203F3CC->unk_01C1 = AddScrollIndicatorArrowPair(&gUnknown_203F3CC->unk_0394, &gUnknown_203F3CC->unk_01C6);
-        gUnknown_203F3CC->unk_01C0_0 = FALSE;
-    }
-}
-
-u32 MENews_GetInput(u16 input)
-{
-    if (gUnknown_203F3CC->unk_01C2_0)
-    {
-        sub_8146B58();
-        return 0xFF;
-    }
-    switch (input)
-    {
-        case A_BUTTON:
-            return 0;
-        case B_BUTTON:
-            return 1;
-        case DPAD_UP:
-            if (gUnknown_203F3CC->unk_01C6 == 0)
-                return 0xFF;
-            if (gUnknown_203F3CC->unk_01C0_0)
-                return 0xFF;
-            gUnknown_203F3CC->unk_01C3_0 = FALSE;
-            break;
-        case DPAD_DOWN:
-            if (gUnknown_203F3CC->unk_01C6 == gUnknown_203F3CC->unk_01C4)
-                return 0xFF;
-            if (gUnknown_203F3CC->unk_01C0_0)
-                return 0xFF;
-            gUnknown_203F3CC->unk_01C3_0 = TRUE;
-            break;
-        default:
-            return 0xFF;
-    }
-    gUnknown_203F3CC->unk_01C2_0 = TRUE;
-    gUnknown_203F3CC->unk_01C2_1 = 2;
-    gUnknown_203F3CC->unk_01C3_1 = 0;
-    if (gUnknown_203F3CC->unk_01C3_0 == FALSE)
-        return 2;
-    else
-        return 3;
-}
-
-void sub_8146980(void)
-{
-    u8 i = 0;
-    memcpy(gUnknown_203F3CC->unk_01CE, gUnknown_203F3CC->unk_0000.unk_04, 40);
-    gUnknown_203F3CC->unk_01CE[40] = EOS;
-    for (; i < 10; ++i)
-    {
-        memcpy(gUnknown_203F3CC->unk_01F7[i], gUnknown_203F3CC->unk_0000.unk_2C[i], 40);
-        gUnknown_203F3CC->unk_01F7[i][40] = EOS;
-        if (i > 7 && gUnknown_203F3CC->unk_01F7[i][0] != EOS)
-            ++gUnknown_203F3CC->unk_01C4;
-    }
-    gUnknown_203F3CC->unk_0394 = gUnknown_8468050;
-    gUnknown_203F3CC->unk_0394.fullyDownThreshold = gUnknown_203F3CC->unk_01C4;
-}
-
-void sub_8146A30(void)
-{
-    u8 i = 0;
-    s32 x;
-    PutWindowTilemap(gUnknown_203F3CC->unk_01C8[0]);
-    PutWindowTilemap(gUnknown_203F3CC->unk_01C8[1]);
-    FillWindowPixelBuffer(gUnknown_203F3CC->unk_01C8[0], 0);
-    FillWindowPixelBuffer(gUnknown_203F3CC->unk_01C8[1], 0);
-    x = (0xe0 - GetStringWidth(3, gUnknown_203F3CC->unk_01CE, GetFontAttribute(3, 2))) / 2;
-    if (x < 0)
-        x = 0;
-    AddTextPrinterParameterized3(gUnknown_203F3CC->unk_01C8[0], 3, x, 6, gUnknown_8468038[gUnknown_203F3CC->unk_01BC->textPal1], 0, gUnknown_203F3CC->unk_01CE);
-    for (; i < 10; ++i)
-    {
-        AddTextPrinterParameterized3(gUnknown_203F3CC->unk_01C8[1], 3, 0, 16 * i + 2, gUnknown_8468038[gUnknown_203F3CC->unk_01BC->textPal2], 0, gUnknown_203F3CC->unk_01F7[i]);
-    }
-    CopyWindowToVram(gUnknown_203F3CC->unk_01C8[0], 3);
-    CopyWindowToVram(gUnknown_203F3CC->unk_01C8[1], 3);
-}
-
-void sub_8146B58(void)
-{
-    u16 r4 = gUnknown_203F3CC->unk_01C2_1;
-    r4 <<= 8;
-    if (gUnknown_203F3CC->unk_01C3_0)
-    {
-        ChangeBgY(2, r4, 1);
-        ChangeBgY(3, r4, 1);
-    }
-    else
-    {
-        ChangeBgY(2, r4, 2);
-        ChangeBgY(3, r4, 2);
-    }
-    gUnknown_203F3CC->unk_01C3_1 += gUnknown_203F3CC->unk_01C2_1;
-    if (gUnknown_203F3CC->unk_01C3_1 > 15)
-    {
-        if (gUnknown_203F3CC->unk_01C3_0)
-            ++gUnknown_203F3CC->unk_01C6;
-        else
-            --gUnknown_203F3CC->unk_01C6;
-        gUnknown_203F3CC->unk_01C2_0 = FALSE;
-        gUnknown_203F3CC->unk_01C3_1 = 0;
-    }
-}
diff --git a/src/mevent_client.c b/src/mevent_client.c
index 4da0b4bc1..d7eff1ec6 100644
--- a/src/mevent_client.c
+++ b/src/mevent_client.c
@@ -195,15 +195,16 @@ static u32 client_mainseq_4(struct mevent_client * svr)
         mevent_client_send_word(svr, 0x13, svr->param);
         break;
     case 10:
-        sub_8143F68(svr->recvBuffer);
+        OverwriteSavedWonderCardWithReceivedCard(svr->recvBuffer);
         break;
     case 9:
-        if (!sub_8143EF4(svr->recvBuffer))
+        if (!MEvent_HaveAlreadyReceivedWonderNews(svr->recvBuffer))
         {
-            sub_8143DC8(svr->recvBuffer);
+            OverwriteSavedWonderNewsWithReceivedNews(svr->recvBuffer);
             mevent_client_send_word(svr, 0x13, 0);
         }
         else
+            // Other trainer already has news
             mevent_client_send_word(svr, 0x13, 1);
         break;
     case 15:
@@ -211,7 +212,7 @@ static u32 client_mainseq_4(struct mevent_client * svr)
         svr->flag = 0;
         break;
     case 16:
-        sub_8144254(svr->recvBuffer);
+        MEvent_ReceiveDistributionMon(svr->recvBuffer);
         break;
     case 17:
         MEventSetRamScript(svr->recvBuffer, 1000);
diff --git a/src/mevent_server.c b/src/mevent_server.c
index bebd69fe3..f1505fcbc 100644
--- a/src/mevent_server.c
+++ b/src/mevent_server.c
@@ -1,10 +1,6 @@
 #include "global.h"
 #include "malloc.h"
-#include "decompress.h"
-#include "overworld.h"
 #include "script.h"
-#include "battle_tower.h"
-#include "mystery_event_script.h"
 #include "mevent.h"
 #include "mevent_server.h"
 
@@ -176,7 +172,7 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
         case 9:
             AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 408);
             ptr = mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord);
-            svr->param = sub_8144434(ptr, svr->mevent_unk1442cc, ptr);
+            svr->param = MEvent_CanPlayerReceiveDistributionMon(ptr, svr->mevent_unk1442cc, ptr);
             break;
         case 10:
             AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 415);
@@ -247,7 +243,7 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr)
         case 26:
             AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 506);
             memcpy(svr->card, GetSavedWonderCard(), 332);
-            sub_814410C(svr->card);
+            MEvent_WonderCardResetUnk08_6(svr->card);
             break;
         case 27:
             AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 512);
diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c
index 94c01c081..234064afc 100644
--- a/src/mevent_server_helpers.c
+++ b/src/mevent_server_helpers.c
@@ -1,14 +1,7 @@
 #include "global.h"
-#include "malloc.h"
-#include "decompress.h"
 #include "util.h"
 #include "link.h"
 #include "link_rfu.h"
-#include "overworld.h"
-#include "script.h"
-#include "battle_tower.h"
-#include "mystery_event_script.h"
-#include "mevent.h"
 #include "mevent_server.h"
 
 static u32 mevent_receive_func(struct mevent_srv_sub *);
diff --git a/src/mevent_show_card.c b/src/mevent_show_card.c
new file mode 100644
index 000000000..d2df613ae
--- /dev/null
+++ b/src/mevent_show_card.c
@@ -0,0 +1,456 @@
+#include "global.h"
+#include "constants/species.h"
+#include "bg.h"
+#include "palette.h"
+#include "decompress.h"
+#include "malloc.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "pokemon_icon.h"
+#include "mystery_gift_menu.h"
+#include "string_util.h"
+#include "mevent.h"
+#include "battle_anim.h"
+
+struct MEventScreenMgr_02DC
+{
+    u8 nDigits;
+    u8 nameTxt[41];
+    u8 numberTxt[4];
+};
+
+struct MEventScreenMgr
+{
+    /*0000*/ struct MEWonderCardData wonderCard;
+    /*014c*/ struct MEventBuffer_3430_Sub buff3430Sub;
+    /*0170*/ const struct UnkStruct_8467FB8 * bgSpec;
+    /*0174*/ u8 state;
+    /*0175*/ u8 recordIdx;
+    /*0176*/ u16 windowIds[3];
+    /*017C*/ u8 monIconId;
+    /*017D*/ u8 cardIconAndShadowSprites[7][2];
+    /*018B*/ u8 title[41];
+    /*01B4*/ u8 subtitle[41];
+    /*01DD*/ u8 unk_01DD[7];
+    /*01E4*/ u8 mainMessageLines[4][41];
+    /*0288*/ u8 instructionsLine1[41];
+    /*02B1*/ u8 instructionsLine2[41];
+    /*02DC*/ struct MEventScreenMgr_02DC recordStrings[8];
+    /*045C*/ u8 buffer_045C[0x1000];
+};
+
+static EWRAM_DATA struct MEventScreenMgr * sMEventScreenData = NULL;
+
+static void sub_8145A98(void);
+static void sub_8145D18(u8 whichWindow);
+static void sub_8146060(void);
+static void sub_81461D8(void);
+
+static const u8 gUnknown_8467068[][3] = {
+    {0, 2, 3},
+    {0, 1, 2}
+};
+
+static const u8 ALIGNED(4) sTextYCoords[3] = {7, 4, 7};
+
+static const struct WindowTemplate sWindowTemplates[] = {
+    {
+        .bg = 1,
+        .tilemapLeft = 1,
+        .tilemapTop = 1,
+        .width = 25,
+        .height = 4,
+        .paletteNum = 15, 
+        .baseBlock = 0x29c},
+    {
+        .bg = 1,
+        .tilemapLeft = 1,
+        .tilemapTop = 6,
+        .width = 28,
+        .height = 8,
+        .paletteNum = 15, 
+        .baseBlock = 0x1bc},
+    {
+        .bg = 1,
+        .tilemapLeft = 1,
+        .tilemapTop = 14,
+        .width = 28,
+        .height = 5,
+        .paletteNum = 15, 
+        .baseBlock = 0x130}
+};
+
+static const u16 gCard0Pal[] = INCBIN_U16("data/graphics/mevent/pal_46708C.gbapal");
+const u16 gCard1Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670AC.gbapal");
+const u16 gCard2Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670CC.gbapal");
+const u16 gCard3Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670EC.gbapal");
+const u16 gCard4Pal[] = INCBIN_U16("data/graphics/mevent/pal_46710C.gbapal");
+const u16 gCard5Pal[] = INCBIN_U16("data/graphics/mevent/pal_46712C.gbapal");
+static const u16 gCard6Pal[] = INCBIN_U16("data/graphics/mevent/pal_46714C.gbapal");
+static const u16 gCard7Pal[] = INCBIN_U16("data/graphics/mevent/pal_46716C.gbapal");
+static const u8 sCard0Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46718C.4bpp.lz");
+static const u8 sCard0Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467288.bin.lz");
+static const u8 sCard1Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46737C.4bpp.lz");
+static const u8 sCard1Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467470.bin.lz");
+static const u8 sCard2Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467558.4bpp.lz");
+static const u8 sCard2Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46762C.bin.lz");
+static const u8 sCard6Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467700.4bpp.lz");
+static const u8 sCard6Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467934.bin.lz");
+static const u8 sCard7Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467A7C.4bpp.lz");
+static const u8 sCard7Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467CAC.bin.lz");
+static const u16 gUnknown_8467DF4[] = INCBIN_U16("data/graphics/mevent/pal_467DF4.gbapal");
+static const u16 gUnknown_8467E14[] = INCBIN_U16("data/graphics/mevent/pal_467E14.gbapal");
+static const u16 gUnknown_8467E34[] = INCBIN_U16("data/graphics/mevent/pal_467E34.gbapal");
+static const u16 gUnknown_8467E54[] = INCBIN_U16("data/graphics/mevent/pal_467E54.gbapal");
+static const u16 gUnknown_8467E74[] = INCBIN_U16("data/graphics/mevent/pal_467E74.gbapal");
+static const u16 gUnknown_8467E94[] = INCBIN_U16("data/graphics/mevent/pal_467E94.gbapal");
+static const u16 gUnknown_8467EB4[] = INCBIN_U16("data/graphics/mevent/pal_467EB4.gbapal");
+static const u16 gUnknown_8467ED4[] = INCBIN_U16("data/graphics/mevent/pal_467ED4.gbapal");
+static const u32 gUnknown_8467EF4[] = INCBIN_U32("data/graphics/mevent/gfx_467EF4.4bpp.lz");
+
+static const struct CompressedSpriteSheet sShadowSpriteSheet = {
+    gUnknown_8467EF4, 0x100, 0x8000
+};
+
+static const struct SpritePalette sShadowSpritePalettes[] = {
+    {gUnknown_8467DF4, 0x8000},
+    {gUnknown_8467E14, 0x8000},
+    {gUnknown_8467E34, 0x8000},
+    {gUnknown_8467E54, 0x8000},
+    {gUnknown_8467E74, 0x8000},
+    {gUnknown_8467E94, 0x8000},
+    {gUnknown_8467EB4, 0x8000},
+    {gUnknown_8467ED4, 0x8000}
+};
+
+static const struct SpriteTemplate sShadowSpriteTemplate = {
+    0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy
+};
+
+static const struct UnkStruct_8467FB8 sCardGfxPtrs[8] = {
+    {1, 0, 0, 0, sCard0Gfx, sCard0Map, gCard0Pal},
+    {1, 0, 0, 1, sCard1Gfx, sCard1Map, gCard1Pal},
+    {1, 0, 0, 2, sCard2Gfx, sCard2Map, gCard2Pal},
+    {1, 0, 0, 3, sCard2Gfx, sCard2Map, gCard3Pal},
+    {1, 0, 0, 4, sCard2Gfx, sCard2Map, gCard4Pal},
+    {1, 0, 0, 5, sCard2Gfx, sCard2Map, gCard5Pal},
+    {1, 0, 0, 6, sCard6Gfx, sCard6Map, gCard6Pal},
+    {1, 0, 0, 7, sCard7Gfx, sCard7Map, gCard7Pal}
+};
+
+bool32 InitWonderCardResources(struct MEWonderCardData * card, struct MEventBuffer_3430_Sub * b3430sub)
+{
+    if (card == NULL || b3430sub == NULL)
+        return FALSE;
+    sMEventScreenData = AllocZeroed(sizeof(struct MEventScreenMgr));
+    if (sMEventScreenData == NULL)
+        return FALSE;
+    sMEventScreenData->wonderCard = *card;
+    sMEventScreenData->buff3430Sub = *b3430sub;
+    if (sMEventScreenData->wonderCard.unk_08_2 >= NELEMS(sCardGfxPtrs))
+        sMEventScreenData->wonderCard.unk_08_2 = 0;
+    if (sMEventScreenData->wonderCard.unk_08_0 >= NELEMS(sTextYCoords))
+        sMEventScreenData->wonderCard.unk_08_0 = 0;
+    if (sMEventScreenData->wonderCard.recvMonCapacity > NELEMS(sMEventScreenData->cardIconAndShadowSprites))
+        sMEventScreenData->wonderCard.recvMonCapacity = 0;
+    sMEventScreenData->bgSpec = &sCardGfxPtrs[sMEventScreenData->wonderCard.unk_08_2];
+    return TRUE;
+}
+
+void DestroyWonderCardResources(void)
+{
+    if (sMEventScreenData != NULL)
+    {
+        *sMEventScreenData = (struct MEventScreenMgr){};
+        Free(sMEventScreenData);
+        sMEventScreenData = NULL;
+    }
+}
+
+s32 FadeToWonderCardMenu(void)
+{
+    if (sMEventScreenData == NULL)
+        return -1;
+    switch(sMEventScreenData->state)
+    {
+        case 0:
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+            break;
+        case 1:
+            if (UpdatePaletteFade())
+                return 0;
+            break;
+        case 2:
+            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
+            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
+            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
+            CopyBgTilemapBufferToVram(0);
+            CopyBgTilemapBufferToVram(1);
+            CopyBgTilemapBufferToVram(2);
+            DecompressAndCopyTileDataToVram(2, sMEventScreenData->bgSpec->tiles, 0, 0x008, 0);
+            sMEventScreenData->windowIds[0] = AddWindow(&sWindowTemplates[0]);
+            sMEventScreenData->windowIds[1] = AddWindow(&sWindowTemplates[1]);
+            sMEventScreenData->windowIds[2] = AddWindow(&sWindowTemplates[2]);
+            break;
+        case 3:
+            if (FreeTempTileDataBuffersIfPossible())
+                return 0;
+            gPaletteFade.bufferTransferDisabled = TRUE;
+            LoadPalette(sMEventScreenData->bgSpec->pal, 0x10, 0x20);
+            LZ77UnCompWram(sMEventScreenData->bgSpec->map, sMEventScreenData->buffer_045C);
+            CopyRectToBgTilemapBufferRect(2, sMEventScreenData->buffer_045C, 0, 0, 30, 20, 0, 0, 30, 20, 1, 0x008, 0);
+            CopyBgTilemapBufferToVram(2);
+            break;
+        case 4:
+            sub_8145A98();
+            break;
+        case 5:
+            sub_8145D18(0);
+            sub_8145D18(1);
+            sub_8145D18(2);
+            CopyBgTilemapBufferToVram(1);
+            break;
+        case 6:
+            LoadMonIconPalettes();
+            break;
+        case 7:
+            ShowBg(1);
+            ShowBg(2);
+            gPaletteFade.bufferTransferDisabled = FALSE;
+            sub_8146060();
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+            UpdatePaletteFade();
+            break;
+        default:
+            if (UpdatePaletteFade())
+                return 0;
+            sMEventScreenData->state = 0;
+            return 1;
+    }
+    ++sMEventScreenData->state;
+    return 0;
+}
+
+s32 FadeOutFromWonderCard(bool32 flag)
+{
+    if (sMEventScreenData == NULL)
+        return -1;
+    switch (sMEventScreenData->state)
+    {
+        case 0:
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+            break;
+        case 1:
+            if (UpdatePaletteFade())
+                return 0;
+            break;
+        case 2:
+            FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
+            FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
+            FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
+            CopyBgTilemapBufferToVram(0);
+            CopyBgTilemapBufferToVram(1);
+            CopyBgTilemapBufferToVram(2);
+            break;
+        case 3:
+            HideBg(1);
+            HideBg(2);
+            RemoveWindow(sMEventScreenData->windowIds[2]);
+            RemoveWindow(sMEventScreenData->windowIds[1]);
+            RemoveWindow(sMEventScreenData->windowIds[0]);
+            break;
+        case 4:
+            sub_81461D8();
+            FreeMonIconPalettes();
+            break;
+        case 5:
+            PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag);
+            break;
+        case 6:
+            CopyBgTilemapBufferToVram(0);
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+            break;
+        default:
+            if (UpdatePaletteFade())
+                return 0;
+            sMEventScreenData->state = 0;
+            return 1;
+    }
+    ++sMEventScreenData->state;
+    return 0;
+}
+
+static void sub_8145A98(void)
+{
+    u16 i = 0;
+    u16 r6;
+    u16 sp0[3] = {0, 0, 0};
+
+    memcpy(sMEventScreenData->title, sMEventScreenData->wonderCard.unk_0A, 40);
+    sMEventScreenData->title[40] = EOS;
+    memcpy(sMEventScreenData->subtitle, sMEventScreenData->wonderCard.unk_32, 40);
+    sMEventScreenData->subtitle[40] = EOS;
+    if (sMEventScreenData->wonderCard.unk_04 > 999999)
+        sMEventScreenData->wonderCard.unk_04 = 999999;
+    ConvertIntToDecimalStringN(sMEventScreenData->unk_01DD, sMEventScreenData->wonderCard.unk_04, STR_CONV_MODE_LEFT_ALIGN, 6);
+    for (i = 0; i < 4; i++)
+    {
+        memcpy(sMEventScreenData->mainMessageLines[i], sMEventScreenData->wonderCard.unk_5A[i], 40);
+        sMEventScreenData->mainMessageLines[i][40] = EOS;
+    }
+    memcpy(sMEventScreenData->instructionsLine1, sMEventScreenData->wonderCard.unk_FA, 40);
+    sMEventScreenData->instructionsLine1[40] = EOS;
+    switch (sMEventScreenData->wonderCard.unk_08_0)
+    {
+        case 0:
+            memcpy(sMEventScreenData->instructionsLine2, sMEventScreenData->wonderCard.unk_122, 40);
+            sMEventScreenData->instructionsLine2[40] = EOS;
+            break;
+        case 1:
+            sMEventScreenData->instructionsLine2[00] = EOS;
+            break;
+        case 2:
+            sMEventScreenData->instructionsLine2[00] = EOS;
+            sp0[0] = sMEventScreenData->buff3430Sub.linkWins < 999 ? sMEventScreenData->buff3430Sub.linkWins : 999;
+            sp0[1] = sMEventScreenData->buff3430Sub.linkLosses < 999 ? sMEventScreenData->buff3430Sub.linkLosses : 999;
+            sp0[2] = sMEventScreenData->buff3430Sub.linkTrades < 999 ? sMEventScreenData->buff3430Sub.linkTrades : 999;
+            for (i = 0; i < 8; i++)
+            {
+                memset(sMEventScreenData->recordStrings[i].numberTxt, EOS, 4);
+                memset(sMEventScreenData->recordStrings[i].nameTxt, EOS, 41);
+            }
+            for (i = 0, r6 = 0; i < 40; i++)
+            {
+                if (sMEventScreenData->wonderCard.unk_122[i] != CHAR_SPECIAL_F7)
+                {
+                    sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].nameTxt[r6] = sMEventScreenData->wonderCard.unk_122[i];
+                    r6++;
+                }
+                else
+                {
+                    u8 r3 = sMEventScreenData->wonderCard.unk_122[i + 1];
+                    if (r3 > 2)
+                    {
+                        i += 2;
+                    }
+                    else
+                    {
+                        ConvertIntToDecimalStringN(sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].numberTxt, sp0[r3], STR_CONV_MODE_LEADING_ZEROS, 3);
+                        sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].nDigits = sMEventScreenData->wonderCard.unk_122[i + 2];
+                        sMEventScreenData->recordIdx++;
+                        if (sMEventScreenData->recordIdx > 7)
+                            break;
+                        r6 = 0;
+                        i += 2;
+                    }
+                }
+            }
+    }
+}
+
+static void sub_8145D18(u8 whichWindow)
+{
+    s8 sp0C = 0;
+    s32 windowId = sMEventScreenData->windowIds[whichWindow];
+    PutWindowTilemap(windowId);
+    FillWindowPixelBuffer(windowId, 0);
+    switch (whichWindow)
+    {
+        case 0:
+        {
+            s32 x;
+            AddTextPrinterParameterized3(windowId, 3, 0, 1, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->title);
+            x = 160 - GetStringWidth(3, sMEventScreenData->subtitle, GetFontAttribute(3, 2));
+            if (x < 0)
+                x = 0;
+            AddTextPrinterParameterized3(windowId, 3, x, 17, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->subtitle);
+            if (sMEventScreenData->wonderCard.unk_04 != 0)
+            {
+                AddTextPrinterParameterized3(windowId, 2, 166, 17, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->unk_01DD);
+            }
+            break;
+        }
+        case 1:
+            for (; sp0C < 4; sp0C++)
+            {
+                AddTextPrinterParameterized3(windowId, 3, 0, 16 * sp0C + 2, gUnknown_8467068[sMEventScreenData->bgSpec->textPal2], 0, sMEventScreenData->mainMessageLines[sp0C]);
+            }
+            break;
+        case 2:
+            AddTextPrinterParameterized3(windowId, 3, 0, sTextYCoords[sMEventScreenData->wonderCard.unk_08_0], gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->instructionsLine1);
+            if (sMEventScreenData->wonderCard.unk_08_0 != 2)
+            {
+                AddTextPrinterParameterized3(windowId, 3, 0, 16 + sTextYCoords[sMEventScreenData->wonderCard.unk_08_0], gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->instructionsLine2);
+            }
+            else
+            {
+                s32 x = 0;
+                s32 y = sTextYCoords[sMEventScreenData->wonderCard.unk_08_0] + 16;
+                s32 spacing = GetFontAttribute(3, 2);
+                for (; sp0C < sMEventScreenData->recordIdx; sp0C++)
+                {
+                    AddTextPrinterParameterized3(windowId, 3, x, y, gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->recordStrings[sp0C].nameTxt);
+                    if (sMEventScreenData->recordStrings[sp0C].numberTxt[0] != EOS)
+                    {
+                        x += GetStringWidth(3, sMEventScreenData->recordStrings[sp0C].nameTxt, spacing);
+                        AddTextPrinterParameterized3(windowId, 2, x, y, gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->recordStrings[sp0C].numberTxt);
+                        x += GetStringWidth(3, sMEventScreenData->recordStrings[sp0C].numberTxt, spacing) + sMEventScreenData->recordStrings[sp0C].nDigits;
+                    }
+                }
+            }
+            break;
+    }
+    CopyWindowToVram(windowId, 3);
+}
+
+static void sub_8146060(void)
+{
+    u8 r7 = 0;
+    sMEventScreenData->monIconId = 0xFF;
+    if (sMEventScreenData->buff3430Sub.unk_06 != SPECIES_NONE)
+    {
+        sMEventScreenData->monIconId = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(sMEventScreenData->buff3430Sub.unk_06), SpriteCallbackDummy, 0xDC, 0x14, 0, FALSE);
+        gSprites[sMEventScreenData->monIconId].oam.priority = 2;
+    }
+    if (sMEventScreenData->wonderCard.recvMonCapacity != 0 && sMEventScreenData->wonderCard.unk_08_0 == 1)
+    {
+        LoadCompressedSpriteSheetUsingHeap(&sShadowSpriteSheet);
+        LoadSpritePalette(&sShadowSpritePalettes[sMEventScreenData->bgSpec->index]);
+        for (; r7 < sMEventScreenData->wonderCard.recvMonCapacity; r7++)
+        {
+            sMEventScreenData->cardIconAndShadowSprites[r7][0] = 0xFF;
+            sMEventScreenData->cardIconAndShadowSprites[r7][1] = 0xFF;
+            sMEventScreenData->cardIconAndShadowSprites[r7][0] = CreateSprite(&sShadowSpriteTemplate, 0xd8 - 32 * r7, 0x90, 8);
+            if (sMEventScreenData->buff3430Sub.distributedMons[0][r7] != 0)
+            {
+                sMEventScreenData->cardIconAndShadowSprites[r7][1] = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(sMEventScreenData->buff3430Sub.distributedMons[0][r7]), SpriteCallbackDummy, 0xd8 - 32 * r7, 0x88, 0, 0);
+                gSprites[sMEventScreenData->cardIconAndShadowSprites[r7][1]].oam.priority = 2;
+            }
+        }
+    }
+}
+
+static void sub_81461D8(void)
+{
+    u8 r6 = 0;
+    if (sMEventScreenData->monIconId != 0xFF)
+        DestroyMonIcon(&gSprites[sMEventScreenData->monIconId]);
+    if (sMEventScreenData->wonderCard.recvMonCapacity != 0 && sMEventScreenData->wonderCard.unk_08_0 == 1)
+    {
+        for (; r6 < sMEventScreenData->wonderCard.recvMonCapacity; r6++)
+        {
+            if (sMEventScreenData->cardIconAndShadowSprites[r6][0] != 0xFF)
+            {
+                DestroySprite(&gSprites[sMEventScreenData->cardIconAndShadowSprites[r6][0]]);
+                // This might be a typo.  Uncomment the next line, and comment the one that follows, to get the presumed intended behavior.
+                // if (sMEventScreenData->cardIconAndShadowSprites[r6][1] != 0xFF)
+                if (sMEventScreenData->cardIconAndShadowSprites[r6][0] != 0xFF)
+                {
+                    DestroyMonIcon(&gSprites[sMEventScreenData->cardIconAndShadowSprites[r6][1]]);
+                }
+            }
+        }
+        FreeSpriteTilesByTag(0x8000);
+        FreeSpritePaletteByTag(0x8000);
+    }
+}
diff --git a/src/mevent_show_news.c b/src/mevent_show_news.c
new file mode 100644
index 000000000..44b19b130
--- /dev/null
+++ b/src/mevent_show_news.c
@@ -0,0 +1,357 @@
+#include "global.h"
+#include "gflib.h"
+#include "menu_indicators.h"
+#include "new_menu_helpers.h"
+#include "mevent.h"
+#include "mystery_gift_menu.h"
+#include "menu.h"
+#include "link_rfu.h"
+
+struct UnkStruct_203F3CC
+{
+    /*0000*/ struct MEWonderNewsData wonderNews;
+    /*01bc*/ const struct UnkStruct_8467FB8 * bgSpec;
+    /*01c0*/ u8 verticalScrollDisabled:1;
+    u8 state:7;
+    /*01c1*/ u8 menuIndicatorsId;
+    /*01c2*/ u8 unk_01C2_0:1;
+    u8 unk_01C2_1:7;
+    /*01c3*/ u8 scrollDirection:1;
+    u8 unk_01C3_1:7;
+    /*01c4*/ u16 numMails;
+    /*01c6*/ u16 scrollOffset;
+    /*01c8*/ u16 windowIds[2];
+    /*01cc*/ u8 filler_01CC[2];
+    /*01ce*/ u8 title[41];
+    /*01f7*/ u8 messages[10][41];
+    /*0394*/ struct ScrollArrowsTemplate scrollArrowsTemplate;
+    /*03a4*/ u8 buffer_03A4[0x1000];
+};
+
+static EWRAM_DATA struct UnkStruct_203F3CC * sWork = NULL;
+
+static void sub_8146980(void);
+static void sub_8146A30(void);
+static void sub_8146B58(void);
+
+static const u8 sTextPals[][3] = {
+    {0, 2, 3},
+    {0, 1, 2}
+};
+static const struct WindowTemplate gUnknown_8468040[] = {
+    {0, 1, 0, 28,  3, 15, 0x000},
+    {2, 1, 3, 28, 20, 15, 0x000}
+};
+static const struct ScrollArrowsTemplate sScrollArrowsTemplate = {
+    0x02, 0xe8, 0x18, 0x03, 0xe8, 0x98,
+    0x0000, 0x0002, 0x1000, 0x1000, 0x0,
+};
+
+static const u16 sNews1Pal[] = INCBIN_U16("data/graphics/mevent/pal_468060.gbapal");
+static const u16 sNews6Pal[] = INCBIN_U16("data/graphics/mevent/pal_468080.gbapal");
+static const u16 sNews7Pal[] = INCBIN_U16("data/graphics/mevent/pal_4680A0.gbapal");
+static const u8 sNews0Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_4680C0.4bpp.lz");
+static const u8 sNews0Map[] = INCBIN_U8("data/graphics/mevent/tilemap_468140.bin.lz");
+static const u8 sNews1Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46821C.4bpp.lz");
+static const u8 sNews1Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46824C.bin.lz");
+static const u8 sNews2Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46830C.4bpp.lz");
+static const u8 sNews2Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46837C.bin.lz");
+static const u8 sNews6Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_468448.4bpp.lz");
+static const u8 sNews6Map[] = INCBIN_U8("data/graphics/mevent/tilemap_4684D8.bin.lz");
+static const u8 sNews7Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_4685B4.4bpp.lz");
+static const u8 sNews7Map[] = INCBIN_U8("data/graphics/mevent/tilemap_468644.bin.lz");
+
+static const struct UnkStruct_8467FB8 sBgSpecs[] = {
+    {1, 0, 0, 0, sNews0Gfx, sNews0Map, sNews1Pal},
+    {1, 0, 0, 0, sNews1Gfx, sNews1Map, gCard1Pal},
+    {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard2Pal},
+    {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard3Pal},
+    {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard4Pal},
+    {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard5Pal},
+    {1, 0, 0, 0, sNews6Gfx, sNews6Map, sNews6Pal},
+    {1, 0, 0, 0, sNews7Gfx, sNews7Map, sNews7Pal}
+};
+
+bool32 InitWonderNewsResources(const struct MEWonderNewsData * news)
+{
+    if (news == NULL)
+        return FALSE;
+    sWork = AllocZeroed(sizeof(struct UnkStruct_203F3CC));
+    if (sWork == NULL)
+        return FALSE;
+    sWork->wonderNews = *news;
+    if (sWork->wonderNews.unk_03 >= NELEMS(sBgSpecs))
+        sWork->wonderNews.unk_03 = 0;
+    sWork->bgSpec = &sBgSpecs[sWork->wonderNews.unk_03];
+    sWork->menuIndicatorsId = 0xFF;
+    return TRUE;
+}
+
+void DestroyWonderNewsResources(void)
+{
+    if (sWork != NULL)
+    {
+        *sWork = (struct UnkStruct_203F3CC){};
+        Free(sWork);
+        sWork = NULL;
+    }
+}
+
+s32 FadeToWonderNewsMenu(void)
+{
+    if (sWork == NULL)
+        return -1;
+
+    switch (sWork->state)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        break;
+    case 1:
+        if (UpdatePaletteFade())
+            return 0;
+        ChangeBgY(0, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgY(3, 0, 0);
+        SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 240));
+        SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(26, 152));
+        SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ);
+        SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ);
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        break;
+    case 2:
+        FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
+        FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
+        FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20);
+        FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 20);
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(3);
+        DecompressAndCopyTileDataToVram(3, sWork->bgSpec->tiles, 0, 8, 0);
+        sWork->windowIds[0] = AddWindow(&gUnknown_8468040[0]);
+        sWork->windowIds[1] = AddWindow(&gUnknown_8468040[1]);
+        break;
+    case 3:
+        if (FreeTempTileDataBuffersIfPossible())
+            return 0;
+        gPaletteFade.bufferTransferDisabled = TRUE;
+        LoadPalette(sWork->bgSpec->pal, 0x10, 0x20);
+        LZ77UnCompWram(sWork->bgSpec->map, sWork->buffer_03A4);
+        CopyRectToBgTilemapBufferRect(1, sWork->buffer_03A4, 0, 0, 30, 3, 0, 0, 30, 3, 1, 8, 0);
+        CopyRectToBgTilemapBufferRect(3, sWork->buffer_03A4, 0, 3, 30, 23, 0, 3, 30, 23, 1, 8, 0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 4:
+        sub_8146980();
+        break;
+    case 5:
+        sub_8146A30();
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(2);
+        break;
+    case 6:
+        ShowBg(1);
+        ShowBg(2);
+        ShowBg(3);
+        gPaletteFade.bufferTransferDisabled = FALSE;
+        sWork->menuIndicatorsId = AddScrollIndicatorArrowPair(&sWork->scrollArrowsTemplate, &sWork->scrollOffset);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+        UpdatePaletteFade();
+        break;
+    default:
+        if (UpdatePaletteFade())
+            return 0;
+        sWork->state = 0;
+        return 1;
+    }
+
+    ++sWork->state;
+    return 0;
+}
+
+s32 FadeOutFromWonderNews(bool32 flag)
+{
+    if (sWork == NULL)
+        return -1;
+    switch (sWork->state)
+    {
+    case 0:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        break;
+    case 1:
+        if (UpdatePaletteFade())
+            return 0;
+        ChangeBgY(2, 0, 0);
+        SetGpuReg(REG_OFFSET_WIN0H, 0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0);
+        SetGpuReg(REG_OFFSET_WININ, 0);
+        SetGpuReg(REG_OFFSET_WINOUT, 0);
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        break;
+    case 2:
+        FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20);
+        FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20);
+        FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 24);
+        FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 24);
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(1);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(3);
+        break;
+    case 3:
+        HideBg(1);
+        HideBg(2);
+        RemoveWindow(sWork->windowIds[1]);
+        RemoveWindow(sWork->windowIds[0]);
+        break;
+    case 4:
+        ChangeBgY(2, 0, 0);
+        ChangeBgY(3, 0, 0);
+        if (sWork->menuIndicatorsId != 0xFF)
+        {
+            RemoveScrollIndicatorArrowPair(sWork->menuIndicatorsId);
+            sWork->menuIndicatorsId = 0xFF;
+        }
+        break;
+    case 5:
+        PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag);
+        break;
+    case 6:
+        MG_DrawCheckerboardPattern();
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(3);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+        break;
+    default:
+        if (UpdatePaletteFade())
+            return 0;
+        sWork->state = 0;
+        return 1;
+    }
+    ++sWork->state;
+    return 0;
+}
+
+void MENews_RemoveScrollIndicatorArrowPair(void)
+{
+    if (!sWork->verticalScrollDisabled && sWork->menuIndicatorsId != 0xFF)
+    {
+        RemoveScrollIndicatorArrowPair(sWork->menuIndicatorsId);
+        sWork->menuIndicatorsId = 0xFF;
+        sWork->verticalScrollDisabled = TRUE;
+    }
+}
+
+
+void MENews_AddScrollIndicatorArrowPair(void)
+{
+    if (sWork->verticalScrollDisabled)
+    {
+        sWork->menuIndicatorsId = AddScrollIndicatorArrowPair(&sWork->scrollArrowsTemplate, &sWork->scrollOffset);
+        sWork->verticalScrollDisabled = FALSE;
+    }
+}
+
+u32 MENews_GetInput(u16 input)
+{
+    if (sWork->unk_01C2_0)
+    {
+        sub_8146B58();
+        return 0xFF;
+    }
+    switch (input)
+    {
+    case A_BUTTON:
+        return 0;
+    case B_BUTTON:
+        return 1;
+    case DPAD_UP:
+        if (sWork->scrollOffset == 0)
+            return 0xFF;
+        if (sWork->verticalScrollDisabled)
+            return 0xFF;
+        sWork->scrollDirection = FALSE;
+        break;
+    case DPAD_DOWN:
+        if (sWork->scrollOffset == sWork->numMails)
+            return 0xFF;
+        if (sWork->verticalScrollDisabled)
+            return 0xFF;
+        sWork->scrollDirection = TRUE;
+        break;
+    default:
+        return 0xFF;
+    }
+    sWork->unk_01C2_0 = TRUE;
+    sWork->unk_01C2_1 = 2;
+    sWork->unk_01C3_1 = 0;
+    if (sWork->scrollDirection == FALSE)
+        return 2;
+    else
+        return 3;
+}
+
+static void sub_8146980(void)
+{
+    u8 i = 0;
+    memcpy(sWork->title, sWork->wonderNews.unk_04, 40);
+    sWork->title[40] = EOS;
+    for (; i < 10; ++i)
+    {
+        memcpy(sWork->messages[i], sWork->wonderNews.unk_2C[i], 40);
+        sWork->messages[i][40] = EOS;
+        if (i > 7 && sWork->messages[i][0] != EOS)
+            ++sWork->numMails;
+    }
+    sWork->scrollArrowsTemplate = sScrollArrowsTemplate;
+    sWork->scrollArrowsTemplate.fullyDownThreshold = sWork->numMails;
+}
+
+static void sub_8146A30(void)
+{
+    u8 i = 0;
+    s32 x;
+    PutWindowTilemap(sWork->windowIds[0]);
+    PutWindowTilemap(sWork->windowIds[1]);
+    FillWindowPixelBuffer(sWork->windowIds[0], 0);
+    FillWindowPixelBuffer(sWork->windowIds[1], 0);
+    x = (0xe0 - GetStringWidth(3, sWork->title, GetFontAttribute(3, 2))) / 2;
+    if (x < 0)
+        x = 0;
+    AddTextPrinterParameterized3(sWork->windowIds[0], 3, x, 6, sTextPals[sWork->bgSpec->textPal1], 0, sWork->title);
+    for (; i < 10; ++i)
+    {
+        AddTextPrinterParameterized3(sWork->windowIds[1], 3, 0, 16 * i + 2, sTextPals[sWork->bgSpec->textPal2], 0, sWork->messages[i]);
+    }
+    CopyWindowToVram(sWork->windowIds[0], 3);
+    CopyWindowToVram(sWork->windowIds[1], 3);
+}
+
+static void sub_8146B58(void)
+{
+    u16 r4 = sWork->unk_01C2_1;
+    r4 <<= 8;
+    if (sWork->scrollDirection)
+    {
+        ChangeBgY(2, r4, 1);
+        ChangeBgY(3, r4, 1);
+    }
+    else
+    {
+        ChangeBgY(2, r4, 2);
+        ChangeBgY(3, r4, 2);
+    }
+    sWork->unk_01C3_1 += sWork->unk_01C2_1;
+    if (sWork->unk_01C3_1 > 15)
+    {
+        if (sWork->scrollDirection)
+            ++sWork->scrollOffset;
+        else
+            --sWork->scrollOffset;
+        sWork->unk_01C2_0 = FALSE;
+        sWork->unk_01C3_1 = 0;
+    }
+}
diff --git a/src/unk_815F138.c b/src/minigame_countdown.c
index 8aa776bc9..5911676bb 100644
--- a/src/unk_815F138.c
+++ b/src/minigame_countdown.c
@@ -5,72 +5,83 @@
 #include "trig.h"
 #include "constants/songs.h"
 
-void sub_815F1AC(u8 taskId);
-bool32 sub_815F2AC(u8 spriteId);
-void sub_815F3E0(u8 spriteId1, u8 spriteId2, u8 spriteId3);
-bool32 sub_815F444(u8 spriteId);
-void sub_815F470(struct Sprite * sprite);
-void sub_815F564(u16 tilesTag, u16 palTag);
-u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority);
-void sub_815F610(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p);
+static void Task_MinigameCountdown(u8 taskId);
+static bool32 RunMinigameCountdownDigitsAnim(u8 spriteId);
+static void StartStartGraphic(u8 spriteId1, u8 spriteId2, u8 spriteId3);
+static bool32 IsStartGraphicAnimRunning(u8 spriteId);
+static void SpriteCB_Start(struct Sprite * sprite);
+static void Load321StartGfx(u16 tilesTag, u16 palTag);
+static u8 CreateNumberSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority);
+static void CreateStartSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p);
 
-void sub_815F138(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority)
+#define tState       data[0]
+#define tTilesTag    data[2]
+#define tPalTag      data[3]
+#define tX           data[4]
+#define tY           data[5]
+#define tSubpriority data[6]
+#define tSpriteId1   data[7]
+#define tSpriteId2   data[8]
+#define tSpriteId3   data[9]
+
+void StartMinigameCountdown(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority)
 {
-    u8 taskId = CreateTask(sub_815F1AC, 80);
-    gTasks[taskId].data[2] = tilesTag;
-    gTasks[taskId].data[3] = palTag;
-    gTasks[taskId].data[4] = x;
-    gTasks[taskId].data[5] = y;
-    gTasks[taskId].data[6] = subpriority;
+    u8 taskId = CreateTask(Task_MinigameCountdown, 80);
+    gTasks[taskId].tTilesTag = tilesTag;
+    gTasks[taskId].tPalTag = palTag;
+    gTasks[taskId].tX = x;
+    gTasks[taskId].tY = y;
+    gTasks[taskId].tSubpriority = subpriority;
 }
 
-bool8 sub_815F198(void)
+bool32 IsMinigameCountdownRunning(void)
 {
-    return FuncIsActiveTask(sub_815F1AC);
+    return FuncIsActiveTask(Task_MinigameCountdown);
 }
 
-void sub_815F1AC(u8 taskId)
+static void Task_MinigameCountdown(u8 taskId)
 {
     s16 * data = gTasks[taskId].data;
 
-    switch (data[0])
+    switch (tState)
     {
     case 0:
-        sub_815F564(data[2], data[3]);
-        data[7] = sub_815F5BC(data[2], data[3], data[4], data[5], data[6]);
-        sub_815F610(data[2], data[3], data[4], data[5], data[6], &data[8], &data[9]);
-        data[0]++;
+        Load321StartGfx(tTilesTag, tPalTag);
+        tSpriteId1 = CreateNumberSprite(tTilesTag, tPalTag, tX, tY, tSubpriority);
+        CreateStartSprite(tTilesTag, tPalTag, tX, tY, tSubpriority, &tSpriteId2, &tSpriteId3);
+        tState++;
         break;
     case 1:
-        if (!sub_815F2AC(data[7]))
+        if (!RunMinigameCountdownDigitsAnim(tSpriteId1))
         {
-            sub_815F3E0(data[7], data[8], data[9]);
-            FreeSpriteOamMatrix(&gSprites[data[7]]);
-            DestroySprite(&gSprites[data[7]]);
-            data[0]++;
+            StartStartGraphic(tSpriteId1, tSpriteId2, tSpriteId3);
+            FreeSpriteOamMatrix(&gSprites[tSpriteId1]);
+            DestroySprite(&gSprites[tSpriteId1]);
+            tState++;
         }
         break;
     case 2:
-        if (!sub_815F444(data[8]))
+        if (!IsStartGraphicAnimRunning(tSpriteId2))
         {
-            DestroySprite(&gSprites[data[8]]);
-            DestroySprite(&gSprites[data[9]]);
-            FreeSpriteTilesByTag(data[2]);
-            FreeSpritePaletteByTag(data[3]);
+            DestroySprite(&gSprites[tSpriteId2]);
+            DestroySprite(&gSprites[tSpriteId3]);
+            FreeSpriteTilesByTag(tTilesTag);
+            FreeSpritePaletteByTag(tPalTag);
             DestroyTask(taskId);
         }
         break;
     }
 }
 
-bool32 sub_815F2AC(u8 spriteId)
+static bool32 RunMinigameCountdownDigitsAnim(u8 spriteId)
 {
     struct Sprite * sprite = &gSprites[spriteId];
 
     switch (sprite->data[0])
     {
     case 0:
-        sub_8007FFC(sprite, 0x800, 0x1A);
+        // some sort of affine transform; x transform disabled
+        obj_pos2_update_enable(sprite, 0x800, 0x1A);
         sprite->data[0]++;
         // fallthrough
     case 1:
@@ -134,22 +145,22 @@ bool32 sub_815F2AC(u8 spriteId)
     return TRUE;
 }
 
-void sub_815F3E0(u8 spriteId1, u8 spriteId2, u8 spriteId3)
+static void StartStartGraphic(u8 spriteId1, u8 spriteId2, u8 spriteId3)
 {
     gSprites[spriteId2].pos2.y = -40;
     gSprites[spriteId3].pos2.y = -40;
     gSprites[spriteId2].invisible = FALSE;
     gSprites[spriteId3].invisible = FALSE;
-    gSprites[spriteId2].callback = sub_815F470;
-    gSprites[spriteId3].callback = sub_815F470;
+    gSprites[spriteId2].callback = SpriteCB_Start;
+    gSprites[spriteId3].callback = SpriteCB_Start;
 }
 
-bool32 sub_815F444(u8 spriteId)
+static bool32 IsStartGraphicAnimRunning(u8 spriteId)
 {
-    return gSprites[spriteId].callback == sub_815F470;
+    return gSprites[spriteId].callback == SpriteCB_Start;
 }
 
-void sub_815F470(struct Sprite * sprite)
+static void SpriteCB_Start(struct Sprite * sprite)
 {
     s16 * data = sprite->data;
     s32 y;
@@ -200,103 +211,103 @@ void sub_815F470(struct Sprite * sprite)
     }
 }
 
-const u16 gUnknown_847A328[] = INCBIN_U16("data/graphics/unk_847a348.gbapal");
-const u16 gUnknown_847A348[] = INCBIN_U16("data/graphics/unk_847a348.4bpp.lz");
+static const u16 sSpritePal_321Start[] = INCBIN_U16("data/graphics/unk_847a348.gbapal");
+static const u16 sSpriteSheet_321Start[] = INCBIN_U16("data/graphics/unk_847a348.4bpp.lz");
 
-void sub_815F564(u16 tilesTag, u16 palTag)
+static void Load321StartGfx(u16 tilesTag, u16 palTag)
 {
-    struct CompressedSpriteSheet spriteSheet = {(const void *)gUnknown_847A348, 0xE00};
-    struct SpritePalette spritePalette = {gUnknown_847A328};
+    struct CompressedSpriteSheet spriteSheet = {(const void *)sSpriteSheet_321Start, 0xE00};
+    struct SpritePalette spritePalette = {sSpritePal_321Start};
     spriteSheet.tag = tilesTag;
     spritePalette.tag = palTag;
     LoadCompressedSpriteSheet(&spriteSheet);
     LoadSpritePalette(&spritePalette);
 }
 
-const struct OamData gOamData_847A7AC = {
+static const struct OamData sOamData_Numbers = {
     .affineMode = ST_OAM_AFFINE_DOUBLE,
-    .shape = ST_OAM_SQUARE,
-    .size = 2
+    .shape = SPRITE_SHAPE(32x32),
+    .size = SPRITE_SIZE(32x32)
 };
 
-const struct OamData gOamData_847A7B4 = {
+static const struct OamData sOamData_Start = {
     .affineMode = ST_OAM_AFFINE_OFF,
-    .shape = ST_OAM_H_RECTANGLE,
-    .size = 3
+    .shape = SPRITE_SHAPE(64x32),
+    .size = SPRITE_SIZE(64x32)
 };
 
-const union AnimCmd gUnknown_847A7BC[] = {
+static const union AnimCmd sAnim_Numbers_Three[] = {
     ANIMCMD_FRAME( 0, 1),
 	ANIMCMD_END
 };
 
-const union AnimCmd gUnknown_847A7C4[] = {
+static const union AnimCmd sAnim_Numbers_Two[] = {
     ANIMCMD_FRAME(16, 1),
 	ANIMCMD_END
 };
 
-const union AnimCmd gUnknown_847A7CC[] = {
+static const union AnimCmd sAnim_Numbers_One[] = {
     ANIMCMD_FRAME(32, 1),
 	ANIMCMD_END
 };
 
-const union AnimCmd *const gUnknown_847A7D4[] = {
-    gUnknown_847A7BC,
-    gUnknown_847A7C4,
-    gUnknown_847A7CC
+static const union AnimCmd *const sAnimTable_Numbers[] = {
+    sAnim_Numbers_Three,
+    sAnim_Numbers_Two,
+    sAnim_Numbers_One
 };
 
-const union AnimCmd gUnknown_847A7E0[] = {
+static const union AnimCmd sAnim_StartLeft[] = {
     ANIMCMD_FRAME(48, 1),
     ANIMCMD_END
 };
 
-const union AnimCmd gUnknown_847A7E8[] = {
+static const union AnimCmd sAnim_StartRight[] = {
     ANIMCMD_FRAME(80, 1),
     ANIMCMD_END
 };
 
-const union AnimCmd *const gUnknown_847A7F0[] = {
-    gUnknown_847A7E0,
-    gUnknown_847A7E8
+static const union AnimCmd *const sAnimTable_Start[] = {
+    sAnim_StartLeft,
+    sAnim_StartRight
 };
 
-const union AffineAnimCmd gUnknown_847A7F8[] = {
+static const union AffineAnimCmd sAffineAnim_Numbers_0[] = {
     AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
 	AFFINEANIMCMD_END
 };
 
-const union AffineAnimCmd gUnknown_847A808[] = {
+static const union AffineAnimCmd sAffineAnim_Numbers_1[] = {
     AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
 	AFFINEANIMCMD_FRAME( 0x10, -0x10, 0, 8),
 	AFFINEANIMCMD_END
 };
 
-const union AffineAnimCmd gUnknown_847A820[] = {
+static const union AffineAnimCmd sAffineAnim_Numbers_2[] = {
     AFFINEANIMCMD_FRAME(-0x12,  0x12, 0, 8),
 	AFFINEANIMCMD_END
 };
 
-const union AffineAnimCmd gUnknown_847A830[] = {
+static const union AffineAnimCmd sAffineAnim_Numbers_3[] = {
     AFFINEANIMCMD_FRAME(  0x6,  -0x6, 0, 8),
 	AFFINEANIMCMD_FRAME( -0x4,   0x4, 0, 8),
 	AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
 	AFFINEANIMCMD_END
 };
 
-const union AffineAnimCmd *const gUnknown_847A850[] = {
-    gUnknown_847A7F8,
-    gUnknown_847A808,
-    gUnknown_847A820,
-    gUnknown_847A830
+static const union AffineAnimCmd *const sAffineAnimTable_Numbers[] = {
+    sAffineAnim_Numbers_0,
+    sAffineAnim_Numbers_1,
+    sAffineAnim_Numbers_2,
+    sAffineAnim_Numbers_3
 };
 
-u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority)
+static u8 CreateNumberSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority)
 {
     struct SpriteTemplate spriteTemplate = {
-        .oam = &gOamData_847A7AC,
-        .anims = gUnknown_847A7D4,
-        .affineAnims = gUnknown_847A850,
+        .oam = &sOamData_Numbers,
+        .anims = sAnimTable_Numbers,
+        .affineAnims = sAffineAnimTable_Numbers,
         .callback = SpriteCallbackDummy
     };
     spriteTemplate.tileTag = tilesTag;
@@ -304,11 +315,11 @@ u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority)
     return CreateSprite(&spriteTemplate, x, y, subpriority);
 }
 
-void sub_815F610(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p)
+static void CreateStartSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p)
 {
     struct SpriteTemplate spriteTemplate = {
-        .oam = &gOamData_847A7B4,
-        .anims = gUnknown_847A7F0,
+        .oam = &sOamData_Start,
+        .anims = sAnimTable_Start,
         .affineAnims = gDummySpriteAffineAnimTable,
         .callback = SpriteCallbackDummy
     };
diff --git a/src/mystery_event_script.c b/src/mystery_event_script.c
index 7b25cc5ff..5a105bae9 100644
--- a/src/mystery_event_script.c
+++ b/src/mystery_event_script.c
@@ -3,7 +3,6 @@
 #include "battle_tower.h"
 #include "easy_chat.h"
 #include "event_data.h"
-#include "mail.h"
 #include "mail_data.h"
 #include "mystery_event_script.h"
 #include "pokedex.h"
diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c
index 8384d211d..cdfd62624 100644
--- a/src/mystery_gift_menu.c
+++ b/src/mystery_gift_menu.c
@@ -25,6 +25,7 @@
 #include "help_system.h"
 #include "strings.h"
 #include "constants/songs.h"
+#include "constants/union_room.h"
 
 EWRAM_DATA u8 sDownArrowCounterAndYCoordIdx[8] = {};
 EWRAM_DATA bool8 gGiftIsFromEReader = FALSE;
@@ -1237,21 +1238,21 @@ void task00_mystery_gift(u8 taskId)
         case 0:
             if (data->source == 1)
             {
-                MEvent_CreateTask_CardOrNewsWithFriend(0x15);
+                MEvent_CreateTask_CardOrNewsWithFriend(ACTIVITY_WCARD2);
             }
             else if (data->source == 0)
             {
-                MEvent_CreateTask_CardOrNewsOverWireless(0x15);
+                MEvent_CreateTask_CardOrNewsOverWireless(ACTIVITY_WCARD2);
             }
             break;
         case 1:
             if (data->source == 1)
             {
-                MEvent_CreateTask_CardOrNewsWithFriend(0x16);
+                MEvent_CreateTask_CardOrNewsWithFriend(ACTIVITY_WNEWS2);
             }
             else if (data->source == 0)
             {
-                MEvent_CreateTask_CardOrNewsOverWireless(0x16);
+                MEvent_CreateTask_CardOrNewsOverWireless(ACTIVITY_WNEWS2);
             }
             break;
         }
@@ -1278,7 +1279,7 @@ void task00_mystery_gift(u8 taskId)
         switch (mevent_client_do_exec(&data->curPromptWindowId))
         {
         case 6: // done
-            task_add_05_task_del_08FA224_when_no_RfuFunc();
+            Rfu_BeginBuildAndSendCommand5F();
             data->prevPromptWindowId = data->curPromptWindowId;
             data->state = 13;
             break;
@@ -1595,10 +1596,10 @@ void task00_mystery_gift(u8 taskId)
             switch (data->IsCardOrNews)
             {
             case 0:
-                MEvent_CreateTask_Leader(21);
+                MEvent_CreateTask_Leader(ACTIVITY_WCARD2);
                 break;
             case 1:
-                MEvent_CreateTask_Leader(22);
+                MEvent_CreateTask_Leader(ACTIVITY_WNEWS2);
                 break;
             }
             data->source = 1;
@@ -1644,7 +1645,7 @@ void task00_mystery_gift(u8 taskId)
         }
         break;
     case 33:
-        task_add_05_task_del_08FA224_when_no_RfuFunc();
+        Rfu_BeginBuildAndSendCommand5F();
         StringCopy(gStringVar1, gLinkPlayers[1].name);
         data->state = 34;
         break;
diff --git a/src/naming_screen.c b/src/naming_screen.c
new file mode 100644
index 000000000..364fc3fe6
--- /dev/null
+++ b/src/naming_screen.c
@@ -0,0 +1,2401 @@
+#include "global.h"
+#include "gflib.h"
+#include "data.h"
+#include "keyboard_text.h"
+#include "event_data.h"
+#include "event_object_movement.h"
+#include "event_scripts.h"
+#include "field_effect.h"
+#include "field_player_avatar.h"
+#include "field_specials.h"
+#include "graphics.h"
+#include "help_system.h"
+#include "menu.h"
+#include "overworld.h"
+#include "naming_screen.h"
+#include "new_menu_helpers.h"
+#include "pokemon_icon.h"
+#include "pokemon_storage_system.h"
+#include "strings.h"
+#include "task.h"
+#include "text_window.h"
+#include "trig.h"
+#include "constants/help_system.h"
+#include "constants/flags.h"
+#include "constants/songs.h"
+#include "constants/event_objects.h"
+
+#define subsprite_table(ptr) {.subsprites = ptr, .subspriteCount = (sizeof ptr) / (sizeof(struct Subsprite))}
+
+#define KBEVENT_NONE 0
+#define KBEVENT_PRESSED_A 5
+#define KBEVENT_PRESSED_B 6
+#define KBEVENT_PRESSED_SELECT 8
+#define KBEVENT_PRESSED_START 9
+
+#define KBROW_COUNT 4
+
+enum
+{
+    KBPAGE_LETTERS_LOWER,
+    KBPAGE_LETTERS_UPPER,
+    KBPAGE_SYMBOLS,
+    KBPAGE_COUNT,
+};
+
+enum
+{
+    MAIN_STATE_BEGIN_FADE_IN,
+    MAIN_STATE_WAIT_FADE_IN,
+    MAIN_STATE_HANDLE_INPUT,
+    MAIN_STATE_MOVE_TO_OK_BUTTON,
+    MAIN_STATE_START_PAGE_SWAP,
+    MAIN_STATE_WAIT_PAGE_SWAP,
+    MAIN_STATE_6,
+    MAIN_STATE_UPDATE_SENT_TO_PC_MESSAGE,
+    MAIN_STATE_BEGIN_FADE_OUT,
+    MAIN_STATE_WAIT_FADE_OUT_AND_EXIT,
+};
+
+enum
+{
+    INPUT_STATE_DISABLED,
+    INPUT_STATE_ENABLED,
+};
+
+enum
+{
+    KEY_ROLE_CHAR,
+    KEY_ROLE_PAGE,
+    KEY_ROLE_BACKSPACE,
+    KEY_ROLE_OK,
+};
+
+struct NamingScreenTemplate
+{
+    u8 copyExistingString;
+    u8 maxChars;
+    u8 iconFunction;
+    u8 addGenderIcon;
+    u8 initialPage;
+    const u8 *title;
+};
+
+struct NamingScreenData
+{
+    /*0x0*/    u8 tilemapBuffer1[0x800];
+    /*0x800*/  u8 tilemapBuffer2[0x800];
+    /*0x800*/  u8 tilemapBuffer3[0x800];
+    /*0x1800*/ u8 textBuffer[0x10];
+    /*0x1810*/ u8 tileBuffer[0x600];
+    /*0x1E10*/ u8 state;
+    /*0x1E11*/ u8 windows[5];
+    /*0x1E16*/ u16 inputCharBaseXPos;
+    /*0x1E18*/ u16 bg1vOffset;
+    /*0x1E1A*/ u16 bg2vOffset;
+    /*0x1E1C*/ u16 bg1Priority;
+    /*0x1E1E*/ u16 bg2Priority;
+    /*0x1E20*/ u8 bgToReveal;
+    /*0x1E21*/ u8 bgToHide;
+    /*0x1E22*/ u8 currentPage;
+    /*0x1E23*/ u8 cursorSpriteId;
+    /*0x1E24*/ u8 selectBtnFrameSpriteId;
+    /*0x1E25*/ u8 keyRepeatStartDelayCopy;
+    /*0x1E28*/ const struct NamingScreenTemplate *template;
+    /*0x1E2C*/ u8 templateNum;
+    /*0x1E30*/ u8 *destBuffer;
+    /*0x1E34*/ u16 monSpecies;
+    /*0x1E36*/ u16 monGender;
+    /*0x1E38*/ u32 monPersonality;
+    /*0x1E3C*/ MainCallback returnCallback;
+};
+
+static EWRAM_DATA struct NamingScreenData * sNamingScreenData = NULL;
+
+static void CB2_NamingScreen(void);
+static void NamingScreen_Init(void);
+static void NamingScreen_InitBGs(void);
+static void sub_809DD60(void);
+static void sub_809DD88(u8 taskId);
+static bool8 MainState_BeginFadeIn(void);
+static bool8 MainState_WaitFadeIn(void);
+static bool8 MainState_HandleInput(void);
+static bool8 MainState_MoveToOKButton(void);
+static bool8 pokemon_store(void);
+static bool8 MainState_BeginFadeInOut(void);
+static bool8 MainState_WaitFadeOutAndExit(void);
+static void pokemon_transfer_to_pc_with_message(void);
+static bool8 sub_809E1D4(void);
+static bool8 MainState_StartPageSwap(void);
+static bool8 MainState_WaitPageSwap(void);
+static void StartPageSwapAnim(void);
+static void Task_HandlePageSwapAnim(u8 taskId);
+static bool8 IsPageSwapAnimNotInProgress(void);
+static bool8 PageSwapAnimState_Init(struct Task * task);
+static bool8 PageSwapAnimState_1(struct Task * task);
+static bool8 PageSwapAnimState_2(struct Task * task);
+static bool8 PageSwapAnimState_Done(struct Task * task);
+static void sub_809E518(u8 a0, u8 a1, u8 a2);
+static void Task_809E58C(u8 taskId);
+static u16 sub_809E644(u8 tag);
+static void sub_809E6B8(u8 a0);
+static void sub_809E6E0(struct Task * task, u8 a1, u8 a2);
+static void sub_809E700(struct Sprite * sprite);
+static void sub_809E7F0(struct Sprite * sprite);
+static void sub_809E83C(struct Sprite * sprite);
+static void sub_809E898(void);
+static void CursorInit(void);
+static void SetCursorPos(s16 x, s16 y);
+static void GetCursorPos(s16 *xP, s16 *yP);
+static void MoveCursorToOKButton(void);
+static void sub_809EA0C(u8 a0);
+static void sub_809EA64(u8 a0);
+static bool8 IsCursorAnimFinished(void);
+static u8 GetCurrentPageColumnCount(void);
+static void CreatePageSwitcherSprites(void);
+static void sub_809EC20(void);
+static bool8 PageSwapSpritesCB_Init(struct Sprite * sprite);
+static bool8 PageSwapSpritesCB_Idle(struct Sprite * sprite);
+static bool8 PageSwapSpritesCB_SwapHide(struct Sprite * sprite);
+static bool8 PageSwapSpritesCB_SwapShow(struct Sprite * sprite);
+static void sub_809ED88(u8 a0, struct Sprite * spr1, struct Sprite * spr2);
+static void CreateBackOkSprites(void);
+static void CreateUnderscoreSprites(void);
+static void CreateInputTargetIcon(void);
+static void NamingScreen_NoCreateIcon(void);
+static void NamingScreen_CreatePlayerIcon(void);
+static void NamingScreen_CreatePCIcon(void);
+static void NamingScreen_CreateMonIcon(void);
+static void NamingScreen_CreateRivalIcon(void);
+static bool8 HandleKeyboardEvent(void);
+static bool8 KeyboardKeyHandler_Character(u8);
+static bool8 KeyboardKeyHandler_Page(u8);
+static bool8 KeyboardKeyHandler_Backspace(u8);
+static bool8 KeyboardKeyHandler_OK(u8);
+static bool8 TriggerKeyboardChange(void);
+static u8 GetInputEvent(void);
+static void SetInputState(u8 state);
+static void Task_HandleInput(u8 taskId);
+static void InputState_Disabled(struct Task * task);
+static void InputState_Enabled(struct Task * task);
+static void HandleDpadMovement(struct Task * task);
+static void PrintTitle(void);
+static void AddGenderIconFunc_No(void);
+static void AddGenderIconFunc_Yes(void);
+static void DeleteTextCharacter(void);
+static u8 GetTextCaretPosition(void);
+static bool8 AppendCharToBuffer_CheckBufferFull(void);
+static void AddTextCharacter(u8 character);
+static void CopyStringToDestBuffer(void);
+static void choose_name_or_words_screen_load_bg_tile_patterns(void);
+static void sub_809F8C0(void);
+static void choose_name_or_words_screen_apply_bg_pals(void);
+static void DecompressToBgTilemapBuffer(u8 bgId, const u32 * tmap);
+static void PrintBufferCharactersOnScreen(void);
+static void sub_809F9E8(u8 windowId, u8 kbPage);
+static void sub_809FA60(void);
+static void sub_809FAE4(void);
+static void sub_809FB70(void);
+static void NamingScreen_TurnOffScreen(void);
+static void NamingScreen_InitDisplayMode(void);
+static void VBlankCB_NamingScreen(void);
+static void ShowAllBgs(void);
+static bool8 IsLetter(u8 character);
+
+// Forward declarations
+
+static const struct SubspriteTable gUnknown_83E2504[];
+static const struct SubspriteTable gUnknown_83E250C[];
+static const struct SubspriteTable gUnknown_83E2524[];
+static const struct SubspriteTable gUnknown_83E252C[];
+
+static const struct SpriteTemplate gUnknown_83E2574;
+static const struct SpriteTemplate gUnknown_83E258C;
+static const struct SpriteTemplate gUnknown_83E25A4;
+static const struct SpriteTemplate gUnknown_83E25BC;
+static const struct SpriteTemplate gUnknown_83E25D4;
+static const struct SpriteTemplate gUnknown_83E25EC;
+static const struct SpriteTemplate sSpriteTemplate_InputArrow;
+static const struct SpriteTemplate sSpriteTemplate_Underscore;
+static const struct SpriteTemplate gUnknown_83E2634;
+
+static const u8 *const sNamingScreenKeyboardText[][KBROW_COUNT];
+
+static const struct SpriteSheet gUnknown_83E267C[];
+static const struct SpritePalette gUnknown_83E26E4[];
+
+static const u16 gUnknown_83E1800[] = INCBIN_U16("graphics/interface/naming_screen_83E1800.4bpp");
+static const u16 gUnknown_83E18C0[] = INCBIN_U16("graphics/interface/naming_screen_83E18C0.4bpp");
+static const u16 gUnknown_83E1980[] = INCBIN_U16("graphics/interface/naming_screen_83E1980.4bpp");
+
+static const u8 *const sTransferredToPCMessages[] = {
+    Text_MonSentToBoxInSomeonesPC,
+    Text_MonSentToBoxInBillsPC,
+    Text_MonSentToBoxSomeonesBoxFull,
+    Text_MonSentToBoxBillsBoxFull
+};
+
+static const struct BgTemplate gUnknown_83E2290[4] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0x000
+    }, {
+        .bg = 1,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0x000
+    }, {
+        .bg = 2,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 28,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0x000
+    }, {
+        .bg = 3,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x000
+    }
+};
+
+static const struct WindowTemplate gUnknown_83E22A0[6] = {
+    {
+        .bg = 1,
+        .tilemapLeft = 3,
+        .tilemapTop = 10,
+        .width = 19,
+        .height = 8,
+        .paletteNum = 10,
+        .baseBlock = 0x0030
+    }, {
+        .bg = 2,
+        .tilemapLeft = 3,
+        .tilemapTop = 10,
+        .width = 19,
+        .height = 8,
+        .paletteNum = 10,
+        .baseBlock = 0x00c8
+    }, {
+        .bg = 3,
+        .tilemapLeft = 8,
+        .tilemapTop = 6,
+        .width = 14,
+        .height = 2,
+        .paletteNum = 10,
+        .baseBlock = 0x0030
+    }, {
+        .bg = 3,
+        .tilemapLeft = 9,
+        .tilemapTop = 4,
+        .width = 16,
+        .height = 2,
+        .paletteNum = 10,
+        .baseBlock = 0x004c
+    }, {
+        .bg = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 0,
+        .width = 30,
+        .height = 2,
+        .paletteNum = 11,
+        .baseBlock = 0x006c
+    }, DUMMY_WIN_TEMPLATE
+};
+
+static const u8 gUnknown_83E22D0[][4][8] = {
+    [KBPAGE_LETTERS_LOWER] = {
+        __("abcdef ."),
+        __("ghijkl ,"),
+        __("mnopqrs"),
+        __("tuvwxyz"),
+    },
+    [KBPAGE_LETTERS_UPPER] = {
+        __("ABCDEF ."),
+        __("GHIJKL ,"),
+        __("MNOPQRS"),
+        __("TUVWXYZ"),
+    },
+    [KBPAGE_SYMBOLS] = {
+        __("01234"),
+        __("56789"),
+        __("!?♂♀/-"),
+        __("…“”‘'"),
+    }
+};
+
+static const u8 gUnknown_83E2330[] = {
+    [KBPAGE_LETTERS_LOWER] = 8, // lower
+    [KBPAGE_LETTERS_UPPER] = 8, // upper
+    [KBPAGE_SYMBOLS]       = 6
+};
+
+static const u8 gUnknown_83E2333[][8] = {
+    [KBPAGE_LETTERS_LOWER] = {
+          0,
+         12,
+         24,
+         56,
+         68,
+         80,
+         92,
+        123
+    },
+    [KBPAGE_LETTERS_UPPER] = {
+         0,
+         12,
+         24,
+         56,
+         68,
+         80,
+         92,
+        123
+    },
+    [KBPAGE_SYMBOLS] = {
+          0,
+         22,
+         44,
+         66,
+         88,
+        110
+    }
+};
+
+static const struct NamingScreenTemplate *const sNamingScreenTemplates[];
+
+void DoNamingScreen(u8 templateNum, u8 *destBuffer, u16 monSpecies, u16 monGender, u32 monPersonality, MainCallback returnCallback)
+{
+    sNamingScreenData = Alloc(sizeof(struct NamingScreenData));
+    if (!sNamingScreenData)
+    {
+        SetMainCallback2(returnCallback);
+    }
+    else
+    {
+        sNamingScreenData->templateNum = templateNum;
+        sNamingScreenData->monSpecies = monSpecies;
+        sNamingScreenData->monGender = monGender;
+        sNamingScreenData->monPersonality = monPersonality;
+        sNamingScreenData->destBuffer = destBuffer;
+        sNamingScreenData->returnCallback = returnCallback;
+
+        if (templateNum == 0)
+            StartTimer1();
+
+        SetMainCallback2(CB2_NamingScreen);
+    }
+}
+
+static void CB2_NamingScreen(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        NamingScreen_TurnOffScreen();
+        NamingScreen_Init();
+        gMain.state++;
+        break;
+    case 1:
+        NamingScreen_InitBGs();
+        gMain.state++;
+        break;
+    case 2:
+        ResetPaletteFade();
+        gMain.state++;
+        break;
+    case 3:
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        gMain.state++;
+        break;
+    case 4:
+        ResetTasks();
+        gMain.state++;
+        break;
+    case 5:
+        choose_name_or_words_screen_apply_bg_pals();
+        gMain.state++;
+        break;
+    case 6:
+        choose_name_or_words_screen_load_bg_tile_patterns();
+        gMain.state++;
+        break;
+    case 7:
+        sub_809E898();
+        UpdatePaletteFade();
+        ShowAllBgs();
+        gMain.state++;
+        break;
+    default:
+        sub_809F8C0();
+        sub_809DD60();
+        break;
+    }
+}
+
+static void NamingScreen_Init(void)
+{
+    sNamingScreenData->state = 0;
+    sNamingScreenData->bg1vOffset = 0;
+    sNamingScreenData->bg2vOffset = 0;
+    sNamingScreenData->bg1Priority = BGCNT_PRIORITY(1);
+    sNamingScreenData->bg2Priority = BGCNT_PRIORITY(2);
+    sNamingScreenData->bgToReveal = 0;
+    sNamingScreenData->bgToHide = 1;
+    sNamingScreenData->template = sNamingScreenTemplates[sNamingScreenData->templateNum];
+    sNamingScreenData->currentPage = sNamingScreenData->template->initialPage;
+    sNamingScreenData->inputCharBaseXPos = (240 - sNamingScreenData->template->maxChars * 8) / 2 + 6;
+    sNamingScreenData->keyRepeatStartDelayCopy = gKeyRepeatStartDelay;
+    memset(sNamingScreenData->textBuffer, 0xFF, sizeof(sNamingScreenData->textBuffer));
+    if (sNamingScreenData->template->copyExistingString != 0)
+        StringCopy(sNamingScreenData->textBuffer, sNamingScreenData->destBuffer);
+    gKeyRepeatStartDelay = 16;
+}
+
+static void sub_809DB70(void)
+{
+    u8 i;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        if (gSprites[i].inUse)
+            gSprites[i].invisible = FALSE;
+    }
+    sub_809EA0C(0);
+}
+
+static void NamingScreen_InitBGs(void)
+{
+    u8 i;
+
+    DmaClearLarge16(3, (void *)VRAM, VRAM_SIZE, 0x1000);
+    DmaClear32(3, (void *)OAM, OAM_SIZE);
+    DmaClear16(3, (void *)PLTT, PLTT_SIZE);
+
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0);
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, gUnknown_83E2290, NELEMS(gUnknown_83E2290));
+
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+
+    InitStandardTextBoxWindows();
+    ResetBg0();
+
+    for (i = 0; i < NELEMS(gUnknown_83E22A0) - 1; i++)
+        sNamingScreenData->windows[i] = AddWindow(&gUnknown_83E22A0[i]);
+
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
+    SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2);
+    SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0xC, 0x8));
+
+    SetBgTilemapBuffer(1, sNamingScreenData->tilemapBuffer1);
+    SetBgTilemapBuffer(2, sNamingScreenData->tilemapBuffer2);
+    SetBgTilemapBuffer(3, sNamingScreenData->tilemapBuffer3);
+
+    FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 0x20, 0x20);
+    FillBgTilemapBufferRect_Palette0(2, 0, 0, 0, 0x20, 0x20);
+    FillBgTilemapBufferRect_Palette0(3, 0, 0, 0, 0x20, 0x20);
+}
+
+static void sub_809DD60(void)
+{
+    CreateTask(sub_809DD88, 2);
+    SetMainCallback2(sub_809FB70);
+    BackupHelpContext();
+    SetHelpContext(HELPCONTEXT_NAMING_SCREEN);
+}
+
+static void sub_809DD88(u8 taskId)
+{
+    switch (sNamingScreenData->state)
+    {
+    case MAIN_STATE_BEGIN_FADE_IN:
+        MainState_BeginFadeIn();
+        sub_809DB70();
+        NamingScreen_InitDisplayMode();
+        break;
+    case MAIN_STATE_WAIT_FADE_IN:
+        MainState_WaitFadeIn();
+        break;
+    case MAIN_STATE_HANDLE_INPUT:
+        MainState_HandleInput();
+        break;
+    case MAIN_STATE_MOVE_TO_OK_BUTTON:
+        MainState_MoveToOKButton();
+        break;
+    case MAIN_STATE_START_PAGE_SWAP:
+        MainState_StartPageSwap();
+        break;
+    case MAIN_STATE_WAIT_PAGE_SWAP:
+        MainState_WaitPageSwap();
+        break;
+    case MAIN_STATE_6:
+        pokemon_store();
+        break;
+    case MAIN_STATE_UPDATE_SENT_TO_PC_MESSAGE:
+        sub_809E1D4();
+        break;
+    case MAIN_STATE_BEGIN_FADE_OUT:
+        MainState_BeginFadeInOut();
+        break;
+    case MAIN_STATE_WAIT_FADE_OUT_AND_EXIT:
+        MainState_WaitFadeOutAndExit();
+        break;
+    }
+}
+
+static const u8 sPageOrderLowerFirst[] = {
+    KBPAGE_LETTERS_LOWER,
+    KBPAGE_SYMBOLS,
+    KBPAGE_LETTERS_UPPER
+};
+
+static const u8 sPageOrderUpperFirst[] = {
+    KBPAGE_LETTERS_UPPER,
+    KBPAGE_LETTERS_LOWER,
+    KBPAGE_SYMBOLS
+};
+
+static const u8 sPageOrderSymbolsFirst[] = {
+    KBPAGE_SYMBOLS,
+    KBPAGE_LETTERS_UPPER,
+    KBPAGE_LETTERS_LOWER
+};
+
+static u8 sub_809DE20(u8 a1)
+{
+    return sPageOrderLowerFirst[a1];
+}
+
+static u8 sub_809DE30(void)
+{
+    return sPageOrderUpperFirst[sNamingScreenData->currentPage];
+}
+
+static u8 sub_809DE50(void)
+{
+    return sPageOrderSymbolsFirst[sNamingScreenData->currentPage];
+}
+
+static bool8 MainState_BeginFadeIn(void)
+{
+    DecompressToBgTilemapBuffer(3, gUnknown_8E982BC);
+    sNamingScreenData->currentPage = KBPAGE_LETTERS_UPPER;
+    DecompressToBgTilemapBuffer(2, gUnknown_8E98458);
+    DecompressToBgTilemapBuffer(1, gUnknown_8E98398);
+    sub_809F9E8(sNamingScreenData->windows[1], KBPAGE_LETTERS_LOWER);
+    sub_809F9E8(sNamingScreenData->windows[0], KBPAGE_LETTERS_UPPER);
+    PrintBufferCharactersOnScreen();
+    PrintTitle();
+    sub_809FAE4();
+    CopyBgTilemapBufferToVram(1);
+    CopyBgTilemapBufferToVram(2);
+    CopyBgTilemapBufferToVram(3);
+    BlendPalettes(-1, 16, RGB_BLACK);
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+    sNamingScreenData->state++;
+    return FALSE;
+}
+
+static bool8 MainState_WaitFadeIn(void)
+{
+    if (!gPaletteFade.active)
+    {
+        SetInputState(INPUT_STATE_ENABLED);
+        sub_809EA64(1);
+        sNamingScreenData->state++;
+    }
+    return FALSE;
+}
+
+static bool8 MainState_HandleInput(void)
+{
+    return HandleKeyboardEvent();
+}
+
+static bool8 MainState_MoveToOKButton(void)
+{
+    if (IsCursorAnimFinished())
+    {
+        SetInputState(INPUT_STATE_ENABLED);
+        MoveCursorToOKButton();
+        sNamingScreenData->state = MAIN_STATE_HANDLE_INPUT;
+    }
+    return FALSE;
+}
+
+static bool8 pokemon_store(void)
+{
+    CopyStringToDestBuffer();
+    SetInputState(INPUT_STATE_DISABLED);
+    sub_809EA64(0);
+    sub_809E518(3, 0, 1);
+    if (sNamingScreenData->templateNum == NAMING_SCREEN_CAUGHT_MON &&
+        CalculatePlayerPartyCount() >= 6)
+    {
+        pokemon_transfer_to_pc_with_message();
+        sNamingScreenData->state = MAIN_STATE_UPDATE_SENT_TO_PC_MESSAGE;
+        return FALSE;
+    }
+    else
+    {
+        sNamingScreenData->state = MAIN_STATE_BEGIN_FADE_OUT;
+        return TRUE;  //Exit the naming screen
+    }
+}
+
+static bool8 MainState_BeginFadeInOut(void)
+{
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+    sNamingScreenData->state++;
+    return FALSE;
+}
+
+static bool8 MainState_WaitFadeOutAndExit(void)
+{
+    if (!gPaletteFade.active)
+    {
+        if (sNamingScreenData->templateNum == NAMING_SCREEN_PLAYER)
+            SeedRngAndSetTrainerId();
+        SetMainCallback2(sNamingScreenData->returnCallback);
+        DestroyTask(FindTaskIdByFunc(sub_809DD88));
+        FreeAllWindowBuffers();
+        FREE_AND_SET_NULL(sNamingScreenData);
+        RestoreHelpContext();
+    }
+    return FALSE;
+}
+
+static void pokemon_transfer_to_pc_with_message(void)
+{
+    u8 stringToDisplay = 0;
+
+    if (!IsDestinationBoxFull())
+    {
+        StringCopy(gStringVar1, GetBoxNamePtr(VarGet(VAR_PC_BOX_TO_SEND_MON)));
+        StringCopy(gStringVar2, sNamingScreenData->destBuffer);
+    }
+    else
+    {
+        StringCopy(gStringVar1, GetBoxNamePtr(VarGet(VAR_PC_BOX_TO_SEND_MON)));
+        StringCopy(gStringVar2, sNamingScreenData->destBuffer);
+        StringCopy(gStringVar3, GetBoxNamePtr(GetPCBoxToSendMon()));
+        stringToDisplay = 2;
+    }
+
+    if (FlagGet(FLAG_SYS_NOT_SOMEONES_PC))
+        stringToDisplay++;
+
+    StringExpandPlaceholders(gStringVar4, sTransferredToPCMessages[stringToDisplay]);
+    DrawDialogueFrame(0, FALSE);
+    gTextFlags.canABSpeedUpPrint = TRUE;
+    AddTextPrinterParameterized2(0, 2, gStringVar4, GetTextSpeedSetting(), NULL, TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY);
+    CopyWindowToVram(0, 3);
+}
+
+static bool8 sub_809E1D4(void)
+{
+    RunTextPrinters();
+
+    if (!IsTextPrinterActive(0) && (JOY_NEW(A_BUTTON)))
+        sNamingScreenData->state = MAIN_STATE_BEGIN_FADE_OUT;
+
+    return FALSE;
+}
+
+static bool8 MainState_StartPageSwap(void)
+{
+    SetInputState(INPUT_STATE_DISABLED);
+    sub_809EC20();
+    StartPageSwapAnim();
+    sub_809EA0C(1);
+    sub_809E518(0, 0, 1);
+    PlaySE(SE_WIN_OPEN);
+    sNamingScreenData->state = MAIN_STATE_WAIT_PAGE_SWAP;
+    return FALSE;
+}
+
+static bool8 MainState_WaitPageSwap(void)
+{
+    s16 cursorX;
+    s16 cursorY;
+    bool32 var3;
+
+    if (IsPageSwapAnimNotInProgress())
+    {
+
+        GetCursorPos(&cursorX, &cursorY);
+        var3 = (cursorX == GetCurrentPageColumnCount());
+
+        sNamingScreenData->state = MAIN_STATE_HANDLE_INPUT;
+        sNamingScreenData->currentPage++;
+        sNamingScreenData->currentPage %= 3;
+
+        if (var3)
+        {
+            cursorX = GetCurrentPageColumnCount();
+        }
+        else
+        {
+            if (cursorX >= GetCurrentPageColumnCount())
+                cursorX = GetCurrentPageColumnCount() - 1;
+        }
+
+        SetCursorPos(cursorX, cursorY);
+        sub_809FA60();
+        SetInputState(INPUT_STATE_ENABLED);
+        sub_809EA0C(0);
+    }
+    return FALSE;
+}
+
+//--------------------------------------------------
+// Page Swap
+//--------------------------------------------------
+
+#define tState data[0]
+#define tFrameCount data[1]
+
+static bool8 (*const sPageSwapAnimStateFuncs[])(struct Task * task) = {
+    PageSwapAnimState_Init,
+    PageSwapAnimState_1,
+    PageSwapAnimState_2,
+    PageSwapAnimState_Done
+};
+
+static void StartPageSwapAnim(void)
+{
+    u8 taskId;
+
+    taskId = CreateTask(Task_HandlePageSwapAnim, 0);
+    Task_HandlePageSwapAnim(taskId);
+}
+
+static void Task_HandlePageSwapAnim(u8 taskId)
+{
+    while (sPageSwapAnimStateFuncs[gTasks[taskId].tState](&gTasks[taskId]))
+        ;
+}
+
+static bool8 IsPageSwapAnimNotInProgress(void)
+{
+    if (FindTaskIdByFunc(Task_HandlePageSwapAnim) == 0xFF)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static bool8 PageSwapAnimState_Init(struct Task *task)
+{
+    sNamingScreenData->bg1vOffset = 0;
+    sNamingScreenData->bg2vOffset = 0;
+    task->tState++;
+    return 0;
+}
+
+static bool8 PageSwapAnimState_1(struct Task *task)
+{
+    u16 *const arr[] =
+        {
+            &sNamingScreenData->bg2vOffset,
+            &sNamingScreenData->bg1vOffset
+        };
+
+    task->tFrameCount += 4;
+    *arr[sNamingScreenData->bgToReveal] = Sin(task->tFrameCount, 40);
+    *arr[sNamingScreenData->bgToHide] = Sin((task->tFrameCount + 128) & 0xFF, 40);
+    if (task->tFrameCount >= 64)
+    {
+        u8 temp = sNamingScreenData->bg1Priority;  //Why u8 and not u16?
+
+        sNamingScreenData->bg1Priority = sNamingScreenData->bg2Priority;
+        sNamingScreenData->bg2Priority = temp;
+        task->tState++;
+    }
+    return 0;
+}
+
+static bool8 PageSwapAnimState_2(struct Task *task)
+{
+    u16 *const arr[] =
+        {
+            &sNamingScreenData->bg2vOffset,
+            &sNamingScreenData->bg1vOffset
+        };
+
+    task->tFrameCount += 4;
+    *arr[sNamingScreenData->bgToReveal] = Sin(task->tFrameCount, 40);
+    *arr[sNamingScreenData->bgToHide] = Sin((task->tFrameCount + 128) & 0xFF, 40);
+    if (task->tFrameCount >= 128)
+    {
+        u8 temp = sNamingScreenData->bgToReveal;
+
+        sNamingScreenData->bgToReveal = sNamingScreenData->bgToHide;
+        sNamingScreenData->bgToHide = temp;
+        task->tState++;
+    }
+    return 0;
+}
+
+static bool8 PageSwapAnimState_Done(struct Task *task)
+{
+    DestroyTask(FindTaskIdByFunc(Task_HandlePageSwapAnim));
+    return 0;
+}
+
+#undef tState
+#undef tFrameCount
+
+//--------------------------------------------------
+// Cursor blink
+//--------------------------------------------------
+
+#define tIdent data[0]
+
+static void sub_809E4F0(void)
+{
+    u8 taskId;
+
+    taskId = CreateTask(Task_809E58C, 3);
+    gTasks[taskId].data[0] = 3;
+}
+
+static void sub_809E518(u8 a, u8 b, u8 c)
+{
+    struct Task *task = &gTasks[FindTaskIdByFunc(Task_809E58C)];
+
+    if (a == task->data[0] && c == 0)
+    {
+        task->data[1] = b;
+        task->data[2] = 1;
+        return;
+    }
+    if (a == 3 && task->data[1] == 0 && c == 0)
+        return;
+    if (task->data[0] != 3)
+        sub_809E6B8(task->data[0]);
+    sub_809E6E0(task, a, b);
+}
+
+static void Task_809E58C(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+
+    if (task->data[0] == 3 || task->data[2] == 0)
+        return;
+    MultiplyInvertedPaletteRGBComponents(sub_809E644(task->data[0]), task->data[3], task->data[3], task->data[3]);
+    if (task->data[5] != 0)
+    {
+        task->data[5]--;
+        if (task->data[5] != 0)
+            return;
+    }
+    task->data[5] = 2;
+    if (task->data[4] >= 0)
+    {
+        if (task->data[3] < 14)
+        {
+            task->data[3] += task->data[4];
+            task->data[6] += task->data[4];
+        }
+        else
+        {
+            task->data[3] = 16;
+            task->data[6]++;
+        }
+    }
+    else
+    {
+        task->data[3] += task->data[4];
+        task->data[6] += task->data[4];
+    }
+
+    if (task->data[3] == 16 && task->data[6] == 22)
+    {
+        task->data[4] = -4;
+    }
+    else if (task->data[3] == 0)
+    {
+        task->data[2] = task->data[1];
+        task->data[4] = 2;
+        task->data[6] = 0;
+    }
+}
+
+static u16 sub_809E644(u8 a)
+{
+    const u16 arr[] =
+    {
+        IndexOfSpritePaletteTag(4) * 16 + 0x10E, // Swap
+        IndexOfSpritePaletteTag(6) * 16 + 0x10E, // BACK
+        IndexOfSpritePaletteTag(7) * 16 + 0x10E, // OK
+        IndexOfSpritePaletteTag(7) * 16 + 0x101, // kbd
+    };
+
+    return arr[a];
+}
+
+static void sub_809E6B8(u8 a)
+{
+    u16 index = sub_809E644(a);
+
+    gPlttBufferFaded[index] = gPlttBufferUnfaded[index];
+}
+
+static void sub_809E6E0(struct Task *task, u8 b, u8 c)
+{
+    task->data[0] = b;
+    task->data[1] = c;
+    task->data[2] = 1;
+    task->data[3] = 4;
+    task->data[4] = 2;
+    task->data[5] = 0;
+    task->data[6] = 4;
+}
+
+//--------------------------------------------------
+// Cursor
+//--------------------------------------------------
+
+static void sub_809E700(struct Sprite *sprite)
+{
+    if (sprite->animEnded)
+        StartSpriteAnim(sprite, 0);
+    sprite->invisible = (sprite->data[4] & 0xFF);
+    if (sprite->data[0] == GetCurrentPageColumnCount())
+        sprite->invisible = TRUE;
+    if (sprite->invisible || (sprite->data[4] & 0xFF00) == 0
+        || sprite->data[0] != sprite->data[2] || sprite->data[1] != sprite->data[3])
+    {
+        sprite->data[5] = 0;
+        sprite->data[6] = 2;
+        sprite->data[7] = 2;
+    }
+    sprite->data[7]--;
+    if (sprite->data[7] == 0)
+    {
+        sprite->data[5] += sprite->data[6];
+        if (sprite->data[5] == 16 || sprite->data[5] == 0)
+            sprite->data[6] = -sprite->data[6];
+        sprite->data[7] = 2;
+    }
+    if ((sprite->data[4] & 0xFF00) != 0)
+    {
+        s8 gb = sprite->data[5];
+        s8 r = sprite->data[5] >> 1;
+        u16 index = IndexOfSpritePaletteTag(5) * 16 + 0x0101;
+
+        MultiplyInvertedPaletteRGBComponents(index, r, gb, gb);
+    }
+}
+
+static void sub_809E7F0(struct Sprite *sprite)
+{
+    const s16 arr[] = {0, -4, -2, -1};
+
+    if (sprite->data[0] == 0 || --sprite->data[0] == 0)
+    {
+        sprite->data[0] = 8;
+        sprite->data[1] = (sprite->data[1] + 1) & 3;
+    }
+    sprite->pos2.x = arr[sprite->data[1]];
+}
+
+static void sub_809E83C(struct Sprite *sprite)
+{
+    const s16 arr[] = {2, 3, 2, 1};
+    u8 var;
+
+    var = GetTextCaretPosition();
+    if (var != (u8)sprite->data[0])
+    {
+        sprite->pos2.y = 0;
+        sprite->data[1] = 0;
+        sprite->data[2] = 0;
+    }
+    else
+    {
+        sprite->pos2.y = arr[sprite->data[1]];
+        sprite->data[2]++;
+        if (sprite->data[2] > 8)
+        {
+            sprite->data[1] = (sprite->data[1] + 1) & 3;
+            sprite->data[2] = 0;
+        }
+    }
+}
+
+static void sub_809E898(void)
+{
+    CursorInit();
+    CreatePageSwitcherSprites();
+    CreateBackOkSprites();
+    CreateUnderscoreSprites();
+    CreateInputTargetIcon();
+}
+
+static void CursorInit(void)
+{
+    sNamingScreenData->cursorSpriteId = CreateSprite(&gUnknown_83E25EC, 38, 88, 1);
+    sub_809EA0C(1);
+    gSprites[sNamingScreenData->cursorSpriteId].oam.priority = 1;
+    gSprites[sNamingScreenData->cursorSpriteId].oam.objMode = ST_OAM_OBJ_BLEND;
+    gSprites[sNamingScreenData->cursorSpriteId].data[6] = 1;
+    gSprites[sNamingScreenData->cursorSpriteId].data[6] = 2;
+    SetCursorPos(0, 0);
+}
+
+static void SetCursorPos(s16 x, s16 y)
+{
+    struct Sprite *cursorSprite = &gSprites[sNamingScreenData->cursorSpriteId];
+
+    if (x < gUnknown_83E2330[sub_809DE50()])
+        cursorSprite->pos1.x = gUnknown_83E2333[sub_809DE50()][x] + 38;
+    else
+        cursorSprite->pos1.x = 0;
+
+    cursorSprite->pos1.y = y * 16 + 88;
+    cursorSprite->data[2] = cursorSprite->data[0];
+    cursorSprite->data[3] = cursorSprite->data[1];
+    cursorSprite->data[0] = x;
+    cursorSprite->data[1] = y;
+}
+
+static void GetCursorPos(s16 *x, s16 *y)
+{
+    struct Sprite *cursorSprite = &gSprites[sNamingScreenData->cursorSpriteId];
+
+    *x = cursorSprite->data[0];
+    *y = cursorSprite->data[1];
+}
+
+static void MoveCursorToOKButton(void)
+{
+    SetCursorPos(GetCurrentPageColumnCount(), 2);
+}
+
+static void sub_809EA0C(u8 a)
+{
+    gSprites[sNamingScreenData->cursorSpriteId].data[4] &= ~0xFF;
+    gSprites[sNamingScreenData->cursorSpriteId].data[4] |= a;
+    StartSpriteAnim(&gSprites[sNamingScreenData->cursorSpriteId], 0);
+}
+
+static void sub_809EA64(u8 a)
+{
+    gSprites[sNamingScreenData->cursorSpriteId].data[4] &= 0xFF;
+    gSprites[sNamingScreenData->cursorSpriteId].data[4] |= a << 8;
+}
+
+static void sub_809EAA8(void)
+{
+    StartSpriteAnim(&gSprites[sNamingScreenData->cursorSpriteId], 1);
+}
+
+static bool8 IsCursorAnimFinished(void)
+{
+    return gSprites[sNamingScreenData->cursorSpriteId].animEnded;
+}
+
+static const u8 sKeyRoles[] = {KEY_ROLE_PAGE, KEY_ROLE_BACKSPACE, KEY_ROLE_OK};
+
+static u8 GetKeyRoleAtCursorPos(void)
+{
+    s16 cursorX;
+    s16 cursorY;
+
+    GetCursorPos(&cursorX, &cursorY);
+    if (cursorX < GetCurrentPageColumnCount())
+        return KEY_ROLE_CHAR;
+    else
+        return sKeyRoles[cursorY];
+}
+
+static u8 GetCurrentPageColumnCount(void)
+{
+    return gUnknown_83E2330[sub_809DE50()];
+}
+
+static void CreatePageSwitcherSprites(void)
+{
+    u8 spriteId1;
+    u8 spriteId2;
+    u8 spriteId3;
+
+    spriteId1 = CreateSprite(&gUnknown_83E2574, 0xCC, 0x58, 0);
+    sNamingScreenData->selectBtnFrameSpriteId = spriteId1;
+    SetSubspriteTables(&gSprites[spriteId1], gUnknown_83E2504);
+    gSprites[spriteId1].invisible = TRUE;
+
+    spriteId2 = CreateSprite(&gUnknown_83E25A4, 0xCC, 0x54, 1);
+    gSprites[spriteId1].data[6] = spriteId2;
+    SetSubspriteTables(&gSprites[spriteId2], gUnknown_83E250C);
+    gSprites[spriteId2].invisible = TRUE;
+
+    spriteId3 = CreateSprite(&gUnknown_83E258C, 0xCC, 0x53, 2);
+    gSprites[spriteId3].oam.priority = 1;
+    gSprites[spriteId1].data[7] = spriteId3;
+    gSprites[spriteId3].invisible = TRUE;
+}
+
+static void sub_809EC20(void)
+{
+    struct Sprite *sprite = &gSprites[sNamingScreenData->selectBtnFrameSpriteId];
+
+    sprite->data[0] = 2;
+    sprite->data[1] = sNamingScreenData->currentPage;
+}
+
+static bool8 (*const sPageSwapSpritesCBs[])(struct Sprite * sprite) = {
+    PageSwapSpritesCB_Init,
+    PageSwapSpritesCB_Idle,
+    PageSwapSpritesCB_SwapHide,
+    PageSwapSpritesCB_SwapShow
+};
+
+static void SpriteCB_PageSwap(struct Sprite *sprite)
+{
+    while (sPageSwapSpritesCBs[sprite->data[0]](sprite))
+        ;
+}
+
+static bool8 PageSwapSpritesCB_Init(struct Sprite *sprite)
+{
+    struct Sprite *sprite1 = &gSprites[sprite->data[6]];
+    struct Sprite *sprite2 = &gSprites[sprite->data[7]];
+
+    sub_809ED88(sub_809DE20(sNamingScreenData->currentPage), sprite1, sprite2);
+    sprite->data[0]++;
+    return FALSE;
+}
+
+static bool8 PageSwapSpritesCB_Idle(struct Sprite *sprite)
+{
+    struct Sprite *sprite1 = &gSprites[sprite->data[6]];
+    struct Sprite *sprite2 = &gSprites[sprite->data[7]];
+
+    return FALSE;
+}
+
+static bool8 PageSwapSpritesCB_SwapHide(struct Sprite *sprite)
+{
+    struct Sprite *sprite1 = &gSprites[sprite->data[6]];
+    struct Sprite *sprite2 = &gSprites[sprite->data[7]];
+    u8 page;
+
+    sprite1->pos2.y++;
+    if (sprite1->pos2.y > 7)
+    {
+        sprite->data[0]++;
+        sprite1->pos2.y = -4;
+        sprite1->invisible = TRUE;
+        page = sprite->data[1];
+        sub_809ED88(sub_809DE20((page + 1) % 3), sprite1, sprite2);
+    }
+    return FALSE;
+}
+
+static bool8 PageSwapSpritesCB_SwapShow(struct Sprite *sprite)
+{
+    struct Sprite *sprite1 = &gSprites[sprite->data[6]];
+    struct Sprite *sprite2 = &gSprites[sprite->data[7]];
+
+    sprite1->invisible = FALSE;
+    sprite1->pos2.y++;
+    if (sprite1->pos2.y >= 0)
+    {
+        sprite1->pos2.y = 0;
+        sprite->data[0] = 1;
+    }
+    return FALSE;
+}
+
+static const u16 gUnknown_83E2388[] = {1, 3, 2};
+static const u16 gUnknown_83E238E[] = {4, 6, 5};
+
+static void sub_809ED88(u8 page, struct Sprite * sprite1, struct Sprite * sprite2)
+{
+    sprite2->oam.paletteNum = IndexOfSpritePaletteTag(gUnknown_83E2388[page]);
+    sprite1->sheetTileStart = GetSpriteTileStartByTag(gUnknown_83E238E[page]);
+    sprite1->subspriteTableNum = page;
+}
+
+//
+
+static void CreateBackOkSprites(void)
+{
+    u8 spriteId;
+
+    spriteId = CreateSprite(&gUnknown_83E25BC, 0xCC, 0x74, 0);
+    SetSubspriteTables(&gSprites[spriteId], gUnknown_83E2524);
+    gSprites[spriteId].invisible = TRUE;
+
+    spriteId = CreateSprite(&gUnknown_83E25D4, 0xCC, 0x8C, 0);
+    SetSubspriteTables(&gSprites[spriteId], gUnknown_83E2524);
+    gSprites[spriteId].invisible = TRUE;
+}
+
+static void CreateUnderscoreSprites(void)
+{
+    u8 spriteId;
+    s16 xPos;
+    u8 i;
+
+    xPos = sNamingScreenData->inputCharBaseXPos - 5;
+    spriteId = CreateSprite(&sSpriteTemplate_InputArrow, xPos, 0x38, 0);
+    gSprites[spriteId].oam.priority = 3;
+    gSprites[spriteId].invisible = TRUE;
+    xPos = sNamingScreenData->inputCharBaseXPos;
+    for (i = 0; i < sNamingScreenData->template->maxChars; i++, xPos += 8)
+    {
+        spriteId = CreateSprite(&sSpriteTemplate_Underscore, xPos + 3, 0x3C, 0);
+        gSprites[spriteId].oam.priority = 3;
+        gSprites[spriteId].data[0] = i;
+        gSprites[spriteId].invisible = TRUE;
+    }
+}
+
+//--------------------------------------------------
+// Icon creation (the thing you're naming or giving input to)
+//--------------------------------------------------
+
+static void (*const sIconFunctions[])(void) = {
+    NamingScreen_NoCreateIcon,
+    NamingScreen_CreatePlayerIcon,
+    NamingScreen_CreatePCIcon,
+    NamingScreen_CreateMonIcon,
+    NamingScreen_CreateRivalIcon
+};
+
+static void CreateInputTargetIcon(void)
+{
+    sIconFunctions[sNamingScreenData->template->iconFunction]();
+}
+
+static void NamingScreen_NoCreateIcon(void)
+{
+
+}
+
+static void NamingScreen_CreatePlayerIcon(void)
+{
+    u8 rivalGfxId;
+    u8 spriteId;
+
+    rivalGfxId = sub_805C7C8(0, sNamingScreenData->monSpecies);
+    spriteId = AddPseudoObjectEvent(rivalGfxId, SpriteCallbackDummy, 0x38, 0x25, 0);
+    gSprites[spriteId].oam.priority = 3;
+    StartSpriteAnim(&gSprites[spriteId], 4);
+}
+
+static void NamingScreen_CreatePCIcon(void)
+{
+    u8 spriteId;
+
+    spriteId = CreateSprite(&gUnknown_83E2634, 0x38, 0x29, 0);
+    SetSubspriteTables(&gSprites[spriteId], gUnknown_83E252C);
+    gSprites[spriteId].oam.priority = 3;
+}
+
+static void NamingScreen_CreateMonIcon(void)
+{
+    u8 spriteId;
+
+    LoadMonIconPalettes();
+    spriteId = CreateMonIcon(sNamingScreenData->monSpecies, SpriteCallbackDummy, 0x38, 0x28, 0, sNamingScreenData->monPersonality, 1);
+    gSprites[spriteId].oam.priority = 3;
+}
+
+static const union AnimCmd gUnknown_83E23A8[] = {
+    ANIMCMD_FRAME( 0, 10),
+    ANIMCMD_FRAME(24, 10),
+    ANIMCMD_FRAME( 0, 10),
+    ANIMCMD_FRAME(32, 10),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const gUnknown_83E23BC[] = {
+    gUnknown_83E23A8
+};
+
+static void NamingScreen_CreateRivalIcon(void)
+{
+    const struct SpriteSheet sheet = {
+        gUnknown_83E1980, 0x900, 255
+    };
+    const struct SpritePalette palette = {
+        gUnknown_8E98004, 255
+    };
+    struct SpriteTemplate template;
+    const struct SubspriteTable * tables_p;
+    u8 spriteId;
+
+    MakeObjectTemplateFromObjectEventGraphicsInfo(OBJ_EVENT_GFX_RED_NORMAL, SpriteCallbackDummy, &template, &tables_p);
+
+    template.tileTag = sheet.tag;
+    template.paletteTag = palette.tag;
+    template.anims = gUnknown_83E23BC;
+    LoadSpriteSheet(&sheet);
+    LoadSpritePalette(&palette);
+    spriteId = CreateSprite(&template, 0x38, 0x25, 0);
+    gSprites[spriteId].oam.priority = 3;
+}
+
+static bool8 (*const sKeyboardKeyHandlers[])(u8) = {
+    KeyboardKeyHandler_Character,
+    KeyboardKeyHandler_Page,
+    KeyboardKeyHandler_Backspace,
+    KeyboardKeyHandler_OK,
+};
+
+static bool8 HandleKeyboardEvent(void)
+{
+    u8 event = GetInputEvent();
+    u8 keyRole = GetKeyRoleAtCursorPos();
+
+    if (event == KBEVENT_PRESSED_SELECT)
+    {
+        return TriggerKeyboardChange();
+    }
+    else if (event == KBEVENT_PRESSED_B)
+    {
+        DeleteTextCharacter();
+        return FALSE;
+    }
+    else if (event == KBEVENT_PRESSED_START)
+    {
+        MoveCursorToOKButton();
+        return FALSE;
+    }
+    else
+    {
+        return sKeyboardKeyHandlers[keyRole](event);
+    }
+}
+
+static bool8 KeyboardKeyHandler_Character(u8 event)
+{
+    sub_809E518(3, 0, 0);
+    if (event == KBEVENT_PRESSED_A)
+    {
+        bool8 var = AppendCharToBuffer_CheckBufferFull();
+
+        sub_809EAA8();
+        if (var)
+        {
+            SetInputState(INPUT_STATE_DISABLED);
+            sNamingScreenData->state = MAIN_STATE_MOVE_TO_OK_BUTTON;
+        }
+    }
+    return FALSE;
+}
+
+static bool8 KeyboardKeyHandler_Page(u8 event)
+{
+    sub_809E518(0, 1, 0);
+    if (event == KBEVENT_PRESSED_A)
+        return TriggerKeyboardChange();
+    else
+        return FALSE;
+}
+
+static bool8 KeyboardKeyHandler_Backspace(u8 event)
+{
+    sub_809E518(1, 1, 0);
+    if (event == KBEVENT_PRESSED_A)
+        DeleteTextCharacter();
+    return FALSE;
+}
+
+static bool8 KeyboardKeyHandler_OK(u8 event)
+{
+    sub_809E518(2, 1, 0);
+    if (event == KBEVENT_PRESSED_A)
+    {
+        PlaySE(SE_SELECT);
+        sNamingScreenData->state = MAIN_STATE_6;
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+static bool8 TriggerKeyboardChange(void)
+{
+    sNamingScreenData->state = MAIN_STATE_START_PAGE_SWAP;
+    return TRUE;
+}
+
+//--------------------------------------------------
+// Input handling
+//--------------------------------------------------
+
+enum
+{
+    FNKEY_CASE,
+    FNKEY_BACK,
+    FNKEY_OK,
+};
+
+#define tState data[0]
+#define tKeyboardEvent data[1]
+#define tKbFunctionKey data[2]
+
+static void (*const sInputStateFuncs[])(struct Task *) = {
+    InputState_Disabled,
+    InputState_Enabled
+};
+
+static void InputInit(void)
+{
+    CreateTask(Task_HandleInput, 1);
+}
+
+static u8 GetInputEvent(void)
+{
+    u8 taskId = FindTaskIdByFunc(Task_HandleInput);
+
+    return gTasks[taskId].tKeyboardEvent;
+}
+
+static void SetInputState(u8 state)
+{
+    u8 taskId = FindTaskIdByFunc(Task_HandleInput);
+
+    gTasks[taskId].tState = state;
+}
+
+static void Task_HandleInput(u8 taskId)
+{
+    sInputStateFuncs[gTasks[taskId].tState](&gTasks[taskId]);
+}
+
+static void InputState_Disabled(struct Task *task)
+{
+    task->tKeyboardEvent = 0;
+}
+
+static void InputState_Enabled(struct Task *task)
+{
+    task->tKeyboardEvent = 0;
+
+    if (JOY_NEW(A_BUTTON))
+        task->tKeyboardEvent = KBEVENT_PRESSED_A;
+    else if (JOY_NEW(B_BUTTON))
+        task->tKeyboardEvent = KBEVENT_PRESSED_B;
+    else if (JOY_NEW(SELECT_BUTTON))
+        task->tKeyboardEvent = KBEVENT_PRESSED_SELECT;
+    else if (JOY_NEW(START_BUTTON))
+        task->tKeyboardEvent = KBEVENT_PRESSED_START;
+    else
+        HandleDpadMovement(task);
+}
+
+static void HandleDpadMovement(struct Task *task)
+{
+    const s16 sDpadDeltaX[] = {
+         0,   //none
+         0,   //up
+         0,   //down
+        -1,   //left
+         1    //right
+    };
+
+    const s16 sDpadDeltaY[] = {
+         0,   //none
+        -1,   //up
+         1,   //down
+         0,   //left
+         0    //right
+    };
+
+    const s16 s4RowTo3RowTableY[] = {0, 1, 1, 2};
+    const s16 s3RowTo4RowTableY[] = {0, 0, 3};
+
+    s16 cursorX;
+    s16 cursorY;
+    u16 dpadDir;
+    s16 prevCursorX;
+
+    GetCursorPos(&cursorX, &cursorY);
+    dpadDir = 0;
+    if (JOY_REPT(DPAD_UP))
+        dpadDir = 1;
+    if (JOY_REPT(DPAD_DOWN))
+        dpadDir = 2;
+    if (JOY_REPT(DPAD_LEFT))
+        dpadDir = 3;
+    if (JOY_REPT(DPAD_RIGHT))
+        dpadDir = 4;
+
+    //Get new cursor position
+    prevCursorX = cursorX;
+    cursorX += sDpadDeltaX[dpadDir];
+    cursorY += sDpadDeltaY[dpadDir];
+
+    //Wrap cursor position in the X direction
+    if (cursorX < 0)
+        cursorX = GetCurrentPageColumnCount();
+    if (cursorX > GetCurrentPageColumnCount())
+        cursorX = 0;
+
+    //Handle cursor movement in X direction
+    if (sDpadDeltaX[dpadDir] != 0)
+    {
+        if (cursorX == GetCurrentPageColumnCount())
+        {
+            //We are now on the last column
+            task->tKbFunctionKey = cursorY;
+            cursorY = s4RowTo3RowTableY[cursorY];
+        }
+        else if (prevCursorX == GetCurrentPageColumnCount())
+        {
+            if (cursorY == 1)
+                cursorY = task->tKbFunctionKey;
+            else
+                cursorY = s3RowTo4RowTableY[cursorY];
+        }
+    }
+
+    if (cursorX == GetCurrentPageColumnCount())
+    {
+        //There are only 3 keys on the last column, unlike the others,
+        //so wrap Y accordingly
+        if (cursorY < 0)
+            cursorY = 2;
+        if (cursorY > 2)
+            cursorY = 0;
+        if (cursorY == 0)
+            task->tKbFunctionKey = FNKEY_BACK;
+        else if (cursorY == 2)
+            task->tKbFunctionKey = FNKEY_OK;
+    }
+    else
+    {
+        if (cursorY < 0)
+            cursorY = 3;
+        if (cursorY > 3)
+            cursorY = 0;
+    }
+    SetCursorPos(cursorX, cursorY);
+}
+
+#undef tState
+#undef tKeyboardEvent
+#undef tKbFunctionKey
+
+static void PrintTitleFunction_NoMon(void)
+{
+    FillWindowPixelBuffer(sNamingScreenData->windows[3], PIXEL_FILL(1));
+    AddTextPrinterParameterized(sNamingScreenData->windows[3], 1, sNamingScreenData->template->title, 1, 1, 0, NULL);
+    PutWindowTilemap(sNamingScreenData->windows[3]);
+}
+
+static void PrintTitleFunction_WithMon(void)
+{
+    u8 buffer[0x20];
+
+    StringCopy(buffer, gSpeciesNames[sNamingScreenData->monSpecies]);
+    StringAppendN(buffer, sNamingScreenData->template->title, 15);
+    FillWindowPixelBuffer(sNamingScreenData->windows[3], PIXEL_FILL(1));
+    AddTextPrinterParameterized(sNamingScreenData->windows[3], 1, buffer, 1, 1, 0, NULL);
+    PutWindowTilemap(sNamingScreenData->windows[3]);
+}
+
+static void (*const sPrintTitleFuncs[])(void) = {
+    [NAMING_SCREEN_PLAYER]     = PrintTitleFunction_NoMon,
+    [NAMING_SCREEN_BOX]        = PrintTitleFunction_NoMon,
+    [NAMING_SCREEN_CAUGHT_MON] = PrintTitleFunction_WithMon,
+    [NAMING_SCREEN_NAME_RATER] = PrintTitleFunction_WithMon,
+    [NAMING_SCREEN_RIVAL]      = PrintTitleFunction_NoMon
+};
+
+static void PrintTitle(void)
+{
+    sPrintTitleFuncs[sNamingScreenData->templateNum]();
+}
+
+static void (*const sAddGenderIconFuncs[])(void) = {
+    AddGenderIconFunc_No,
+    AddGenderIconFunc_Yes
+};
+
+static void CallAddGenderIconFunc(void)
+{
+    sAddGenderIconFuncs[sNamingScreenData->template->addGenderIcon]();
+}
+
+static void AddGenderIconFunc_No(void)
+{
+
+}
+
+static const u8 sGenderColors[2][3] = {
+    [MALE]   = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_BLUE, TEXT_COLOR_BLUE},
+    [FEMALE] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_RED, TEXT_COLOR_RED}
+};
+
+static void AddGenderIconFunc_Yes(void)
+{
+    u8 genderSymbol[2];
+    bool8 gender = MALE;
+
+    StringCopy(genderSymbol, gText_MaleSymbol);
+
+    if (sNamingScreenData->monGender != MON_GENDERLESS)
+    {
+        if (sNamingScreenData->monGender == MON_FEMALE)
+        {
+            StringCopy(genderSymbol, gText_FemaleSymbol);
+            gender = FEMALE;
+        }
+        AddTextPrinterParameterized3(sNamingScreenData->windows[2], 2, 0x68, 1, sGenderColors[gender], TEXT_SPEED_FF, genderSymbol);
+    }
+}
+
+static u8 GetCharAtKeyboardPos(s16 x, s16 y)
+{
+    return gUnknown_83E22D0[sub_809DE50()][y][x];
+}
+
+static u8 GetTextCaretPosition(void)
+{
+    u8 i;
+
+    for (i = 0; i < sNamingScreenData->template->maxChars; i++)
+    {
+        if (sNamingScreenData->textBuffer[i] == EOS)
+            return i;
+    }
+    return sNamingScreenData->template->maxChars - 1;
+}
+
+static u8 GetPreviousTextCaretPosition(void)
+{
+    s8 i;
+
+    for (i = sNamingScreenData->template->maxChars - 1; i > 0; i--)
+    {
+        if (sNamingScreenData->textBuffer[i] != EOS)
+            return i;
+    }
+    return 0;
+}
+
+static void DeleteTextCharacter(void)
+{
+    u8 index;
+    u8 var2;
+
+    index = GetPreviousTextCaretPosition();
+    // Temporarily make this a space for redrawing purposes
+    sNamingScreenData->textBuffer[index] = CHAR_SPACE;
+    PrintBufferCharactersOnScreen();
+    CopyBgTilemapBufferToVram(3);
+    sNamingScreenData->textBuffer[index] = EOS;
+    var2 = GetKeyRoleAtCursorPos();
+    if (var2 == KEY_ROLE_CHAR || var2 == KEY_ROLE_BACKSPACE)
+        sub_809E518(1, 0, 1);
+    PlaySE(SE_BOWA);
+}
+
+static bool8 AppendCharToBuffer_CheckBufferFull(void)
+{
+    s16 x;
+    s16 y;
+
+    GetCursorPos(&x, &y);
+    AddTextCharacter(GetCharAtKeyboardPos(x, y));
+    PrintBufferCharactersOnScreen();
+    CopyBgTilemapBufferToVram(3);
+    PlaySE(SE_SELECT);
+
+    if (GetPreviousTextCaretPosition() != sNamingScreenData->template->maxChars - 1)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static void AddTextCharacter(u8 ch)
+{
+    u8 index = GetTextCaretPosition();
+
+    sNamingScreenData->textBuffer[index] = ch;
+}
+
+static void CopyStringToDestBuffer(void)
+{
+    // Copy from the first non-whitespace character
+    u8 i;
+
+    for (i = 0; i < sNamingScreenData->template->maxChars; i++)
+    {
+        if (sNamingScreenData->textBuffer[i] != CHAR_SPACE && sNamingScreenData->textBuffer[i] != EOS)
+        {
+            StringCopyN(sNamingScreenData->destBuffer, sNamingScreenData->textBuffer, sNamingScreenData->template->maxChars + 1);
+            break;
+        }
+    }
+}
+
+static void choose_name_or_words_screen_load_bg_tile_patterns(void)
+{
+    LZ77UnCompWram(gNamingScreenMenu_Gfx, sNamingScreenData->tileBuffer);
+    LoadBgTiles(1, sNamingScreenData->tileBuffer, 0x600, 0);
+    LoadBgTiles(2, sNamingScreenData->tileBuffer, 0x600, 0);
+    LoadBgTiles(3, sNamingScreenData->tileBuffer, 0x600, 0);
+    LoadSpriteSheets(gUnknown_83E267C);
+    LoadSpritePalettes(gUnknown_83E26E4);
+}
+
+static void sub_809F8C0(void)
+{
+    InputInit();
+    sub_809E4F0();
+}
+
+static void choose_name_or_words_screen_apply_bg_pals(void)
+{
+    LoadPalette(gNamingScreenMenu_Pal, 0, 0xC0);
+    LoadPalette(gUnknown_8E97FE4, 0xA0, 0x20);
+    LoadPalette(stdpal_get(2), 0xB0, 0x20);
+}
+
+static void DecompressToBgTilemapBuffer(u8 bg, const u32 *src)
+{
+    CopyToBgTilemapBuffer(bg, src, 0, 0);
+}
+
+static void PrintBufferCharactersOnScreen(void)
+{
+    u8 i;
+    u8 temp[2];
+    u16 xoff;
+    u8 maxChars = sNamingScreenData->template->maxChars;
+    u16 xpos = sNamingScreenData->inputCharBaseXPos - 0x40;
+
+    FillWindowPixelBuffer(sNamingScreenData->windows[2], PIXEL_FILL(1));
+
+    for (i = 0; i < maxChars; i++)
+    {
+        temp[0] = sNamingScreenData->textBuffer[i];
+        temp[1] = gExpandedPlaceholder_Empty[0];
+        xoff = (IsLetter(temp[0]) == TRUE) ? 2 : 0;
+
+        AddTextPrinterParameterized(sNamingScreenData->windows[2], 2, temp, i * 8 + xpos + xoff, 1, TEXT_SPEED_FF, NULL);
+    }
+
+    CallAddGenderIconFunc();
+    CopyWindowToVram(sNamingScreenData->windows[2], 2);
+    PutWindowTilemap(sNamingScreenData->windows[2]);
+}
+
+struct TextColor   // Needed because of alignment
+{
+    u8 colors[3][4];
+};
+
+static const struct TextColor sTextColorStruct = {
+    {
+        {TEXT_DYNAMIC_COLOR_4, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY},
+        {TEXT_DYNAMIC_COLOR_5, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY},
+        {TEXT_DYNAMIC_COLOR_6, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY}
+    }
+};
+
+static const u8 sFillValues[KBPAGE_COUNT] = {
+    [KBPAGE_LETTERS_LOWER] = PIXEL_FILL(14),
+    [KBPAGE_LETTERS_UPPER] = PIXEL_FILL(13),
+    [KBPAGE_SYMBOLS]       = PIXEL_FILL(15)
+};
+
+static const u8 *const sKeyboardTextColors[KBPAGE_COUNT] = {
+    [KBPAGE_LETTERS_LOWER] = sTextColorStruct.colors[1],
+    [KBPAGE_LETTERS_UPPER] = sTextColorStruct.colors[0],
+    [KBPAGE_SYMBOLS]       = sTextColorStruct.colors[2]
+};
+
+static void sub_809F9E8(u8 window, u8 page)
+{
+    u8 i;
+
+    FillWindowPixelBuffer(window, sFillValues[page]);
+
+    for (i = 0; i < KBROW_COUNT; i++)
+    {
+        AddTextPrinterParameterized3(window, 1, 0, i * 16 + 1, sKeyboardTextColors[page], 0, sNamingScreenKeyboardText[page][i]);
+    }
+
+    PutWindowTilemap(window);
+}
+
+static const u32 *const gUnknown_83E244C[] = {
+    gUnknown_8E98398,
+    gUnknown_8E98458,
+    gUnknown_8E98518
+};
+
+static void sub_809FA60(void)
+{
+    u8 bgId;
+    u8 bgId_copy;
+    u8 windowId;
+    u8 bg1Priority = GetGpuReg(REG_OFFSET_BG1CNT) & 3;
+    u8 bg2Priority = GetGpuReg(REG_OFFSET_BG2CNT) & 3;
+
+    if (bg1Priority > bg2Priority)
+    {
+        bgId = 1;
+        bgId_copy = 1;
+        windowId = sNamingScreenData->windows[0];
+    }
+    else
+    {
+        bgId = 2;
+        bgId_copy = 2;
+        windowId = sNamingScreenData->windows[1];
+    }
+
+    DecompressToBgTilemapBuffer(bgId, gUnknown_83E244C[sNamingScreenData->currentPage]);
+    sub_809F9E8(windowId, sub_809DE30());
+    CopyBgTilemapBufferToVram(bgId_copy);
+}
+
+static void sub_809FAE4(void)
+{
+    const u8 color[3] = { TEXT_DYNAMIC_COLOR_6, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY };
+    int strwidth = GetStringWidth(0, gText_MoveOkBack, 0);
+
+    FillWindowPixelBuffer(sNamingScreenData->windows[4], PIXEL_FILL(15));
+    AddTextPrinterParameterized3(sNamingScreenData->windows[4], 0, 236 - strwidth, 0, color, 0, gText_MoveOkBack);
+    PutWindowTilemap(sNamingScreenData->windows[4]);
+    CopyWindowToVram(sNamingScreenData->windows[4], 3);
+}
+
+static void sub_809FB70(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void NamingScreen_TurnOffScreen(void)
+{
+    SetVBlankCallback(NULL);
+    SetHBlankCallback(NULL);
+}
+
+static void NamingScreen_InitDisplayMode(void)
+{
+    SetVBlankCallback(VBlankCB_NamingScreen);
+}
+
+static void VBlankCB_NamingScreen(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+    SetGpuReg(REG_OFFSET_BG1VOFS, sNamingScreenData->bg1vOffset);
+    SetGpuReg(REG_OFFSET_BG2VOFS, sNamingScreenData->bg2vOffset);
+    SetGpuReg(REG_OFFSET_BG1CNT, GetGpuReg(REG_OFFSET_BG1CNT) & 0xFFFC); // clear priority bits
+    SetGpuRegBits(REG_OFFSET_BG1CNT, sNamingScreenData->bg1Priority);
+    SetGpuReg(REG_OFFSET_BG2CNT, GetGpuReg(REG_OFFSET_BG2CNT) & 0xFFFC); // clear priority bits
+    SetGpuRegBits(REG_OFFSET_BG2CNT, sNamingScreenData->bg2Priority);
+}
+
+static void ShowAllBgs(void)
+{
+    ShowBg(0);
+    ShowBg(1);
+    ShowBg(2);
+    ShowBg(3);
+}
+
+static bool8 IsLetter(u8 character)
+{
+    u8 i;
+
+    for (i = 0; gText_AlphabetUpperLower[i] != EOS; i++)
+    {
+        if (character == gText_AlphabetUpperLower[i])
+            return TRUE;
+    }
+    return FALSE;
+}
+
+//--------------------------------------------------
+// Unused debug functions
+//--------------------------------------------------
+
+static void Debug_DoNamingScreen_Player(void)
+{
+    DoNamingScreen(NAMING_SCREEN_PLAYER, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, MON_MALE, 0, CB2_ReturnToFieldWithOpenMenu);
+}
+
+static void Debug_DoNamingScreen_Box(void)
+{
+    DoNamingScreen(NAMING_SCREEN_BOX, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, MON_MALE, 0, CB2_ReturnToFieldWithOpenMenu);
+}
+
+static void Debug_DoNamingScreen_CaughtMon(void)
+{
+    DoNamingScreen(NAMING_SCREEN_CAUGHT_MON, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, MON_MALE, 0, CB2_ReturnToFieldWithOpenMenu);
+}
+
+static void Debug_DoNamingScreen_NameRater(void)
+{
+    DoNamingScreen(NAMING_SCREEN_NAME_RATER, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, MON_MALE, 0, CB2_ReturnToFieldWithOpenMenu);
+}
+
+static void Debug_DoNamingScreen_Rival(void)
+{
+    DoNamingScreen(NAMING_SCREEN_RIVAL, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, MON_MALE, 0, CB2_ReturnToFieldWithOpenMenu);
+}
+
+//--------------------------------------------------
+// Forward-declared variables
+//--------------------------------------------------
+
+static const struct NamingScreenTemplate sPlayerNamingScreenTemplate = {
+    .copyExistingString = FALSE,
+    .maxChars = PLAYER_NAME_LENGTH,
+    .iconFunction = 1,
+    .addGenderIcon = 0,
+    .initialPage = KBPAGE_LETTERS_UPPER,
+    .title = gText_YourName,
+};
+
+static const struct NamingScreenTemplate sPcBoxNamingScreenTemplate = {
+    .copyExistingString = FALSE,
+    .maxChars = 8/*BOX_NAME_LENGTH*/,
+    .iconFunction = 2,
+    .addGenderIcon = 0,
+    .initialPage = KBPAGE_LETTERS_UPPER,
+    .title = gText_BoxName,
+};
+
+static const struct NamingScreenTemplate sMonNamingScreenTemplate = {
+    .copyExistingString = FALSE,
+    .maxChars = POKEMON_NAME_LENGTH,
+    .iconFunction = 3,
+    .addGenderIcon = 1,
+    .initialPage = KBPAGE_LETTERS_UPPER,
+    .title = gText_PkmnsNickname,
+};
+
+static const struct NamingScreenTemplate sRivalNamingScreenTemplate = {
+    .copyExistingString = FALSE,
+    .maxChars = OT_NAME_LENGTH,
+    .iconFunction = 4,
+    .addGenderIcon = 0,
+    .initialPage = KBPAGE_LETTERS_UPPER,
+    .title = gText_RivalsName,
+};
+
+static const struct NamingScreenTemplate *const sNamingScreenTemplates[] = {
+    &sPlayerNamingScreenTemplate,
+    &sPcBoxNamingScreenTemplate,
+    &sMonNamingScreenTemplate,
+    &sMonNamingScreenTemplate,
+    &sRivalNamingScreenTemplate,
+};
+
+static const struct OamData gOamData_858BFEC = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(8x8),
+    .x = 0,
+    .size = SPRITE_SIZE(8x8),
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+};
+
+static const struct OamData gOamData_858BFF4 = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+};
+
+static const struct OamData gOamData_858BFFC = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x16),
+    .x = 0,
+    .size = SPRITE_SIZE(32x16),
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+};
+
+static const struct Subsprite gUnknown_83E24B8[] = {
+    {
+        .x = -20,
+        .y = -16,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 0,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y = -16,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 4,
+        .priority = 1
+    }, {
+        .x = -20,
+        .y = -8,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 5,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y = -8,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 9,
+        .priority = 1
+    }, {
+        .x = -20,
+        .y =  0,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 10,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y =  0,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 14,
+        .priority = 1
+    }, {
+        .x = -20,
+        .y =  8,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 15,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y =  8,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 19,
+        .priority = 1
+    }
+};
+
+static const struct Subsprite gUnknown_83E24D8[] = {
+    {
+        .x = -12,
+        .y = -4,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 0,
+        .priority = 1
+    }, {
+        .x =   4,
+        .y = -4,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 2,
+        .priority = 1
+    }
+};
+
+static const struct Subsprite gUnknown_83E24E0[] = {
+    {
+        .x = -20,
+        .y = -12,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 0,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y = -12,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 4,
+        .priority = 1
+    }, {
+        .x = -20,
+        .y = -4,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 5,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y = -4,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 9,
+        .priority = 1
+    }, {
+        .x = -20,
+        .y =  4,
+        .shape = SPRITE_SHAPE(32x8),
+        .size = SPRITE_SIZE(32x8),
+        .tileOffset = 10,
+        .priority = 1
+    }, {
+        .x =  12,
+        .y =  4,
+        .shape = SPRITE_SHAPE(8x8),
+        .size = SPRITE_SIZE(8x8),
+        .tileOffset = 14,
+        .priority = 1
+    }
+};
+
+static const struct Subsprite gUnknown_83E24F8[] = {
+    {
+        .x = -8,
+        .y = -12,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 0,
+        .priority = 3
+    }, {
+        .x = -8,
+        .y = -4,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 2,
+        .priority = 3
+    }, {
+        .x = -8,
+        .y =  4,
+        .shape = SPRITE_SHAPE(16x8),
+        .size = SPRITE_SIZE(16x8),
+        .tileOffset = 4,
+        .priority = 3
+    }
+};
+
+static const struct SubspriteTable gUnknown_83E2504[] = {
+    subsprite_table(gUnknown_83E24B8)
+};
+
+static const struct SubspriteTable gUnknown_83E250C[] = {
+    subsprite_table(gUnknown_83E24D8),
+    subsprite_table(gUnknown_83E24D8),
+    subsprite_table(gUnknown_83E24D8)
+};
+
+static const struct SubspriteTable gUnknown_83E2524[] = {
+    subsprite_table(gUnknown_83E24E0)
+};
+
+static const struct SubspriteTable gUnknown_83E252C[] = {
+    subsprite_table(gUnknown_83E24F8)
+};
+
+static const struct SpriteFrameImage gUnknown_0858C080[] = {
+    {gUnknown_83E1800, sizeof(gUnknown_83E1800)},
+    {gUnknown_83E18C0, sizeof(gUnknown_83E18C0)},
+};
+
+static const union AnimCmd gSpriteAnim_858C090[] = {
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd gSpriteAnim_858C098[] = {
+    ANIMCMD_FRAME(4, 8),
+    ANIMCMD_FRAME(8, 8),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gSpriteAnim_858C0A4[] = {
+    ANIMCMD_FRAME(0, 2),
+    ANIMCMD_FRAME(1, 2),
+    ANIMCMD_JUMP(0)
+};
+
+static const union AnimCmd *const gSpriteAnimTable_858C0B0[] = {
+    gSpriteAnim_858C090
+};
+
+static const union AnimCmd *const gSpriteAnimTable_858C0B4[] = {
+    gSpriteAnim_858C090,
+    gSpriteAnim_858C098
+};
+
+static const union AnimCmd *const gSpriteAnimTable_858C0BC[] = {
+    gSpriteAnim_858C0A4
+};
+
+static const struct SpriteTemplate gUnknown_83E2574 = {
+    .tileTag = 0x0002,
+    .paletteTag = 0x0004,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_PageSwap
+};
+
+static const struct SpriteTemplate gUnknown_83E258C = {
+    .tileTag = 0x0003,
+    .paletteTag = 0x0001,
+    .oam = &gOamData_858BFFC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_83E25A4 = {
+    .tileTag = 0x0004,
+    .paletteTag = 0x0004,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_83E25BC = {
+    .tileTag = 0x0000,
+    .paletteTag = 0x0006,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_83E25D4 = {
+    .tileTag = 0x0001,
+    .paletteTag = 0x0007,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct SpriteTemplate gUnknown_83E25EC = {
+    .tileTag = 0x0007,
+    .paletteTag = 0x0005,
+    .oam = &gOamData_858BFF4,
+    .anims = gSpriteAnimTable_858C0B4,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_809E700
+};
+
+static const struct SpriteTemplate sSpriteTemplate_InputArrow = {
+    .tileTag = 0x000A,
+    .paletteTag = 0x0003,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_809E7F0
+};
+
+static const struct SpriteTemplate sSpriteTemplate_Underscore = {
+    .tileTag = 0x000B,
+    .paletteTag = 0x0003,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0B0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_809E83C
+};
+
+static const struct SpriteTemplate gUnknown_83E2634 = {
+    .tileTag = 0xFFFF,
+    .paletteTag = 0x0000,
+    .oam = &gOamData_858BFEC,
+    .anims = gSpriteAnimTable_858C0BC,
+    .images = gUnknown_0858C080,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const u8 *const sNamingScreenKeyboardText[KBPAGE_COUNT][KBROW_COUNT] = {
+    [KBPAGE_LETTERS_LOWER] = {
+        gText_NamingScreenKeyboard_abcdef,
+        gText_NamingScreenKeyboard_ghijkl,
+        gText_NamingScreenKeyboard_mnopqrs,
+        gText_NamingScreenKeyboard_tuvwxyz
+    },
+    [KBPAGE_LETTERS_UPPER] = {
+        gText_NamingScreenKeyboard_ABCDEF,
+        gText_NamingScreenKeyboard_GHIJKL,
+        gText_NamingScreenKeyboard_MNOPQRS,
+        gText_NamingScreenKeyboard_TUVWXYZ
+    },
+    [KBPAGE_SYMBOLS] = {
+        gText_NamingScreenKeyboard_01234,
+        gText_NamingScreenKeyboard_56789,
+        gText_NamingScreenKeyboard_Symbols1,
+        gText_NamingScreenKeyboard_Symbols2
+    },
+};
+
+// FIXME: Sync with Emerald
+static const struct SpriteSheet gUnknown_83E267C[] = {
+    {gUnknown_8E98858, 0x1E0,  0x0000},
+    {gUnknown_8E98A38, 0x1E0,  0x0001},
+    {gUnknown_8E985D8, 0x280,  0x0002},
+    {gUnknown_8E98FD8, 0x100,  0x0003},
+    {gUnknown_8E98C18, 0x060,  0x0004},
+    {gUnknown_8E98CB8, 0x060,  0x0005},
+    {gUnknown_8E98D58, 0x060,  0x0006},
+    {gUnknown_8E98DF8, 0x080,  0x0007},
+    {gUnknown_8E98E98, 0x080,  0x0008},
+    {gUnknown_8E98F38, 0x080,  0x0009},
+    {gUnknown_8E990D8, 0x020,  0x000A},
+    {gUnknown_8E990F8, 0x020,  0x000B},
+    {} // terminator
+};
+
+static const struct SpritePalette gUnknown_83E26E4[] = {
+    {gNamingScreenMenu_Pal,         0x0000},
+    {gNamingScreenMenu_Pal + 0x10,  0x0001},
+    {gNamingScreenMenu_Pal + 0x20,  0x0002},
+    {gNamingScreenMenu_Pal + 0x30,  0x0003},
+    {gNamingScreenMenu_Pal + 0x40,  0x0004},
+    {gNamingScreenMenu_Pal + 0x50,  0x0005},
+    {gNamingScreenMenu_Pal + 0x40,  0x0006},
+    {gNamingScreenMenu_Pal + 0x40,  0x0007},
+    {} // terminator
+};
diff --git a/src/new_game.c b/src/new_game.c
index 05fb9c83e..d03e83b34 100644
--- a/src/new_game.c
+++ b/src/new_game.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "new_game.h"
 #include "random.h"
 #include "main.h"
 #include "overworld.h"
@@ -145,7 +144,7 @@ void NewGameInitData(void)
     ResetTrainerFanClub();
     UnionRoomChat_InitializeRegisteredTexts();
     ResetMiniGamesResults();
-    sub_8143D24();
+    InitMEventData();
     SetAllRenewableItemFlags();
     WarpToPlayersRoom();
     ScriptContext2_RunNewScript(EventScript_ResetAllMapFlags);
diff --git a/src/new_menu_helpers.c b/src/new_menu_helpers.c
index 39340ca55..959370398 100644
--- a/src/new_menu_helpers.c
+++ b/src/new_menu_helpers.c
@@ -3,7 +3,6 @@
 #include "dma3.h"
 #include "task.h"
 #include "bg.h"
-#include "gpu_regs.h"
 #include "window.h"
 #include "menu.h"
 #include "menu_helpers.h"
@@ -13,7 +12,6 @@
 #include "field_specials.h"
 #include "text_window.h"
 #include "script.h"
-#include "graphics.h"
 #include "palette.h"
 
 #define DLG_WINDOW_PALETTE_NUM 15
@@ -718,7 +716,7 @@ void DestroyHelpMessageWindow_(void)
     DestroyHelpMessageWindow(2);
 }
 
-void sub_80F79A4(void)
+void LoadSignPostWindowFrameGfx(void)
 {
     Menu_LoadStdPal();
     sub_814FEEC(0, DLG_WINDOW_BASE_TILE_NUM, 0x10 * DLG_WINDOW_PALETTE_NUM);
diff --git a/src/oak_speech.c b/src/oak_speech.c
index 6887ff85a..11281da30 100644
--- a/src/oak_speech.c
+++ b/src/oak_speech.c
@@ -4,7 +4,6 @@
 #include "task.h"
 #include "malloc.h"
 #include "gpu_regs.h"
-#include "wild_encounter.h"
 #include "palette.h"
 #include "blend_palette.h"
 #include "text.h"
@@ -25,7 +24,6 @@
 #include "overworld.h"
 #include "random.h"
 #include "data.h"
-#include "oak_speech.h"
 #include "constants/species.h"
 #include "constants/songs.h"
 
@@ -514,7 +512,7 @@ static void Task_OaksSpeech1(u8 taskId)
         ResetSpriteData();
         FreeAllSpritePalettes();
         ResetTempTileDataBuffers();
-        HelpSystem_SetSomeVariable2(2);
+        SetHelpContext(HELPCONTEXT_NEW_GAME);
         break;
     case 1:
         sOakSpeechResources = AllocZeroed(sizeof(*sOakSpeechResources));
@@ -1225,13 +1223,13 @@ static void Task_OakSpeech25(u8 taskId)
         GetDefaultName(sOakSpeechResources->unk_0010, 0);
         if (sOakSpeechResources->unk_0010 == 0)
         {
-            DoNamingScreen(0, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, 0, 0, CB2_ReturnFromNamingScreen);
+            DoNamingScreen(NAMING_SCREEN_PLAYER, gSaveBlock2Ptr->playerName, gSaveBlock2Ptr->playerGender, 0, 0, CB2_ReturnFromNamingScreen);
         }
         else
         {
             ClearStdWindowAndFrameToTransparent(gTasks[taskId].data[13], 1);
             RemoveWindow(gTasks[taskId].data[13]);
-            DoNamingScreen(4, gSaveBlock1Ptr->rivalName, 0, 0, 0, CB2_ReturnFromNamingScreen);
+            DoNamingScreen(NAMING_SCREEN_RIVAL, gSaveBlock1Ptr->rivalName, 0, 0, 0, CB2_ReturnFromNamingScreen);
         }
         DestroyLinkedPikaOrGrassPlatformSprites(taskId, 1);
         FreeAllWindowBuffers();
diff --git a/src/option_menu.c b/src/option_menu.c
index 5453dfa9e..56a4ec877 100644
--- a/src/option_menu.c
+++ b/src/option_menu.c
@@ -224,7 +224,7 @@ void CB2_OptionsMenuFromStartMenu(void)
         if (sOptionMenuPtr->option[i] > (sOptionMenuItemCounts[i]) - 1)
             sOptionMenuPtr->option[i] = 0;
     }
-    HelpSystem_SetSomeVariable2(0xD);
+    SetHelpContext(HELPCONTEXT_OPTIONS);
     SetMainCallback2(CB2_OptionMenu);
 }
 
diff --git a/src/palette.c b/src/palette.c
index 6609c9baa..04638f6d1 100644
--- a/src/palette.c
+++ b/src/palette.c
@@ -948,7 +948,7 @@ void sub_8071898(void)
     while (TRUE)
     {
         taskId = FindTaskIdByFunc(sub_80718B8);
-        if (taskId == TASK_NONE)
+        if (taskId == TAIL_SENTINEL)
             break;
         DestroyTask(taskId);
     }
diff --git a/src/party_menu.c b/src/party_menu.c
index df0e70b37..edf7e96f6 100644
--- a/src/party_menu.c
+++ b/src/party_menu.c
@@ -1,5 +1,5 @@
 #include "global.h"
-#include "malloc.h"
+#include "gflib.h"
 #include "battle.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
@@ -7,21 +7,17 @@
 #include "battle_interface.h"
 #include "battle_tower.h"
 #include "berry_pouch.h"
-#include "bg.h"
 #include "data.h"
 #include "decompress.h"
 #include "easy_chat.h"
 #include "event_data.h"
 #include "evolution_scene.h"
-#include "field_control_avatar.h"
 #include "field_effect.h"
 #include "field_player_avatar.h"
-#include "field_screen_effect.h"
-#include "field_specials.h"
+#include "field_fadetransition.h"
 #include "field_weather.h"
 #include "fieldmap.h"
 #include "fldeff.h"
-#include "gpu_regs.h"
 #include "graphics.h"
 #include "help_system.h"
 #include "item.h"
@@ -38,7 +34,6 @@
 #include "new_menu_helpers.h"
 #include "metatile_behavior.h"
 #include "overworld.h"
-#include "palette.h"
 #include "party_menu.h"
 #include "player_pc.h"
 #include "pokedex.h"
@@ -46,26 +41,21 @@
 #include "pokemon_icon.h"
 #include "pokemon_jump.h"
 #include "pokemon_special_anim.h"
-#include "pokemon_storage_system.h"
 #include "pokemon_summary_screen.h"
 #include "quest_log.h"
 #include "region_map.h"
 #include "reshow_battle_screen.h"
 #include "scanline_effect.h"
 #include "script.h"
-#include "sound.h"
-#include "sprite.h"
 #include "start_menu.h"
 #include "string_util.h"
 #include "strings.h"
 #include "task.h"
 #include "teachy_tv.h"
-#include "text.h"
 #include "text_window.h"
 #include "tm_case.h"
 #include "trade.h"
 #include "union_room.h"
-#include "window.h"
 #include "constants/battle.h"
 #include "constants/easy_chat.h"
 #include "constants/field_effects.h"
@@ -78,7 +68,6 @@
 #include "constants/quest_log.h"
 #include "constants/songs.h"
 #include "constants/species.h"
-#include "constants/vars.h"
 
 #define PARTY_PAL_SELECTED     (1 << 0)
 #define PARTY_PAL_FAINTED      (1 << 1)
@@ -577,7 +566,7 @@ static bool8 ShowPartyMenu(void)
         ++gMain.state;
         break;
     case 19:
-        HelpSystem_SetSomeVariable2(5);
+        SetHelpContext(HELPCONTEXT_PARTY_MENU);
         ++gMain.state;
         break;
     case 20:
@@ -3881,7 +3870,7 @@ static void CursorCB_Register(u8 taskId)
     u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES);
     u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE);
 
-    switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)sub_80F9800(), species2, species, obedience))
+    switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)GetHostRFUtgtGname(), species2, species, obedience))
     {
     case CANT_REGISTER_MON:
         StringExpandPlaceholders(gStringVar4, gText_PkmnCantBeTradedNow);
@@ -3907,7 +3896,7 @@ static void CursorCB_Trade1(u8 taskId)
     u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2);
     u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES);
     u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE);
-    u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)sub_80F9800(), gUnknown_203B064, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience);
+    u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)GetHostRFUtgtGname(), gPartnerTgtGnameSub, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience);
 
     if (stringId != UR_TRADE_MSG_NONE)
     {
@@ -4048,7 +4037,7 @@ static void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId)
 
 bool8 FieldCallback_PrepareFadeInFromMenu(void)
 {
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(Task_FieldMoveWaitForFade, 8);
     return TRUE;
 }
@@ -6365,7 +6354,7 @@ void ChoosePartyMonByMenuType(u8 menuType)
 
 static bool8 CB2_FadeFromPartyMenu(void)
 {
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(Task_PartyMenuWaitForFade, 10);
     return TRUE;
 }
diff --git a/src/party_menu_specials.c b/src/party_menu_specials.c
index 751684bd5..aba11a534 100644
--- a/src/party_menu_specials.c
+++ b/src/party_menu_specials.c
@@ -2,7 +2,6 @@
 #include "data.h"
 #include "script.h"
 #include "overworld.h"
-#include "battle.h"
 #include "palette.h"
 #include "pokemon.h"
 #include "party_menu.h"
@@ -14,7 +13,7 @@
 
 static void sub_80BF97C(u8 taskId);
 
-void Special_ChooseMonFromParty(void)
+void ChoosePartyMon(void)
 {
     u8 taskId;
 
@@ -24,7 +23,7 @@ void Special_ChooseMonFromParty(void)
     BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK);
 }
 
-void Special_SelectMoveTutorMon(void)
+void SelectMoveTutorMon(void)
 {
     u8 taskId;
 
@@ -44,14 +43,14 @@ static void sub_80BF97C(u8 taskId)
     }
 }
 
-void Special_SelectMove(void)
+void SelectMoveDeleterMove(void)
 {
     ShowSelectMovePokemonSummaryScreen(gPlayerParty, gSpecialVar_0x8004, gPlayerPartyCount - 1, CB2_ReturnToField, 0);
     sub_8138B38(3);
     gFieldCallback = FieldCallback_ReturnToEventScript2;
 }
 
-void Special_GetNumMovesSelectedMonHas(void)
+void GetNumMovesSelectedMonHas(void)
 {
     u8 i;
 
@@ -61,7 +60,7 @@ void Special_GetNumMovesSelectedMonHas(void)
             ++gSpecialVar_Result;
 }
 
-void Special_BufferMoveDeleterNicknameAndMove(void)
+void BufferMoveDeleterNicknameAndMove(void)
 {
     struct Pokemon *mon = &gPlayerParty[gSpecialVar_0x8004];
     u16 move = GetMonData(mon, MON_DATA_MOVE1 + gSpecialVar_0x8005);
@@ -92,7 +91,7 @@ static void ShiftMoveSlot(struct Pokemon *mon, u8 slotTo, u8 slotFrom)
     SetMonData(mon, MON_DATA_PP_BONUSES, &ppBonuses);
 }
 
-void Special_MoveDeleterForgetMove(void)
+void MoveDeleterForgetMove(void)
 {
     u16 i;
 
@@ -102,7 +101,7 @@ void Special_MoveDeleterForgetMove(void)
         ShiftMoveSlot(&gPlayerParty[gSpecialVar_0x8004], i, i + 1);
 }
 
-void Special_IsSelectedMonEgg(void)
+void IsSelectedMonEgg(void)
 {
     if (GetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_IS_EGG))
         gSpecialVar_Result = TRUE;
diff --git a/src/player_pc.c b/src/player_pc.c
index 928676844..736c67a51 100644
--- a/src/player_pc.c
+++ b/src/player_pc.c
@@ -23,6 +23,7 @@
 #include "party_menu.h"
 #include "constants/items.h"
 #include "constants/songs.h"
+#include "constants/field_weather.h"
 
 #define PC_ITEM_ID  0
 #define PC_QUANTITY 1
@@ -153,8 +154,8 @@ void BedroomPC(void)
 {
     u8 taskId;
 
-    gPlayerPcMenuManager.unk_9 = 0;
-    HelpSystem_BackupSomeVariable();
+    gPlayerPcMenuManager.notInRoom = FALSE;
+    BackupHelpContext();
     sItemOrder = gUnknown_8402200;
     sTopMenuItemCount = 3;
     taskId = CreateTask(TaskDummy, 0);
@@ -165,8 +166,8 @@ void PlayerPC(void)
 {
     u8 taskId;
 
-    gPlayerPcMenuManager.unk_9 = 1;
-    HelpSystem_BackupSomeVariable();
+    gPlayerPcMenuManager.notInRoom = TRUE;
+    BackupHelpContext();
     sItemOrder = gUnknown_8402203;
     sTopMenuItemCount = 3;
     taskId = CreateTask(TaskDummy, 0);
@@ -215,7 +216,7 @@ static void Task_TopMenuHandleInput(u8 taskId)
 
 static void Task_ReturnToTopMenu(u8 taskId)
 {
-    HelpSystem_RestoreSomeVariable();
+    RestoreHelpContext();
     DisplayItemMessageOnField(taskId, 2, gText_WhatWouldYouLikeToDo, Task_DrawPlayerPcTopMenu);
 }
 
@@ -238,10 +239,10 @@ static void Task_PlayerPcMailbox(u8 taskId)
         gPlayerPcMenuManager.itemsAbove = 0;
         PCMailCompaction();
         Task_SetPageItemVars(taskId);
-        if (gPlayerPcMenuManager.unk_9 == 0)
-            HelpSystem_SetSomeVariable2(34);
+        if (gPlayerPcMenuManager.notInRoom == FALSE)
+            SetHelpContext(HELPCONTEXT_BEDROOM_PC_MAILBOX);
         else
-            HelpSystem_SetSomeVariable2(30);
+            SetHelpContext(HELPCONTEXT_PLAYERS_PC_MAILBOX);
         if (MailboxPC_InitBuffers(gPlayerPcMenuManager.count) == TRUE)
         {
             ClearDialogWindowAndFrame(0, FALSE);
@@ -257,7 +258,7 @@ static void Task_PlayerPcMailbox(u8 taskId)
 
 static void Task_PlayerPcTurnOff(u8 taskId)
 {
-    if (gPlayerPcMenuManager.unk_9 == 0)
+    if (gPlayerPcMenuManager.notInRoom == FALSE)
         ScriptContext1_SetupScript(EventScript_PalletTown_PlayersHouse_2F_ShutDownPC);
     else
         EnableBothScriptContexts();
@@ -267,10 +268,10 @@ static void Task_PlayerPcTurnOff(u8 taskId)
 static void Task_CreateItemStorageSubmenu(u8 taskId, u8 cursorPos)
 {
     s16 *data = gTasks[taskId].data;
-    if (gPlayerPcMenuManager.unk_9 == 0)
-        HelpSystem_SetSomeVariable2(33);
+    if (gPlayerPcMenuManager.notInRoom == FALSE)
+        SetHelpContext(HELPCONTEXT_BEDROOM_PC_ITEMS);
     else
-        HelpSystem_SetSomeVariable2(29);
+        SetHelpContext(HELPCONTEXT_PLAYERS_PC_ITEMS);
     tWindowId = AddWindow(&sWindowTemplate_ItemStorageSubmenu);
     SetStdWindowBorderStyle(tWindowId, FALSE);
     PrintTextArray(tWindowId, 2, GetMenuCursorDimensionByFont(2, 0), 2, 16, 3, sMenuActions_ItemPc);
@@ -331,7 +332,7 @@ static void Task_DepositItem_WaitFadeAndGoToBag(u8 taskId)
 static void Task_PlayerPcDepositItem(u8 taskId)
 {
     gTasks[taskId].func = Task_DepositItem_WaitFadeAndGoToBag;
-    FadeScreen(1, 0);
+    FadeScreen(FADE_TO_BLACK, 0);
 }
 
 static void Task_ReturnToItemStorageSubmenu(u8 taskId)
@@ -347,7 +348,7 @@ static void CB2_ReturnFromDepositMenu(void)
     DrawDialogueFrame(0, TRUE);
     taskId = CreateTask(Task_ReturnToItemStorageSubmenu, 0);
     Task_CreateItemStorageSubmenu(taskId, 1);
-    sub_807DC00();
+    FadeInFromBlack();
 }
 
 static void Task_PlayerPcWithdrawItem(u8 taskId)
@@ -376,7 +377,7 @@ static void CB2_ReturnFromWithdrawMenu(void)
     DrawDialogueFrame(0, TRUE);
     taskId = CreateTask(Task_ReturnToItemStorageSubmenu, 0);
     Task_CreateItemStorageSubmenu(taskId, 0);
-    sub_807DC00();
+    FadeInFromBlack();
 }
 
 static void Task_WithdrawItem_WaitFadeAndGoToItemStorage(u8 taskId)
@@ -394,7 +395,7 @@ static void Task_WithdrawItemBeginFade(u8 taskId)
 {
     gTasks[taskId].func = Task_WithdrawItem_WaitFadeAndGoToItemStorage;
     ItemPc_SetInitializedFlag(0);
-    FadeScreen(1, 0);
+    FadeScreen(FADE_TO_BLACK, 0);
 }
 
 static void Task_PlayerPcCancel(u8 taskId)
@@ -556,7 +557,7 @@ static void Task_MailSubmenuHandleInput(u8 taskId)
 
 static void Task_PlayerPcReadMail(u8 taskId)
 {
-    FadeScreen(1, 0);
+    FadeScreen(FADE_TO_BLACK, 0);
     gTasks[taskId].func = Task_WaitFadeAndReadSelectedMail;
 }
 
@@ -580,17 +581,17 @@ static void Task_WaitFadeAndReturnToMailboxPcInputHandler(u8 taskId)
 static void CB2_ReturnToMailbox(void)
 {
     u8 taskId;
-    if (gPlayerPcMenuManager.unk_9 == 0)
-        HelpSystem_SetSomeVariable2(34);
+    if (gPlayerPcMenuManager.notInRoom == FALSE)
+        SetHelpContext(HELPCONTEXT_BEDROOM_PC_MAILBOX);
     else
-        HelpSystem_SetSomeVariable2(30);
+        SetHelpContext(HELPCONTEXT_PLAYERS_PC_MAILBOX);
     LoadStdWindowFrameGfx();
     taskId = CreateTask(Task_WaitFadeAndReturnToMailboxPcInputHandler, 0);
     if (MailboxPC_InitBuffers(gPlayerPcMenuManager.count) == TRUE)
         Task_DrawMailboxPcMenu(taskId);
     else
         DestroyTask(taskId);
-    sub_807DC00();
+    FadeInFromBlack();
 }
 
 static void CB2_SetCbToReturnToMailbox(void)
@@ -663,7 +664,7 @@ static void Task_PlayerPcGiveMailToMon(u8 taskId)
     }
     else
     {
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
         gTasks[taskId].func = Task_WaitFadeAndGoToPartyMenu;
     }
 }
@@ -683,10 +684,10 @@ static void CB2_ReturnToMailboxPc_UpdateScrollVariables(void)
 {
     u8 taskId;
     u8 count;
-    if (gPlayerPcMenuManager.unk_9 == 0)
-        HelpSystem_SetSomeVariable2(34);
+    if (gPlayerPcMenuManager.notInRoom == FALSE)
+        SetHelpContext(HELPCONTEXT_BEDROOM_PC_MAILBOX);
     else
-        HelpSystem_SetSomeVariable2(30);
+        SetHelpContext(HELPCONTEXT_PLAYERS_PC_MAILBOX);
     taskId = CreateTask(Task_WaitFadeAndReturnToMailboxPcInputHandler, 0);
     count = gPlayerPcMenuManager.count;
     gPlayerPcMenuManager.count = CountPCMail();
@@ -705,7 +706,7 @@ static void CB2_ReturnToMailboxPc_UpdateScrollVariables(void)
         Task_DrawMailboxPcMenu(taskId);
     else
         DestroyTask(taskId);
-    sub_807DC00();
+    FadeInFromBlack();
 }
 
 void Mailbox_ReturnToMailListAfterDeposit(void)
diff --git a/src/pokeball.c b/src/pokeball.c
index aeaba08ab..92b22abe6 100644
--- a/src/pokeball.c
+++ b/src/pokeball.c
@@ -15,7 +15,6 @@
 #include "link.h"
 #include "battle_gfx_sfx_util.h"
 #include "constants/songs.h"
-#include "constants/species.h"
 
 #define tFrames          data[0]
 #define tPan             data[1]
diff --git a/src/pokedex_screen.c b/src/pokedex_screen.c
index 2ccec7a3f..0219ca466 100644
--- a/src/pokedex_screen.c
+++ b/src/pokedex_screen.c
@@ -302,7 +302,7 @@ void CB2_OpenPokedexFromStartMenu(void)
     SetGpuReg(REG_OFFSET_BLDALPHA, 0);
     SetGpuReg(REG_OFFSET_BLDY, 0);
     SetMainCallback2(sub_81024D4);
-    HelpSystem_SetSomeVariable2(4);
+    SetHelpContext(HELPCONTEXT_POKEDEX);
 }
 
 #define FREE_IF_NOT_NULL(ptr0) ({ void * ptr = (ptr0); if (ptr) Free(ptr); })
@@ -562,8 +562,8 @@ void sub_8102F80(u8 taskId)
     switch (gUnknown_203ACF0->field_01)
     {
     case 0:
-        sub_8107D38(0x10, 0);
-        sub_8107D38(0x20, 1);
+        ListMenuLoadStdPalAt(0x10, 0);
+        ListMenuLoadStdPalAt(0x20, 1);
         gUnknown_203ACF0->field_48 = sub_8103518(gUnknown_203ACF0->field_42);
         gUnknown_203ACF0->field_01 = 2;
         break;
@@ -648,8 +648,8 @@ void sub_8103238(u8 taskId)
     switch (gUnknown_203ACF0->field_01)
     {
     case 0:
-        sub_8107D38(0x10, 0);
-        sub_8107D38(0x20, 1);
+        ListMenuLoadStdPalAt(0x10, 0);
+        ListMenuLoadStdPalAt(0x20, 1);
         gUnknown_203ACF0->field_48 = sub_8103518(gUnknown_203ACF0->field_42);
         gUnknown_203ACF0->field_01 = 2;
         break;
diff --git a/src/pokemon.c b/src/pokemon.c
index 09e2ed998..f1f7834b1 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -90,7 +90,20 @@ static u16 CalculateBoxMonChecksum(struct BoxPokemon *boxMon);
 
 #include "data/battle_moves.h"
 
-static const u8 sUnreferencedData[] = { 0x34, 0x00, 0x10, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 };
+// Used in an unreferenced function in RS.
+// Unreferenced here and in Emerald.
+struct CombinedMove
+{
+    u16 move1;
+    u16 move2;
+    u16 newMove;
+};
+
+static const struct CombinedMove sCombinedMoves[2] =
+{
+    {MOVE_EMBER, MOVE_GUST, MOVE_HEAT_WAVE},
+    {0xFFFF, 0xFFFF, 0xFFFF}
+};
 
 static const u16 sSpeciesToHoennPokedexNum[] = // Assigns all species to the Hoenn Dex Index (Summary No. for Hoenn Dex)
 {
diff --git a/src/pokemon_jump.c b/src/pokemon_jump.c
new file mode 100644
index 000000000..063176151
--- /dev/null
+++ b/src/pokemon_jump.c
@@ -0,0 +1,254 @@
+#include "global.h"
+#include "gflib.h"
+#include "battle_anim.h"
+#include "decompress.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "task.h"
+#include "constants/songs.h"
+
+static void sub_8147654(u8 taskId);
+static void sub_81477C0(u8 taskId);
+static void sub_814784C(u8 taskId);
+static void sub_81479D4(u8 taskId);
+static void sub_8147A34(u8 taskId);
+
+static const u16 gUnknown_846AFE8[] = INCBIN_U16("graphics/misc/unk_846B008.gbapal");
+static const u32 gUnknown_846B008[] = INCBIN_U32("graphics/misc/unk_846B008.4bpp.lz");
+
+static const struct CompressedSpriteSheet gUnknown_846B42C[] = {
+    {gUnknown_846B008, 0x0C00, 0x2000},
+    {}
+};
+
+static const struct SpritePalette gUnknown_846B43C[] = {
+    {gUnknown_846AFE8, 0x2000},
+    {}
+};
+
+static const union AnimCmd gUnknown_846B44C[] = {
+    ANIMCMD_FRAME(0x00, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846B454[] = {
+    ANIMCMD_FRAME(0x10, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846B45C[] = {
+    ANIMCMD_FRAME(0x20, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846B464[] = {
+    ANIMCMD_FRAME(0x40, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846B46C[] = {
+    ANIMCMD_FRAME(0x30, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd gUnknown_846B474[] = {
+    ANIMCMD_FRAME(0x50, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const gUnknown_846B47C[] = {
+    gUnknown_846B44C,
+    gUnknown_846B454,
+    gUnknown_846B45C,
+    gUnknown_846B464,
+    gUnknown_846B46C,
+    gUnknown_846B474
+};
+
+static const struct SpriteTemplate gUnknown_846B494[] = {
+    {
+        .tileTag = 0x2000,
+        .paletteTag = 0x2000,
+        .oam = &gOamData_AffineOff_ObjNormal_32x32,
+        .anims = gUnknown_846B47C,
+        .affineAnims = gDummySpriteAffineAnimTable,
+        .callback = SpriteCallbackDummy
+    },
+};
+
+static const TaskFunc gUnknown_846B4AC[][4] = {
+    { sub_81477C0, sub_814784C, sub_81479D4, sub_8147A34 }
+};
+
+// Unused, but looks like it was intended to be a hook
+UNUSED u8 sub_81475C0(u8 data1, u8 priority)
+{
+    u8 taskId;
+    struct Task * task;
+
+    taskId = CreateTask(sub_8147654, priority);
+    task = &gTasks[taskId];
+    task->data[0] = 1;
+    task->data[1] = data1;
+    gUnknown_846B4AC[data1][0](taskId);
+    return taskId;
+}
+
+// Unused, but looks like it was intended to be a hook
+UNUSED bool32 sub_814760C(void)
+{
+    u8 taskId;
+
+    taskId = FindTaskIdByFunc(sub_8147654);
+    if (taskId == 0xFF)
+        return FALSE;
+    gTasks[taskId].data[0] = 2;
+    return TRUE;
+}
+
+// Unused, but looks like it was intended to be a hook
+UNUSED bool32 sub_8147640(void)
+{
+    return FuncIsActiveTask(sub_8147654);
+}
+
+static void sub_8147654(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 2:
+        gUnknown_846B4AC[data[1]][2](taskId);
+        data[0] = 3;
+        break;
+    case 3:
+        gUnknown_846B4AC[data[1]][3](taskId);
+        break;
+    case 4:
+        gUnknown_846B4AC[data[1]][1](taskId);
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+static void sub_81476E0(u8 taskId, s16 *data)
+{
+    u8 i;
+    struct Sprite *sprite;
+
+    LoadCompressedSpriteSheet(&gUnknown_846B42C[data[3]]);
+    LoadSpritePalette(&gUnknown_846B43C[data[4]]);
+    for (i = 0; i < data[8]; i++)
+        data[13 + i] = CreateSprite(&gUnknown_846B494[data[2]], data[9], data[10], data[7]);
+    for (i = 0; i < data[8]; i++)
+    {
+        sprite = &gSprites[data[13 + i]];
+        sprite->oam.priority = data[6];
+        sprite->invisible = TRUE;
+        sprite->data[1] = data[5];
+        sprite->data[3] = taskId;
+        sprite->data[4] = i;
+        sprite->data[5] = data[13];
+    }
+}
+
+static void sub_81477C0(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    data[2] = 0;
+    data[3] = 0;
+    data[4] = 0;
+    data[5] = 60;
+    data[6] = 0;
+    data[7] = 0;
+    data[8] = 3;
+    data[9] = 120;
+    data[10] = 88;
+    sub_81476E0(taskId, data);
+
+    StartSpriteAnim(&gSprites[data[14]], 4);
+    gSprites[data[14]].pos2.x = -32;
+
+    StartSpriteAnim(&gSprites[data[15]], 5);
+    gSprites[data[15]].pos2.x = 32;
+}
+
+static void sub_814784C(u8 taskId)
+{
+    u8 i = 0;
+    s16 *data = gTasks[taskId].data;
+
+    for (i = 0; i < data[8]; i++)
+        DestroySprite(&gSprites[data[13 + i]]);
+    FreeSpriteTilesByTag(gUnknown_846B42C[data[3]].tag);
+    FreeSpritePaletteByTag(gUnknown_846B43C[data[4]].tag);
+}
+
+static void sub_81478BC(struct Sprite *sprite)
+{
+    s16 *data = gTasks[sprite->data[3]].data;
+
+    if (data[11] % data[5] != 0)
+        return;
+    if (data[11] == data[10])
+        return;
+
+    data[10] = data[11];
+    switch (sprite->data[2])
+    {
+    case 0:
+        sprite->invisible = FALSE;
+    case 1:
+    case 2:
+        PlaySE(SE_KON);
+        StartSpriteAnim(sprite, sprite->data[2]);
+        break;
+    case 3:
+        PlaySE(SE_PIN);
+        StartSpriteAnim(sprite, sprite->data[2]);
+        gSprites[data[14]].invisible = FALSE;
+        gSprites[data[15]].invisible = FALSE;
+        break;
+    case 4:
+        sprite->invisible = TRUE;
+        gSprites[data[14]].invisible = TRUE;
+        gSprites[data[15]].invisible = TRUE;
+        data[0] = 4;
+        return;
+    }
+    sprite->data[2]++;
+}
+
+static void sub_81479D4(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    PlaySE(SE_KON);
+    gSprites[data[13]].callback = sub_81478BC;
+    gSprites[data[13]].invisible = FALSE;
+    gTasks[taskId].data[0] = 3;
+}
+
+static void sub_8147A34(u8 taskId)
+{
+    u16 packet[6];
+    s16 *data = gTasks[taskId].data;
+
+    if (gReceivedRemoteLinkPlayers != 0)
+    {
+        if (gRecvCmds[0][1] == 0x7FFF)
+            data[11] = gRecvCmds[0][2];
+        if (GetMultiplayerId() == 0)
+        {
+            data[12]++;
+            memset(packet, 0, sizeof(packet));
+            packet[0] = 0x7FFF;
+            packet[1] = data[12];
+            RfuPrepareSend0x2f00(packet);
+        }
+    }
+    else
+    {
+        data[11]++;
+    }
+}
diff --git a/src/pokemon_jump_2.c b/src/pokemon_jump_2.c
new file mode 100644
index 000000000..aa1238e3f
--- /dev/null
+++ b/src/pokemon_jump_2.c
@@ -0,0 +1,2035 @@
+#include "global.h"
+#include "gflib.h"
+#include "event_data.h"
+#include "item.h"
+#include "link_rfu.h"
+#include "menu.h"
+#include "random.h"
+#include "save.h"
+#include "task.h"
+#include "pokemon_jump.h"
+#include "constants/songs.h"
+#include "constants/species.h"
+
+struct PokemonJump1
+{
+    MainCallback returnCallback;
+    u8 unk4;
+    u8 unk5;
+    u8 unk6;
+    u8 unk7;
+    u16 unk8;
+    u16 unkA;
+    u16 unkC;
+    u16 unkE;
+    int unk10;
+    u32 unk14;
+    u32 unk18;
+    int unk1C;
+    u32 unk20;
+    u32 unk24;
+    u32 unk28;
+    int unk2C;
+    u32 unk30;
+    u16 unk34;
+    u16 unk36;
+    u8 filler38[0x2];
+    u16 unk3A;
+    u16 unk3C;
+    u16 unk3E;
+    u16 unk40;
+    u16 unk42;
+    u8 unk44;
+    u8 unk45;
+    u8 unk46;
+    u8 isLeader;
+    u8 unk48;
+    u8 unk49;
+    u16 unk4A;
+    u8 unk4C;
+    u8 unk4D;
+    u16 unk4E;
+    u8 unk50;
+    u8 unk51;
+    u8 filler52[0x2];
+    int unk54;
+    int unk58;
+    int unk5C;
+    int unk60;
+    int unk64;
+    int unk68;
+    int unk6C;
+    struct PokemonJump1Sub unk70;
+    u8 unk7C[MAX_RFU_PLAYERS];
+    u8 unk81[MAX_RFU_PLAYERS];
+    u8 unk86[MAX_RFU_PLAYERS];
+    u8 unk8B[MAX_RFU_PLAYERS];
+    u16 unk90[MAX_RFU_PLAYERS];
+    u16 unk9A[MAX_RFU_PLAYERS];
+    struct PokemonJump2 unkA4;
+    struct PokemonJump1_MonInfo unk82A8[MAX_RFU_PLAYERS];
+    struct PokemonJump1_82E4 unk82E4[MAX_RFU_PLAYERS];
+    struct PokemonJump1_82E4 *unk83AC;
+};
+
+static void sub_8147B60(struct PokemonJump1 *);
+static void sub_8147B94(struct PokemonJump1 *);
+static void sub_8147C20(void);
+static void sub_8147C98(void);
+static s16 GetPokemonJumpSpeciesIdx(u16 species);
+static void sub_8147D2C(struct PokemonJump1_MonInfo *monInfo, struct Pokemon *mon);
+static void sub_8147D6C(void);
+static void sub_8147DA0(u8 taskId);
+static void sub_814807C(u8 taskId);
+static void sub_8148104(void);
+static void sub_8148290(u8 taskId);
+static void sub_81482F8(void);
+static bool32 sub_8148344(void);
+static bool32 sub_81483D0(void);
+static bool32 sub_8148464(void);
+static bool32 sub_81484D0(void);
+static bool32 sub_814856C(void);
+static bool32 sub_81485C8(void);
+static bool32 sub_8148664(void);
+static bool32 sub_81486C4(void);
+static bool32 sub_8148724(void);
+static bool32 sub_8148760(void);
+static bool32 sub_81487B4(void);
+static bool32 sub_8148800(void);
+static bool32 sub_814881C(void);
+static bool32 sub_81488DC(void);
+static bool32 sub_81489C8(void);
+static bool32 sub_8148A60(void);
+static bool32 sub_8148398(void);
+static bool32 sub_8148418(void);
+static bool32 sub_81484B0(void);
+static bool32 sub_8148B54(void);
+static bool32 sub_8148C80(void);
+static bool32 sub_8148D5C(void);
+static bool32 sub_8148E2C(void);
+static void sub_8148E80(u8 taskId);
+static void sub_8148F5C(TaskFunc func, u8 taskPriority);
+static void sub_8148F7C(void);
+static void sub_8148F9C(void);
+static void sub_8148FE0(void);
+static int sub_8149044(void);
+static void sub_8149078(void);
+static int sub_8149194(void);
+static void sub_81491B4(void);
+static void sub_81491E4(void);
+static void sub_8149210(void);
+static bool32 sub_814922C(u16);
+static void sub_8149260(void);
+static void sub_81492D8(void);
+static void sub_814933C(void);
+static void sub_814935C(void);
+static void sub_814936C(void);
+static void sub_814937C(void);
+static void sub_8149490(int);
+static void sub_8149534(void);
+static bool32 sub_8149630(void);
+static bool32 sub_81496D4(void);
+static bool32 sub_8149710(void);
+static bool32 sub_8149748(void);
+static void sub_8149780(int);
+static int sub_81497A8(void);
+static bool32 sub_8149804(void);
+static int sub_8149834(u8 *);
+static void sub_8149878(void);
+static int sub_8149888(int);
+static void sub_8149898(u16);
+static bool32 sub_81498B4(void);
+static u16 sub_81498D8(void);
+static void sub_8149900(u16, u16 *, u16 *);
+static u16 sub_8149910(void);
+static u16 sub_8149930(void);
+static u16 sub_8149978(u16 item, u16 quantity);
+
+EWRAM_DATA static struct PokemonJump1 *gUnknown_203F3D4 = NULL;
+
+static const struct PokemonJumpMons
+{
+    u16 species;
+    u16 unk2;
+} sPkmnJumpSpecies[] =
+{
+    { .species = SPECIES_BULBASAUR,  .unk2 = 2, },
+    { .species = SPECIES_CHARMANDER, .unk2 = 1, },
+    { .species = SPECIES_SQUIRTLE,   .unk2 = 0, },
+    { .species = SPECIES_CATERPIE,   .unk2 = 1, },
+    { .species = SPECIES_METAPOD,    .unk2 = 1, },
+    { .species = SPECIES_WEEDLE,     .unk2 = 1, },
+    { .species = SPECIES_KAKUNA,     .unk2 = 1, },
+    { .species = SPECIES_RATTATA,    .unk2 = 1, },
+    { .species = SPECIES_RATICATE,   .unk2 = 1, },
+    { .species = SPECIES_PIKACHU,    .unk2 = 0, },
+    { .species = SPECIES_SANDSHREW,  .unk2 = 0, },
+    { .species = SPECIES_NIDORAN_F,  .unk2 = 0, },
+    { .species = SPECIES_NIDORAN_M,  .unk2 = 0, },
+    { .species = SPECIES_CLEFAIRY,   .unk2 = 0, },
+    { .species = SPECIES_VULPIX,     .unk2 = 0, },
+    { .species = SPECIES_JIGGLYPUFF, .unk2 = 2, },
+    { .species = SPECIES_ODDISH,     .unk2 = 2, },
+    { .species = SPECIES_PARAS,      .unk2 = 1, },
+    { .species = SPECIES_MEOWTH,     .unk2 = 0, },
+    { .species = SPECIES_PSYDUCK,    .unk2 = 2, },
+    { .species = SPECIES_MANKEY,     .unk2 = 1, },
+    { .species = SPECIES_GROWLITHE,  .unk2 = 1, },
+    { .species = SPECIES_POLIWAG,    .unk2 = 2, },
+    { .species = SPECIES_BELLSPROUT, .unk2 = 2, },
+    { .species = SPECIES_SHELLDER,   .unk2 = 1, },
+    { .species = SPECIES_KRABBY,     .unk2 = 1, },
+    { .species = SPECIES_EXEGGCUTE,  .unk2 = 2, },
+    { .species = SPECIES_CUBONE,     .unk2 = 0, },
+    { .species = SPECIES_DITTO,      .unk2 = 2, },
+    { .species = SPECIES_EEVEE,      .unk2 = 0, },
+    { .species = SPECIES_OMANYTE,    .unk2 = 1, },
+    { .species = SPECIES_KABUTO,     .unk2 = 1, },
+    { .species = SPECIES_CHIKORITA,  .unk2 = 2, },
+    { .species = SPECIES_CYNDAQUIL,  .unk2 = 1, },
+    { .species = SPECIES_TOTODILE,   .unk2 = 0, },
+    { .species = SPECIES_SPINARAK,   .unk2 = 1, },
+    { .species = SPECIES_PICHU,      .unk2 = 0, },
+    { .species = SPECIES_CLEFFA,     .unk2 = 0, },
+    { .species = SPECIES_IGGLYBUFF,  .unk2 = 2, },
+    { .species = SPECIES_TOGEPI,     .unk2 = 2, },
+    { .species = SPECIES_MAREEP,     .unk2 = 0, },
+    { .species = SPECIES_BELLOSSOM,  .unk2 = 2, },
+    { .species = SPECIES_MARILL,     .unk2 = 2, },
+    { .species = SPECIES_SUNKERN,    .unk2 = 2, },
+    { .species = SPECIES_WOOPER,     .unk2 = 2, },
+    { .species = SPECIES_PINECO,     .unk2 = 2, },
+    { .species = SPECIES_SNUBBULL,   .unk2 = 0, },
+    { .species = SPECIES_SHUCKLE,    .unk2 = 2, },
+    { .species = SPECIES_TEDDIURSA,  .unk2 = 0, },
+    { .species = SPECIES_SLUGMA,     .unk2 = 2, },
+    { .species = SPECIES_SWINUB,     .unk2 = 0, },
+    { .species = SPECIES_HOUNDOUR,   .unk2 = 1, },
+    { .species = SPECIES_PHANPY,     .unk2 = 0, },
+    { .species = SPECIES_PORYGON2,   .unk2 = 0, },
+    { .species = SPECIES_TYROGUE,    .unk2 = 1, },
+    { .species = SPECIES_SMOOCHUM,   .unk2 = 2, },
+    { .species = SPECIES_ELEKID,     .unk2 = 1, },
+    { .species = SPECIES_MAGBY,      .unk2 = 1, },
+    { .species = SPECIES_LARVITAR,   .unk2 = 1, },
+    { .species = SPECIES_TREECKO,    .unk2 = 1, },
+    { .species = SPECIES_TORCHIC,    .unk2 = 2, },
+    { .species = SPECIES_MUDKIP,     .unk2 = 0, },
+    { .species = SPECIES_MARSHTOMP,  .unk2 = 0, },
+    { .species = SPECIES_POOCHYENA,  .unk2 = 1, },
+    { .species = SPECIES_ZIGZAGOON,  .unk2 = 0, },
+    { .species = SPECIES_LINOONE,    .unk2 = 0, },
+    { .species = SPECIES_WURMPLE,    .unk2 = 1, },
+    { .species = SPECIES_SILCOON,    .unk2 = 2, },
+    { .species = SPECIES_CASCOON,    .unk2 = 2, },
+    { .species = SPECIES_LOTAD,      .unk2 = 2, },
+    { .species = SPECIES_SEEDOT,     .unk2 = 1, },
+    { .species = SPECIES_RALTS,      .unk2 = 0, },
+    { .species = SPECIES_KIRLIA,     .unk2 = 0, },
+    { .species = SPECIES_SURSKIT,    .unk2 = 2, },
+    { .species = SPECIES_SHROOMISH,  .unk2 = 2, },
+    { .species = SPECIES_NINCADA,    .unk2 = 1, },
+    { .species = SPECIES_WHISMUR,    .unk2 = 0, },
+    { .species = SPECIES_AZURILL,    .unk2 = 2, },
+    { .species = SPECIES_SKITTY,     .unk2 = 0, },
+    { .species = SPECIES_SABLEYE,    .unk2 = 0, },
+    { .species = SPECIES_MAWILE,     .unk2 = 0, },
+    { .species = SPECIES_ARON,       .unk2 = 1, },
+    { .species = SPECIES_MEDITITE,   .unk2 = 2, },
+    { .species = SPECIES_ELECTRIKE,  .unk2 = 1, },
+    { .species = SPECIES_PLUSLE,     .unk2 = 1, },
+    { .species = SPECIES_MINUN,      .unk2 = 1, },
+    { .species = SPECIES_VOLBEAT,    .unk2 = 0, },
+    { .species = SPECIES_ILLUMISE,   .unk2 = 0, },
+    { .species = SPECIES_ROSELIA,    .unk2 = 2, },
+    { .species = SPECIES_GULPIN,     .unk2 = 2, },
+    { .species = SPECIES_NUMEL,      .unk2 = 2, },
+    { .species = SPECIES_TORKOAL,    .unk2 = 2, },
+    { .species = SPECIES_SPOINK,     .unk2 = 0, },
+    { .species = SPECIES_TRAPINCH,   .unk2 = 2, },
+    { .species = SPECIES_CACNEA,     .unk2 = 2, },
+    { .species = SPECIES_ANORITH,    .unk2 = 1, },
+    { .species = SPECIES_WYNAUT,     .unk2 = 0, },
+    { .species = SPECIES_SNORUNT,    .unk2 = 0, },
+    { .species = SPECIES_CLAMPERL,   .unk2 = 1, },
+    { .species = SPECIES_BAGON,      .unk2 = 1, },
+};
+
+void StartPokemonJump(u16 partyIndex, MainCallback callback)
+{
+    u8 taskId;
+
+    if (gReceivedRemoteLinkPlayers)
+    {
+        gUnknown_203F3D4 = Alloc(sizeof(*gUnknown_203F3D4));
+        if (gUnknown_203F3D4 != NULL)
+        {
+            ResetTasks();
+            taskId = CreateTask(sub_8147DA0, 1);
+            gUnknown_203F3D4->unk8 = 0;
+            gUnknown_203F3D4->returnCallback = callback;
+            gUnknown_203F3D4->unk4 = taskId;
+            gUnknown_203F3D4->unk6 = GetMultiplayerId();
+            sub_8147D2C(&gUnknown_203F3D4->unk82A8[gUnknown_203F3D4->unk6], &gPlayerParty[partyIndex]);
+            sub_8147B60(gUnknown_203F3D4);
+            SetWordTaskArg(taskId, 2, (uintptr_t)gUnknown_203F3D4);
+            SetMainCallback2(sub_8147D6C);
+            return;
+        }
+    }
+
+    SetMainCallback2(callback);
+}
+
+static void sub_8147B48(void)
+{
+    sub_8149D24();
+    Free(gUnknown_203F3D4);
+}
+
+static void sub_8147B60(struct PokemonJump1 *arg0)
+{
+    arg0->unk5 = GetLinkPlayerCount();
+    arg0->unk70.unk0 = 5;
+    arg0->unk70.unk2 = 0;
+    sub_8147C20();
+    sub_8147B94(arg0);
+    if (arg0->unk5 == MAX_RFU_PLAYERS)
+        sub_814B4E8();
+}
+
+static void sub_8147B94(struct PokemonJump1 *arg0)
+{
+    int i;
+
+    arg0->unk14 = 6;
+    arg0->unk18 = 6;
+    arg0->unk4A = 0;
+    arg0->unk1C = 0;
+    arg0->unk5C = 0;
+    arg0->isLeader = GetMultiplayerId() == 0;
+    arg0->unk8 = 0;
+    arg0->unkA = 0;
+    arg0->unkC = 0;
+    arg0->unkE = 0;
+    arg0->unk58 = 0;
+    arg0->unk3A = 0;
+    arg0->unk44 = 0;
+    arg0->unk54 = 0;
+    arg0->unk46 = 0;
+    arg0->unk49 = 0;
+    arg0->unk48 = 1;
+    arg0->unk70.unk8 = 0;
+    arg0->unk70.unk1 = 0;
+    arg0->unk70.unk4 = 0;
+    arg0->unk60 = 1;
+    arg0->unk4D = 0;
+    arg0->unk68 = 0;
+    arg0->unk64 = 0;
+    arg0->unk2C = 0;
+    arg0->unk30 = 0;
+    sub_8147C98();
+    sub_81491E4();
+
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        arg0->unk7C[i] = 0;
+        arg0->unk9A[i] = 0;
+    }
+}
+
+static void sub_8147C20(void)
+{
+    int i, index;
+
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        index = GetPokemonJumpSpeciesIdx(gUnknown_203F3D4->unk82A8[i].species);
+        gUnknown_203F3D4->unk82E4[i].unkC = sPkmnJumpSpecies[index].unk2;
+    }
+
+    gUnknown_203F3D4->unk83AC = &gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6];
+}
+
+static void sub_8147C98(void)
+{
+    int i;
+
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        gUnknown_203F3D4->unk82E4[i].unkE = 0;
+        gUnknown_203F3D4->unk82E4[i].unk10 = 0;
+        gUnknown_203F3D4->unk82E4[i].unk12 = 0;
+        gUnknown_203F3D4->unk82E4[i].unk0 = 0;
+        gUnknown_203F3D4->unk82E4[i].unk4 = 0x7FFFFFFF;
+        gUnknown_203F3D4->unk82E4[i].unk14 = 0;
+        gUnknown_203F3D4->unk8B[i] = 9;
+    }
+}
+
+static s16 GetPokemonJumpSpeciesIdx(u16 species)
+{
+    u32 i;
+    for (i = 0; i < NELEMS(sPkmnJumpSpecies); i++)
+    {
+        if (sPkmnJumpSpecies[i].species == species)
+            return i;
+    }
+
+    return -1; // species isnt allowed
+}
+
+static void sub_8147D2C(struct PokemonJump1_MonInfo *monInfo, struct Pokemon *mon)
+{
+    monInfo->species = GetMonData(mon, MON_DATA_SPECIES);
+    monInfo->otId = GetMonData(mon, MON_DATA_OT_ID);
+    monInfo->personality = GetMonData(mon, MON_DATA_PERSONALITY);
+}
+
+static void sub_8147D58(void)
+{
+    TransferPlttBuffer();
+    LoadOam();
+    ProcessSpriteCopyRequests();
+}
+
+static void sub_8147D6C(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void sub_8147D84(TaskFunc func)
+{
+    gUnknown_203F3D4->unk4 = CreateTask(func, 1);
+    gUnknown_203F3D4->unk8 = 0;
+}
+
+static void sub_8147DA0(u8 taskId)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        SetVBlankCallback(NULL);
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        sub_8148F5C(sub_8148E80, 5);
+        FadeOutMapMusic(4);
+        gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (!FuncIsActiveTask(sub_8148E80))
+        {
+            sub_8149CEC(&gUnknown_203F3D4->unkA4);
+            LoadWirelessStatusIndicatorSpriteGfx();
+            CreateWirelessStatusIndicatorSprite(0, 0);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 2:
+        if (!sub_8149D68() && IsNotWaitingForBGMStop() == TRUE)
+        {
+            FadeOutAndPlayNewMapMusic(MUS_JUMP, 8);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 3:
+        if (IsLinkTaskFinished())
+        {
+            BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+            BeginNormalPaletteFade(0xFFFFFFFF, -1, 16, 0, RGB_BLACK);
+            SetVBlankCallback(sub_8147D58);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 4:
+        UpdatePaletteFade();
+        if (!gPaletteFade.active)
+        {
+            gUnknown_203F3D4->unk7 = 0;
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 5:
+        gUnknown_203F3D4->unk7++;
+        if (gUnknown_203F3D4->unk7 >= 20)
+        {
+            if (gUnknown_203F3D4->isLeader)
+                sub_8147D84(sub_814807C);
+            else
+                sub_8147D84(sub_8148290);
+
+            sub_8148F7C();
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+static void sub_8147F10(int arg0)
+{
+    if (arg0 == 0)
+    {
+        gUnknown_203F3D4->unk30 = 0x1111;
+        gUnknown_203F3D4->unk2C = 1;
+    }
+    else
+    {
+        gUnknown_203F3D4->unk30 = (1 << (arg0 - 1)) - 1;
+        gUnknown_203F3D4->unk2C = 0;
+    }
+}
+
+static void sub_8147F4C(u8 arg0)
+{
+    int i;
+
+    gUnknown_203F3D4->unk70.unk0 = arg0;
+    gUnknown_203F3D4->unk8 = 0;
+    gUnknown_203F3D4->unkA = 0;
+    gUnknown_203F3D4->unk48 = 1;
+    gUnknown_203F3D4->unk49 = 0;
+    for (i = 1; i < gUnknown_203F3D4->unk5; i++)
+        gUnknown_203F3D4->unk82E4[i].unk18 = 0;
+}
+
+static void sub_8147FA0(void)
+{
+    int i;
+    int count;
+    u16 var0;
+    u8 var1;
+    u16 var2;
+
+    for (i = 1, count = 0; i < gUnknown_203F3D4->unk5; i++)
+    {
+        var0 = gUnknown_203F3D4->unk82E4[i].unk10;
+        if (sub_8149C24(&gUnknown_203F3D4->unk82E4[i], i, &var1, &var2))
+        {
+            gUnknown_203F3D4->unk90[i] = var2;
+            gUnknown_203F3D4->unk8B[i] = var1;
+            gUnknown_203F3D4->unk82E4[i].unk12 = var0;
+        }
+
+        if (gUnknown_203F3D4->unk82E4[i].unk18 && gUnknown_203F3D4->unk8B[i] == gUnknown_203F3D4->unk70.unk0)
+            count++;
+    }
+
+    if (count == gUnknown_203F3D4->unk5 - 1)
+        gUnknown_203F3D4->unk49 = 1;
+}
+
+static bool32 (* const gUnknown_846B64C[])(void) =
+{
+    sub_8148344,
+    sub_81483D0,
+    sub_8148464,
+    sub_81484D0,
+    sub_81485C8,
+    sub_81486C4,
+    sub_8148760,
+    sub_81487B4,
+    sub_814881C,
+};
+
+static void sub_814807C(u8 taskId)
+{
+    sub_8147FA0();
+    sub_8149534();
+    if (!gUnknown_203F3D4->unk48 && gUnknown_203F3D4->unk49)
+    {
+        sub_8147F4C(gUnknown_203F3D4->unk4C);
+        sub_8147F10(3);
+    }
+
+    if (gUnknown_203F3D4->unk48 == 1)
+    {
+        if (!gUnknown_846B64C[gUnknown_203F3D4->unk70.unk0]())
+        {
+            gUnknown_203F3D4->unk48 = 0;
+            gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6].unk18 = 1;
+        }
+    }
+
+    sub_81492D8();
+    sub_8148104();
+}
+
+static void sub_8148104(void)
+{
+    if (!gUnknown_203F3D4->unk2C)
+        sub_8149AF8(gUnknown_203F3D4->unk82E4, &gUnknown_203F3D4->unk70);
+
+    if (gUnknown_203F3D4->unk30 != 0x1111)
+    {
+        gUnknown_203F3D4->unk2C++;
+        gUnknown_203F3D4->unk2C &= gUnknown_203F3D4->unk30;
+    }
+}
+
+static void sub_8148140(u8 arg0)
+{
+    gUnknown_203F3D4->unk70.unk0 = arg0;
+    gUnknown_203F3D4->unk8 = 0;
+    gUnknown_203F3D4->unkA = 0;
+    gUnknown_203F3D4->unk48 = 1;
+    gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6].unk18 = 0;
+}
+
+static void sub_8148174(void)
+{
+    int i;
+    u16 var0;
+    struct PokemonJump1Sub sp0;
+
+    var0 = gUnknown_203F3D4->unk82E4[0].unk10;
+    if (sub_8149B7C(gUnknown_203F3D4->unk82E4, &sp0))
+    {
+        if (gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6].unk18 == 1
+         && sp0.unk0 != gUnknown_203F3D4->unk70.unk0)
+        {
+            sub_8148140(sp0.unk0);
+        }
+
+        if (gUnknown_203F3D4->unk70.unk8 != sp0.unk8)
+        {
+            gUnknown_203F3D4->unk70.unk8 = sp0.unk8;
+            gUnknown_203F3D4->unk5C = 1;
+            gUnknown_203F3D4->unk70.unk1 = sp0.unk1;
+            if (gUnknown_203F3D4->unk70.unk1)
+                gUnknown_203F3D4->unk4D = 1;
+            else
+                gUnknown_203F3D4->unk4D = 0;
+        }
+
+        gUnknown_203F3D4->unk70.unk2 = sp0.unk2;
+        gUnknown_203F3D4->unk70.unk4 = sp0.unk4;
+        gUnknown_203F3D4->unk82E4[0].unk12 = var0;
+    }
+
+    for (i = 1; i < gUnknown_203F3D4->unk5; i++)
+    {
+        if (i != gUnknown_203F3D4->unk6)
+        {
+            var0 = gUnknown_203F3D4->unk82E4[i].unk10;
+            if (sub_8149C90(&gUnknown_203F3D4->unk82E4[i], i))
+                gUnknown_203F3D4->unk82E4[i].unk12 = var0;
+        }
+    }
+}
+
+static bool32 (* const gUnknown_846B670[])(void) =
+{
+    sub_8148398,
+    sub_8148418,
+    sub_81484B0,
+    sub_814856C,
+    sub_8148664,
+    sub_8148724,
+    sub_8148760,
+    sub_8148800,
+    sub_814881C,
+};
+
+static void sub_8148290(u8 taskId)
+{
+    sub_8148174();
+    if (gUnknown_203F3D4->unk48)
+    {
+        if (!gUnknown_846B670[gUnknown_203F3D4->unk70.unk0]())
+        {
+            gUnknown_203F3D4->unk48 = 0;
+            gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6].unk18 = 1;
+            sub_8147F10(3);
+        }
+    }
+
+    sub_81492D8();
+    sub_81482F8();
+}
+
+static void sub_81482F8(void)
+{
+    if (!gUnknown_203F3D4->unk2C)
+        sub_8149BF4(&gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6], gUnknown_203F3D4->unk70.unk0, gUnknown_203F3D4->unk42);
+
+    if (gUnknown_203F3D4->unk30 != 0x1111)
+    {
+        gUnknown_203F3D4->unk2C++;
+        gUnknown_203F3D4->unk2C &= gUnknown_203F3D4->unk30;
+    }
+}
+
+static bool32 sub_8148344(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8147F10(3);
+        gUnknown_203F3D4->unk8++;
+        // fall through
+    case 1:
+        if (!sub_81488DC())
+        {
+            gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unk4A;
+            gUnknown_203F3D4->unk4C = 1;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148398(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8147F10(0);
+        gUnknown_203F3D4->unk24 = gUnknown_203F3D4->unk70.unk2;
+        gUnknown_203F3D4->unk8++;
+        // fall through
+    case 1:
+        return sub_81488DC();
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81483D0(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_81491E4();
+        sub_8147F10(5);
+        gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (gUnknown_203F3D4->unk49)
+        {
+            gUnknown_203F3D4->unk4C = 2;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148418(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_81491E4();
+        sub_8147F10(0);
+        gUnknown_203F3D4->unk4A = gUnknown_203F3D4->unk70.unk2;
+        gUnknown_203F3D4->unk8++;
+        // fall through
+    case 1:
+        if (sub_8149804())
+            return FALSE;
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148464(void)
+{
+    if (!sub_81489C8())
+    {
+        gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unk4A;
+        gUnknown_203F3D4->unk4C = 1;
+    }
+    else if (sub_8149630())
+    {
+        return TRUE;
+    }
+    else
+    {
+        sub_81491B4();
+        gUnknown_203F3D4->unk4C = 3;
+    }
+
+    return FALSE;
+}
+
+static bool32 sub_81484B0(void)
+{
+    if (!sub_81489C8())
+        ;
+    else if (sub_8149630())
+        return TRUE;
+    else
+        sub_81491B4();
+
+    return FALSE;
+}
+
+static bool32 sub_81484D0(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8149630();
+        if (sub_81496D4())
+            gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (!sub_8148A60())
+        {
+            if (sub_81498B4())
+            {
+                gUnknown_203F3D4->unk70.unk2 = sub_81498D8();
+                gUnknown_203F3D4->unk4C = 7;
+            }
+            else if (gUnknown_203F3D4->unk70.unk4 >= 200)
+            {
+                gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unkE;
+                gUnknown_203F3D4->unk4C = 8;
+            }
+            else
+            {
+                gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unkE;
+                gUnknown_203F3D4->unk4C = 4;
+            }
+
+            gUnknown_203F3D4->unk8++;
+            return FALSE;
+        }
+        break;
+    case 2:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_814856C(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        if (!sub_8149630())
+            sub_81491B4();
+        if (sub_81496D4())
+            gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (!sub_8148A60())
+        {
+            gUnknown_203F3D4->unk8++;
+            return FALSE;
+        }
+        break;
+    case 2:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81485C8(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8147F10(4);
+        gUnknown_203F3D4->unk8++;
+        // fall through
+    case 1:
+        if (!sub_8148C80())
+        {
+            sub_814B494(gUnknown_203F3D4->unk70.unk8, gUnknown_203F3D4->unk70.unk4, gUnknown_203F3D4->unk70.unk2);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 2:
+        if (gUnknown_203F3D4->unk49)
+        {
+            if (sub_8149748())
+                gUnknown_203F3D4->unk4C = 5;
+            else
+                gUnknown_203F3D4->unk4C = 6;
+
+            gUnknown_203F3D4->unk8++;
+            return FALSE;
+        }
+        break;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148664(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8147F10(0);
+        gUnknown_203F3D4->unk8++;
+        // fall through
+    case 1:
+        if (!sub_8148C80())
+        {
+            sub_814B494(gUnknown_203F3D4->unk70.unk8, gUnknown_203F3D4->unk70.unk4, gUnknown_203F3D4->unk70.unk2);
+            gUnknown_203F3D4->unk42 = gUnknown_203F3D4->unk45;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81486C4(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        if (!sub_8148E2C())
+            gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (gUnknown_203F3D4->unk49)
+        {
+            sub_8147B94(gUnknown_203F3D4);
+            gUnknown_203F3D4->unk24 = Random();
+            gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unk24;
+            gUnknown_203F3D4->unk4C = 0;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148724(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        if (!sub_8148E2C())
+        {
+            sub_8147B94(gUnknown_203F3D4);
+            gUnknown_203F3D4->unk8++;
+            return FALSE;
+        }
+        break;
+    case 1:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148760(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        gUnknown_203F3D4->unk8 = 1;
+        break;
+    case 1:
+        sub_8147F10(0);
+        gUnknown_203F3D4->unk8++;
+        break;
+    case 2:
+        if (!sub_8148D5C())
+        {
+            SetMainCallback2(gUnknown_203F3D4->returnCallback);
+            sub_8147B48();
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81487B4(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_8147F10(4);
+        gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (!sub_8148B54())
+        {
+            gUnknown_203F3D4->unk70.unk2 = gUnknown_203F3D4->unkE;
+            gUnknown_203F3D4->unk4C = 8;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148800(void)
+{
+    sub_8147F10(0);
+    if (!sub_8148B54())
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static bool32 sub_814881C(void)
+{
+    switch (gUnknown_203F3D4->unk8)
+    {
+    case 0:
+        sub_814B494(gUnknown_203F3D4->unk70.unk8, gUnknown_203F3D4->unk70.unk4, gUnknown_203F3D4->unk70.unk2);
+        sub_8149D40(5);
+        gUnknown_203F3D4->unk8++;
+        break;
+    case 1:
+        if (!sub_8149D68())
+        {
+            sub_8147F10(0);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 2:
+        if (sub_8149804())
+        {
+            CreateTask(sub_80DA634, 6);
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 3:
+        if (!FuncIsActiveTask(sub_80DA634))
+        {
+            sub_814A6CC();
+            gUnknown_203F3D4->unk8++;
+        }
+        break;
+    case 4:
+        if (!sub_814A6FC())
+        {
+            gUnknown_203F3D4->unk4C = 4;
+            return FALSE;
+        }
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81488DC(void)
+{
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        sub_8149D40(2);
+        sub_814AAA0();
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+        if (!sub_8149D68())
+        {
+            sub_814AAB4(gUnknown_203F3D4->unk6);
+            gUnknown_203F3D4->unk3C = 0;
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 2:
+        if (++gUnknown_203F3D4->unk3C > 120)
+        {
+            sub_8149D40(3);
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 3:
+        if (sub_8149D68() != 1 && sub_814AAC8() != 1)
+            gUnknown_203F3D4->unkA++;
+        break;
+    case 4:
+        sub_8149D40(9);
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 5:
+        if (!sub_8149D68())
+        {
+            sub_814935C();
+            sub_814A3E4();
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 6:
+        if (!sub_814A408())
+        {
+            sub_814936C();
+            sub_8148F9C();
+            gUnknown_203F3D4->unkA++;
+            return FALSE;
+        }
+        break;
+    case 7:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81489C8(void)
+{
+    sub_8148FE0();
+    if (gUnknown_203F3D4->unk36)
+    {
+        gUnknown_203F3D4->unk36 = 0;
+        return FALSE;
+    }
+
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        if (sub_814922C(0))
+            gUnknown_203F3D4->unkA++;
+        else
+            break;
+        // fall through
+    case 1:
+        if (gMain.newKeys & A_BUTTON)
+        {
+            sub_8149260();
+            sub_8147F10(3);
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 2:
+        if (sub_814922C(1) == TRUE)
+            gUnknown_203F3D4->unkA++;
+        break;
+    case 3:
+        if (sub_814922C(0) == TRUE)
+            gUnknown_203F3D4->unkA = 0;
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148A60(void)
+{
+    int i;
+
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        for (i = 0; i < gUnknown_203F3D4->unk5; i++)
+        {
+            if (sub_814AA78(i) == 1)
+                return TRUE;
+        }
+
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+        for (i = 0; i < gUnknown_203F3D4->unk5; i++)
+        {
+            if (gUnknown_203F3D4->unk82E4[i].unk10 == 2)
+                sub_814AA60(i);
+        }
+
+        sub_8149D40(1);
+        gUnknown_203F3D4->unk3C = 0;
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 2:
+        if (++gUnknown_203F3D4->unk3C > 100)
+        {
+            sub_8149D40(3);
+            gUnknown_203F3D4->unk3C = 0;
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 3:
+        if (!sub_8149D68())
+        {
+            sub_814AA8C();
+            gUnknown_203F3D4->unk70.unk1 = 0;
+            sub_8149210();
+            gUnknown_203F3D4->unkA++;
+            return FALSE;
+        }
+        break;
+    case 4:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148B54(void)
+{
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        sub_8149900(gUnknown_203F3D4->unk70.unk2, &gUnknown_203F3D4->unk3E, &gUnknown_203F3D4->unk40);
+        sub_814A468(gUnknown_203F3D4->unk3E, gUnknown_203F3D4->unk40);
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+    case 4:
+        if (!sub_814A62C())
+        {
+            gUnknown_203F3D4->unk3C = 0;
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 2:
+    case 5:
+        gUnknown_203F3D4->unk3C++;
+        if (gMain.newKeys & (A_BUTTON | B_BUTTON) || gUnknown_203F3D4->unk3C > 180)
+        {
+            sub_814A6CC();
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 3:
+        if (!sub_814A6FC())
+        {
+            gUnknown_203F3D4->unk40 = sub_8149978(gUnknown_203F3D4->unk3E, gUnknown_203F3D4->unk40);
+            if (gUnknown_203F3D4->unk40 && AddBagItem(gUnknown_203F3D4->unk3E, gUnknown_203F3D4->unk40))
+            {
+                if (!CheckBagHasSpace(gUnknown_203F3D4->unk3E, 1))
+                {
+                    sub_814A53C(gUnknown_203F3D4->unk3E);
+                    gUnknown_203F3D4->unkA = 4;
+                }
+                else
+                {
+                    gUnknown_203F3D4->unkA = 6;
+                    break;
+                }
+            }
+            else
+            {
+                sub_814A5B4(gUnknown_203F3D4->unk3E);
+                gUnknown_203F3D4->unkA = 4;
+            }
+        }
+        break;
+    case 6:
+        if (!sub_814A6FC())
+            return FALSE;
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148C80(void)
+{
+    s8 input;
+
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        sub_8149D40(4);
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+        if (!sub_8149D68())
+            gUnknown_203F3D4->unkA++;
+        break;
+    case 2:
+        input = sub_814A744();
+        switch (input)
+        {
+        case MENU_B_PRESSED:
+        case 1:
+            gUnknown_203F3D4->unk45 = 1;
+            sub_8149D40(6);
+            gUnknown_203F3D4->unkA++;
+            break;
+        case 0:
+            gUnknown_203F3D4->unk45 = 2;
+            sub_8149D40(6);
+            gUnknown_203F3D4->unkA++;
+            break;
+        }
+        break;
+    case 3:
+        if (!sub_8149D68())
+            gUnknown_203F3D4->unkA++;
+        break;
+    case 4:
+        sub_8149D40(8);
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 5:
+        if (!sub_8149D68())
+        {
+            gUnknown_203F3D4->unkA++;
+            return FALSE;
+        }
+        break;
+    case 6:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148D5C(void)
+{
+    int var0;
+
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        sub_814A6CC();
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+        if (!sub_814A6FC())
+        {
+            sub_8149D40(7);
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 2:
+        var0 = sub_8149D68();
+        if (!var0)
+        {
+            gUnknown_203F3D4->unk3C = var0;
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 3:
+        if (++gUnknown_203F3D4->unk3C > 120)
+        {
+            BeginNormalPaletteFade(0xFFFFFFFF, -1, 0, 16, RGB_BLACK);
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 4:
+        if (!gPaletteFade.active)
+        {
+            Link_TryStartSend5FFF();
+            gUnknown_203F3D4->unkA++;
+        }
+        break;
+    case 5:
+        if (!gReceivedRemoteLinkPlayers)
+            return FALSE;
+        break;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8148E2C(void)
+{
+    switch (gUnknown_203F3D4->unkA)
+    {
+    case 0:
+        sub_814A6CC();
+        sub_814AA24(0);
+        gUnknown_203F3D4->unkA++;
+        break;
+    case 1:
+        if (!sub_814A6FC())
+        {
+            gUnknown_203F3D4->unkA++;
+            return FALSE;
+        }
+        break;
+    case 2:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void sub_8148E80(u8 taskId)
+{
+    int i;
+    s16 *taskData = gTasks[taskId].data;
+    struct PokemonJump1 *ptr = (struct PokemonJump1 *)GetWordTaskArg(taskId, 14);
+
+    switch (taskData[0])
+    {
+    case 0:
+        for (i = 0; i < MAX_RFU_PLAYERS; i++)
+            taskData[i + 2] = 0;
+
+        taskData[0]++;
+        // fall through
+    case 1:
+        sub_8149A6C(&ptr->unk82A8[ptr->unk6]);
+        for (i = 0; i < MAX_RFU_PLAYERS; i++)
+        {
+            if (!taskData[i + 2] && sub_8149A90(i, &ptr->unk82A8[i]))
+            {
+                StringCopy(ptr->unk82E4[i].unk1C, gLinkPlayers[i].name);
+                taskData[i + 2] = 1;
+                taskData[1]++;
+                if (taskData[1] == ptr->unk5)
+                {
+                    sub_8147C20();
+                    DestroyTask(taskId);
+                    break;
+                }
+            }
+        }
+        break;
+    }
+}
+
+static void sub_8148F5C(TaskFunc func, u8 taskPriority)
+{
+    u8 taskId = CreateTask(func, taskPriority);
+    SetWordTaskArg(taskId, 14, (uintptr_t)gUnknown_203F3D4);
+}
+
+static void sub_8148F7C(void)
+{
+    gUnknown_203F3D4->unk4A = 0;
+    gUnknown_203F3D4->unk14 = 6;
+    gUnknown_203F3D4->unk34 = 0;
+    gUnknown_203F3D4->unk1C = 0;
+    gUnknown_203F3D4->unk36 = 0;
+    gUnknown_203F3D4->unk10 = 0;
+}
+
+static void sub_8148F9C(void)
+{
+    gUnknown_203F3D4->unk4A = 0;
+    gUnknown_203F3D4->unk34 = 0x6FF;
+    gUnknown_203F3D4->unk14 = 7;
+    gUnknown_203F3D4->unk36 = 0;
+    gUnknown_203F3D4->unk10 = 0;
+    gUnknown_203F3D4->unk51 = 0;
+    gUnknown_203F3D4->unk50 = 0;
+    gUnknown_203F3D4->unk20 = 0;
+    gUnknown_203F3D4->unk4E = 0;
+    gUnknown_203F3D4->unk6C = 0;
+    sub_8149078();
+}
+
+static void sub_8148FE0(void)
+{
+    if (gUnknown_203F3D4->unk46)
+    {
+        gUnknown_203F3D4->unk4A++;
+        gUnknown_203F3D4->unk34 += sub_8149044();
+        if (gUnknown_203F3D4->unk34 >= 0x9FF)
+            gUnknown_203F3D4->unk34 -= 0x9FF;
+
+        gUnknown_203F3D4->unk18 = gUnknown_203F3D4->unk14;
+        gUnknown_203F3D4->unk14 = gUnknown_203F3D4->unk34 >> 8;
+        if (gUnknown_203F3D4->unk14 > 6 && gUnknown_203F3D4->unk18 < 7)
+        {
+            gUnknown_203F3D4->unk36++;
+            sub_8149078();
+        }
+    }
+}
+
+static int sub_8149044(void)
+{
+    int result;
+
+    if (gUnknown_203F3D4->unk10)
+        return 0;
+
+    result = gUnknown_203F3D4->unk1C;
+    if (gUnknown_203F3D4->unk34 <= 0x5FF)
+    {
+        gUnknown_203F3D4->unk20 += 80;
+        result += gUnknown_203F3D4->unk20 >> 8;
+    }
+
+    return result;
+}
+
+static const u16 gUnknown_846B694[] = {0x1a, 0x1f, 0x24, 0x29, 0x2e, 0x33, 0x38, 0x3d};
+static const u16 gUnknown_846B6A4[] = {0, 1, 1, 2};
+
+static void sub_8149078(void)
+{
+    int var0;
+
+    gUnknown_203F3D4->unk20 = 0;
+    if (gUnknown_203F3D4->unk4E)
+    {
+        gUnknown_203F3D4->unk4E--;
+        if (gUnknown_203F3D4->unk6C)
+        {
+            if (sub_8149194() % 4 != 0)
+            {
+                gUnknown_203F3D4->unk1C = gUnknown_203F3D4->unk28;
+            }
+            else
+            {
+                if (gUnknown_203F3D4->unk28 > 54)
+                    gUnknown_203F3D4->unk1C = 30;
+                else
+                    gUnknown_203F3D4->unk1C = 82;
+            }
+        }
+    }
+    else
+    {
+        if (!(gUnknown_203F3D4->unk50 & 8))
+        {
+            gUnknown_203F3D4->unk28 = gUnknown_846B694[gUnknown_203F3D4->unk50] + (gUnknown_203F3D4->unk51 * 7);
+            gUnknown_203F3D4->unk4E = gUnknown_846B6A4[sub_8149194() % NELEMS(gUnknown_846B6A4)] + 2;
+            gUnknown_203F3D4->unk50++;
+        }
+        else
+        {
+            if (gUnknown_203F3D4->unk50 == 8)
+            {
+                if (gUnknown_203F3D4->unk51 < 3)
+                    gUnknown_203F3D4->unk51++;
+                else
+                    gUnknown_203F3D4->unk6C = 1;
+            }
+
+            var0 = gUnknown_846B694[15 - gUnknown_203F3D4->unk50];
+            gUnknown_203F3D4->unk28 = var0 + (gUnknown_203F3D4->unk51 * 7);
+            if (++gUnknown_203F3D4->unk50 > 15)
+            {
+                if (sub_8149194() % 4 == 0)
+                    gUnknown_203F3D4->unk28 -= 5;
+
+                gUnknown_203F3D4->unk50 = 0;
+            }
+        }
+
+        gUnknown_203F3D4->unk1C = gUnknown_203F3D4->unk28;
+    }
+}
+
+static int sub_8149194(void)
+{
+    // The number 1103515245 comes from the example implementation of rand and srand
+    gUnknown_203F3D4->unk24 = gUnknown_203F3D4->unk24 * 1103515245 + 24691;
+    return gUnknown_203F3D4->unk24 >> 16;
+}
+
+static void sub_81491B4(void)
+{
+    gUnknown_203F3D4->unk10 = 1;
+    gUnknown_203F3D4->unk14 = 6;
+    gUnknown_203F3D4->unk34 = 0x5FF;
+    sub_814936C();
+}
+
+static int sub_81491D8(void)
+{
+    return gUnknown_203F3D4->unk10;
+}
+
+static void sub_81491E4(void)
+{
+    int i;
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+        gUnknown_203F3D4->unk82E4[i].unk14 = 0;
+}
+
+static void sub_8149210(void)
+{
+    gUnknown_203F3D4->unk83AC->unk10 = 0;
+    gUnknown_203F3D4->unk83AC->unk12 = 0;
+}
+
+static bool32 sub_814922C(u16 arg0)
+{
+    if (gUnknown_203F3D4->unk82E4[gUnknown_203F3D4->unk6].unk10 == arg0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static void sub_8149260(void)
+{
+    gUnknown_203F3D4->unk83AC->unkE = gUnknown_203F3D4->unk4A;
+    gUnknown_203F3D4->unk83AC->unk12 = gUnknown_203F3D4->unk83AC->unk10;
+    gUnknown_203F3D4->unk83AC->unk10 = 1;
+}
+
+static void sub_8149288(void)
+{
+    gUnknown_203F3D4->unk83AC->unk12 = gUnknown_203F3D4->unk83AC->unk10;
+    gUnknown_203F3D4->unk83AC->unk10 = 2;
+    gUnknown_203F3D4->unk83AC->unkE = gUnknown_203F3D4->unk4A;
+    gUnknown_203F3D4->unk83AC->unk14 = 2;
+}
+
+static void sub_81492B8(void)
+{
+    gUnknown_203F3D4->unk83AC->unk12 = gUnknown_203F3D4->unk83AC->unk10;
+    gUnknown_203F3D4->unk83AC->unk10 = 0;
+}
+
+static const u16 gUnknown_846B6AC[] = {SE_REGI, SE_REAPOKE, SE_W234, SE_EXCELLENT};
+
+static void sub_81492D8(void)
+{
+    if (gUnknown_203F3D4->unk5C)
+    {
+        sub_814AA24(gUnknown_203F3D4->unk70.unk8);
+        gUnknown_203F3D4->unk5C = 0;
+        if (gUnknown_203F3D4->unk4D)
+        {
+            int index = sub_814A98C(gUnknown_203F3D4->unk70.unk1);
+            PlaySE(gUnknown_846B6AC[index - 2]);
+            gUnknown_203F3D4->unk4D = 0;
+        }
+    }
+
+    sub_814AA34(gUnknown_203F3D4->unk70.unk4);
+    sub_814937C();
+    sub_814933C();
+}
+
+static void sub_814933C(void)
+{
+    if (gUnknown_203F3D4->unk46)
+        sub_814A95C(gUnknown_203F3D4->unk14);
+}
+
+static void sub_814935C(void)
+{
+    gUnknown_203F3D4->unk46 = 0;
+}
+
+static void sub_814936C(void)
+{
+    gUnknown_203F3D4->unk46 = 1;
+}
+
+static void sub_814937C(void)
+{
+    int i;
+    int whichSound = 0;
+    int numLinkPlayers = gUnknown_203F3D4->unk5;
+
+    for (i = 0; i < numLinkPlayers; i++)
+    {
+        switch (gUnknown_203F3D4->unk82E4[i].unk10)
+        {
+        case 0:
+            sub_814A940(i, 0);
+            break;
+        case 1:
+            if (gUnknown_203F3D4->unk82E4[i].unk12 != 1 || gUnknown_203F3D4->unk82E4[i].unkE != gUnknown_203F3D4->unk9A[i])
+            {
+                if (i == gUnknown_203F3D4->unk6)
+                    gUnknown_203F3D4->unk82E4[i].unk12 = 1;
+
+                whichSound |= 0x1;
+                gUnknown_203F3D4->unk82E4[i].unk4 = 0x7FFFFFFF;
+                gUnknown_203F3D4->unk9A[i] = gUnknown_203F3D4->unk82E4[i].unkE;
+            }
+
+            sub_8149490(i);
+            break;
+        case 2:
+            if (gUnknown_203F3D4->unk82E4[i].unk12 != 2)
+            {
+                if (i == gUnknown_203F3D4->unk6)
+                    gUnknown_203F3D4->unk82E4[i].unk12 = 2;
+
+                whichSound |= 0x2;
+                sub_814AA48(i);
+            }
+            break;
+        }
+    }
+
+    if (whichSound & 0x2)
+        PlaySE(SE_NAWAMISS);
+    else if (whichSound & 0x1)
+        PlaySE(SE_DANSA);
+}
+
+static const s8 gUnknown_846B6B4[][48] =
+{
+    {-3, -6, -8, -10, -13, -15, -17, -19, -21, -23, -25, -27, -28, -29, -30, -30, -30, -28, -27,
+    -26, -25, -23, -22, -20, -18, -17, -15, -13, -11, -8, -6, -4, -1},
+
+    {-3, -6, -9, -11, -14, -16, -18, -20, -22, -24, -26, -28, -29, -30, -30, -28, -26, -24, -22,
+    -20, -18, -16, -14, -11, -9, -6, -4, -1},
+
+    {-3, -6, -9, -11, -13, -15, -17, -19, -21, -23, -25, -27, -28, -29, -30, -30, -30, -30, -29,
+    -29, -28, -28, -27, -27, -26, -25, -24, -22, -20, -18, -16, -14,
+    -12, -11, -9, -6, -4, -1},
+};
+
+static void sub_8149490(int multiplayerId)
+{
+    int var0;
+    int var1;
+    struct PokemonJump1_82E4 *player;
+
+    if (gUnknown_203F3D4->unk68)
+        return;
+
+    player = &gUnknown_203F3D4->unk82E4[multiplayerId];
+    if (player->unk4 != 0x7FFFFFFF)
+    {
+        player->unk4++;
+        var0 = player->unk4;
+    }
+    else
+    {
+        var0 = gUnknown_203F3D4->unk4A - player->unkE;
+        if (var0 >= 65000)
+        {
+            var0 -= 65000;
+            var0 += gUnknown_203F3D4->unk4A;
+        }
+
+        player->unk4 = var0;
+    }
+
+    if (var0 < 4)
+        return;
+
+    var0 -= 4;
+    if (var0 < 48)
+        var1 = gUnknown_846B6B4[player->unkC][var0];
+    else
+        var1 = 0;
+
+    sub_814A940(multiplayerId, var1);
+    if (!var1 && multiplayerId == gUnknown_203F3D4->unk6)
+        sub_81492B8();
+
+    player->unk0 = var1;
+}
+
+static void sub_8149534(void)
+{
+    if (gUnknown_203F3D4->unk14 == 8 && gUnknown_203F3D4->unk18 == 7)
+    {
+        if (gUnknown_203F3D4->unk58 == 0)
+        {
+            sub_8149878();
+            gUnknown_203F3D4->unk54 = 0;
+            gUnknown_203F3D4->unk58 = 1;
+            gUnknown_203F3D4->unk70.unk1 = 0;
+        }
+        else
+        {
+            if (gUnknown_203F3D4->unk54 == 5)
+            {
+                gUnknown_203F3D4->unkC++;
+                sub_8149898(gUnknown_203F3D4->unkC);
+            }
+            else
+            {
+                gUnknown_203F3D4->unkC = 0;
+            }
+
+            if (gUnknown_203F3D4->unk54 > 1)
+            {
+                gUnknown_203F3D4->unk64 = 1;
+                memcpy(gUnknown_203F3D4->unk86, gUnknown_203F3D4->unk81, sizeof(u8) * MAX_RFU_PLAYERS);
+            }
+
+            sub_8149878();
+            gUnknown_203F3D4->unk54 = 0;
+            gUnknown_203F3D4->unk58 = 1;
+            gUnknown_203F3D4->unk70.unk1 = 0;
+            if (gUnknown_203F3D4->unk70.unk4 < 9999)
+                gUnknown_203F3D4->unk70.unk4++;
+
+            sub_8149780(10);
+            sub_8147F10(3);
+        }
+    }
+
+    if (gUnknown_203F3D4->unk64 && (sub_8149710() == TRUE || !gUnknown_203F3D4->unk14))
+    {
+        int var0 = sub_8149834(gUnknown_203F3D4->unk86);
+        sub_8149780(sub_8149888(var0));
+        sub_8147F10(3);
+        gUnknown_203F3D4->unk64 = 0;
+    }
+
+    if (gUnknown_203F3D4->unk58)
+    {
+        int var1 = sub_81497A8();
+        if (var1 > gUnknown_203F3D4->unk54)
+        {
+            gUnknown_203F3D4->unk54 = var1;
+            memcpy(gUnknown_203F3D4->unk81, gUnknown_203F3D4->unk7C, sizeof(u8) * MAX_RFU_PLAYERS);
+        }
+    }
+}
+
+static bool32 sub_8149630(void)
+{
+    int i;
+
+    if (gUnknown_203F3D4->unk14 == 6 && !gUnknown_203F3D4->unk83AC->unk0)
+    {
+        if (gUnknown_203F3D4->unk83AC->unk12 == 1 && sub_81491D8() == 1)
+        {
+            gUnknown_203F3D4->unk83AC->unk14 = 1;
+        }
+        else
+        {
+            sub_8149288();
+            sub_8147F10(3);
+        }
+    }
+
+    if (gUnknown_203F3D4->unk14 == 7
+     && gUnknown_203F3D4->unk18 == 6
+     && gUnknown_203F3D4->unk83AC->unk10 != 2)
+    {
+        gUnknown_203F3D4->unk83AC->unk14 = 1;
+        sub_8147F10(3);
+    }
+
+    for (i = 0; i < gUnknown_203F3D4->unk5; i++)
+    {
+        if (gUnknown_203F3D4->unk82E4[i].unk10 == 2)
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_81496D4(void)
+{
+    int i;
+    int numPlayers = gUnknown_203F3D4->unk5;
+    int count = 0;
+    for (i = 0; i < numPlayers; i++)
+    {
+        if (gUnknown_203F3D4->unk82E4[i].unk14)
+            count++;
+    }
+
+    return count == numPlayers;
+}
+
+static bool32 sub_8149710(void)
+{
+    int i;
+    for (i = 0; i < gUnknown_203F3D4->unk5; i++)
+    {
+        if (gUnknown_203F3D4->unk82E4[i].unk14 != 1)
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool32 sub_8149748(void)
+{
+    int i;
+
+    if (gUnknown_203F3D4->unk45 == 1)
+        return FALSE;
+
+    for (i = 1; i < gUnknown_203F3D4->unk5; i++)
+    {
+        if (gUnknown_203F3D4->unk90[i] == 1)
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void sub_8149780(int arg0)
+{
+    gUnknown_203F3D4->unk70.unk8 += arg0;
+    gUnknown_203F3D4->unk5C = 1;
+    if (gUnknown_203F3D4->unk70.unk8 >= 99990)
+        gUnknown_203F3D4->unk70.unk8 = 99990;
+}
+
+static int sub_81497A8(void)
+{
+    int i;
+    int count = 0;
+    int numPlayers = gUnknown_203F3D4->unk5;
+
+    for (i = 0; i < numPlayers; i++)
+    {
+        if (gUnknown_203F3D4->unk82E4[i].unk0 == -30)
+        {
+            gUnknown_203F3D4->unk7C[i] = 1;
+            count++;
+        }
+        else
+        {
+            gUnknown_203F3D4->unk7C[i] = 0;
+        }
+    }
+
+    return count;
+}
+
+static bool32 sub_8149804(void)
+{
+    return !Rfu.unk_124.count && !Rfu.unk_9e8.count;
+}
+
+static int sub_8149834(u8 *arg0)
+{
+    int i;
+    int flags;
+    int count;
+
+    for (i = 0, flags = 0, count = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        if (arg0[i])
+        {
+            flags |= 1 << i;
+            count++;
+        }
+    }
+
+    gUnknown_203F3D4->unk70.unk1 = flags;
+    if (flags)
+        gUnknown_203F3D4->unk4D = 1;
+
+    return count;
+}
+
+static void sub_8149878(void)
+{
+    gUnknown_203F3D4->unk44 = 0;
+}
+
+static const int gUnknown_846B74C[] = {0, 0, 50, 100, 200, 500};
+
+static int sub_8149888(int arg0)
+{
+    return gUnknown_846B74C[arg0];
+}
+
+static void sub_8149898(u16 arg0)
+{
+    if (arg0 > gUnknown_203F3D4->unkE)
+        gUnknown_203F3D4->unkE = arg0;
+}
+
+static const u16 gUnknown_846B764[] = {0x8a, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93};
+static const u32 gUnknown_846B76C[][2] =
+{
+    {0x1388, 1},
+    {0x1f40, 2},
+    {0x2ee0, 3},
+    {0x3e80, 4},
+    {0x4e20, 5},
+};
+
+static bool32 sub_81498B4(void)
+{
+    if (gUnknown_203F3D4->unk70.unk8 >= gUnknown_846B76C[0][0])
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static u16 sub_81498D8(void)
+{
+    u16 lo = sub_8149910();
+    u16 hi = sub_8149930();
+    return (hi << 12) | (lo & 0xFFF);
+}
+
+static void sub_8149900(u16 arg0, u16 *arg1, u16 *arg2)
+{
+    *arg2 = arg0 >> 12;
+    *arg1 = arg0 & 0xFFF;
+}
+
+static u16 sub_8149910(void)
+{
+    u16 index = Random() % NELEMS(gUnknown_846B764);
+    return gUnknown_846B764[index];
+}
+
+static u16 sub_8149930(void)
+{
+    u32 val, i;
+
+    val = 0;
+    for (i = 0; i < 5; i++)
+    {
+        if (gUnknown_203F3D4->unk70.unk8 < gUnknown_846B76C[i][0])
+            break;
+        else if (1) // required to match, see pret/pokeemerald#982
+            val = gUnknown_846B76C[i][1];
+        else
+            break;
+    }
+
+    return val;
+}
+
+static u16 sub_8149978(u16 item, u16 quantity)
+{
+    while (quantity && !CheckBagHasSpace(item, quantity))
+        quantity--;
+
+    return quantity;
+}
+
+u16 sub_81499A4(void)
+{
+    return GetLinkPlayerCount();
+}
+
+u16 sub_81499B4(void)
+{
+    return gUnknown_203F3D4->unk6;
+}
+
+struct PokemonJump1_MonInfo *sub_81499C0(u8 multiplayerId)
+{
+    return &gUnknown_203F3D4->unk82A8[multiplayerId];
+}
+
+u8 *sub_81499E0(u8 multiplayerId)
+{
+    return gUnknown_203F3D4->unk82E4[multiplayerId].unk1C;
+}
+
+bool32 IsSpeciesAllowedInPokemonJump(u16 species)
+{
+    return GetPokemonJumpSpeciesIdx(species) > -1;
+}
+
+void IsPokemonJumpSpeciesInParty(void)
+{
+    int i;
+
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_HAS_SPECIES))
+        {
+            u16 species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2);
+            if (IsSpeciesAllowedInPokemonJump(species))
+            {
+                gSpecialVar_Result = TRUE;
+                return;
+            }
+        }
+    }
+
+    gSpecialVar_Result = FALSE;
+}
diff --git a/src/pokemon_jump_3.c b/src/pokemon_jump_3.c
new file mode 100644
index 000000000..04d9ad439
--- /dev/null
+++ b/src/pokemon_jump_3.c
@@ -0,0 +1,167 @@
+#include "global.h"
+#include "link_rfu.h"
+#include "pokemon_jump.h"
+
+struct MonInfoPacket
+{
+    u8 id; // packet id
+    u16 species;
+    u32 personality;
+    u32 otId;
+};
+
+void sub_8149A6C(struct PokemonJump1_MonInfo *arg0)
+{
+    struct MonInfoPacket packet;
+    packet.id = 1;
+    packet.species = arg0->species;
+    packet.otId = arg0->otId;
+    packet.personality = arg0->personality;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+bool32 sub_8149A90(int multiplayerId, struct PokemonJump1_MonInfo *arg0)
+{
+    struct MonInfoPacket packet;
+
+    if ((gRecvCmds[multiplayerId][0] & 0xFF00) != 0x2F00)
+        return FALSE;
+
+    memcpy(&packet, &gRecvCmds[multiplayerId][1], sizeof(packet));
+    if (packet.id == 1)
+    {
+        arg0->species = packet.species;
+        arg0->otId = packet.otId;
+        arg0->personality = packet.personality;
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+struct UnkPacket2
+{
+    u8 id; // packet id
+    u32 unk4;
+    u32 unk8;
+};
+
+void sub_8149AE0(u32 arg0)
+{
+    struct UnkPacket2 packet;
+    packet.id = 2;
+    packet.unk4 = arg0;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+struct UnkPacket3
+{
+    u8 id; // packet id
+    u8 unk1;
+    u8 unk2;
+    u8 unk3_0:5;
+    u8 unk3_1:3;
+    u16 unk4;
+    u16 unk6;
+    u32 unk8_0:15;
+    u32 unk8_1:17;
+};
+
+void sub_8149AF8(struct PokemonJump1_82E4 *arg0, struct PokemonJump1Sub *arg1)
+{
+    struct UnkPacket3 packet;
+    packet.id = 3;
+    packet.unk8_1 = arg1->unk8;
+    packet.unk3_0 = arg1->unk1;
+    packet.unk1 = arg1->unk0;
+    packet.unk6 = arg1->unk2;
+    packet.unk8_0 = arg1->unk4;
+    packet.unk2 = arg0->unk10;
+    packet.unk3_1 = arg0->unk14;
+    packet.unk4 = arg0->unkE;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+bool32 sub_8149B7C(struct PokemonJump1_82E4 *arg0, struct PokemonJump1Sub *arg1)
+{
+    struct UnkPacket3 packet;
+
+    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00)
+        return FALSE;
+
+    memcpy(&packet, &gRecvCmds[0][1], sizeof(packet));
+    if (packet.id != 3)
+        return FALSE;
+
+    arg1->unk8 = packet.unk8_1;
+    arg1->unk1 = packet.unk3_0;
+    arg1->unk0 = packet.unk1;
+    arg1->unk2 = packet.unk6;
+    arg1->unk4 = packet.unk8_0;
+    arg0->unk10 = packet.unk2;
+    arg0->unk14 = packet.unk3_1;
+    arg0->unkE = packet.unk4;
+    return TRUE;
+}
+
+struct UnkPacket4
+{
+    u8 id; // packet id
+    u8 unk1;
+    u8 unk2;
+    u8 unk3;
+    u16 unk4;
+    u8 unk6;
+    u16 unk8;
+};
+
+void sub_8149BF4(struct PokemonJump1_82E4 *arg0, u8 arg1, u16 arg2)
+{
+    struct UnkPacket4 packet;
+    packet.id = 4;
+    packet.unk1 = arg0->unk10;
+    packet.unk2 = arg0->unk14;
+    packet.unk3 = arg0->unk18;
+    packet.unk4 = arg0->unkE;
+    packet.unk6 = arg1;
+    packet.unk8 = arg2;
+    RfuPrepareSend0x2f00(&packet);
+}
+
+bool32 sub_8149C24(struct PokemonJump1_82E4 *arg0, int multiplayerId, u8 *arg2, u16 *arg3)
+{
+    struct UnkPacket4 packet;
+
+    if ((gRecvCmds[multiplayerId][0] & 0xFF00) != 0x2F00)
+        return FALSE;
+
+    memcpy(&packet, &gRecvCmds[multiplayerId][1], sizeof(packet));
+    if (packet.id != 4)
+        return FALSE;
+
+    arg0->unk10 = packet.unk1;
+    arg0->unk14 = packet.unk2;
+    arg0->unk18 = packet.unk3;
+    arg0->unkE = packet.unk4;
+    *arg2 = packet.unk6;
+    *arg3 = packet.unk8;
+    return TRUE;
+}
+
+bool32 sub_8149C90(struct PokemonJump1_82E4 *arg0, int multiplayerId)
+{
+    struct UnkPacket4 packet;
+
+    if ((gRecvCmds[multiplayerId][0] & 0xFF00) != 0x2F00)
+        return FALSE;
+
+    memcpy(&packet, &gRecvCmds[multiplayerId][1], sizeof(packet));
+    if (packet.id != 4)
+        return FALSE;
+
+    arg0->unk10 = packet.unk1;
+    arg0->unk14 = packet.unk2;
+    arg0->unk18 = packet.unk3;
+    arg0->unkE = packet.unk4;
+    return TRUE;
+}
diff --git a/src/pokemon_jump_4.c b/src/pokemon_jump_4.c
new file mode 100644
index 000000000..c125734a3
--- /dev/null
+++ b/src/pokemon_jump_4.c
@@ -0,0 +1,922 @@
+#include "global.h"
+#include "gflib.h"
+#include "data.h"
+#include "digit_obj_util.h"
+#include "dynamic_placeholder_text_util.h"
+#include "item.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "pokemon_jump.h"
+#include "strings.h"
+#include "task.h"
+#include "text_window.h"
+#include "constants/songs.h"
+#include "constants/items.h"
+
+EWRAM_DATA static struct PokemonJump2 *gUnknown_203F3D8 = NULL;
+
+static void sub_8149D80(void (*func)(void));
+static void sub_8149DA4(u8 taskId);
+static void sub_8149DC8(void);
+static void sub_8149F64(void);
+static void sub_8149FD0(void);
+static void sub_814A03C(void);
+static void sub_814A0C8(void);
+static void sub_814A174(void);
+static void sub_814A218(void);
+static void sub_814A264(void);
+static void sub_814A308(void);
+static void sub_814A3AC(void);
+static u32 sub_814A754(u32 left, u32 top, u32 width, u32 height);
+static void sub_814A7D0(u16 left, u16 top, u8 cursorPos);
+static void sub_814A84C(void);
+static void sub_814A8B8(void);
+static void sub_814A9C8(void);
+static void sub_814AADC(void);
+static void sub_814AC30(bool32 arg0);
+static void sub_814AC94(void);
+static void sub_814ACCC(u8 arg0);
+static void sub_814AD50(u8 taskId);
+
+static void sub_8149D34(struct PokemonJump2 *);
+
+void sub_8149CEC(struct PokemonJump2 *arg0)
+{
+    u8 taskId;
+
+    gUnknown_203F3D8 = arg0;
+    sub_8149D34(gUnknown_203F3D8);
+    taskId = CreateTask(sub_8149DA4, 3);
+    gUnknown_203F3D8->unk6 = taskId;
+    SetWordTaskArg(gUnknown_203F3D8->unk6, 2, (uintptr_t)gUnknown_203F3D8);
+    sub_8149D80(sub_8149DC8);
+}
+
+void sub_8149D24(void)
+{
+    FreeAllWindowBuffers();
+    DigitObjUtil_Teardown();
+}
+
+static void sub_8149D34(struct PokemonJump2 *arg0)
+{
+    arg0->unk4 = 0;
+    arg0->unk0 = 0;
+    arg0->unk12 = 0xFF;
+}
+
+// Gfx
+static const u16 sPkmnJumpPal3[] = INCBIN_U16("graphics/link_games/pkmnjump_pal3.gbapal");
+
+static const u16 sPkmnJumpBgPal[] = INCBIN_U16("graphics/link_games/pkmnjump_bg.gbapal");
+static const u32 sPkmnJumpBgGfx[] = INCBIN_U32("graphics/link_games/pkmnjump_bg.4bpp.lz");
+static const u32 sPkmnJumpBgTilemap[] = INCBIN_U32("graphics/link_games/pkmnjump_bg.bin.lz");
+
+static const u16 sPkmnJumpVenusaurPal[] = INCBIN_U16("graphics/link_games/pkmnjump_venusaur.gbapal");
+static const u32 sPkmnJumpVenusaurGfx[] = INCBIN_U32("graphics/link_games/pkmnjump_venusaur.4bpp.lz");
+static const u32 sPkmnJumpVenusaurTilemap[] = INCBIN_U32("graphics/link_games/pkmnjump_venusaur.bin.lz");
+
+static const u16 sPkmnJumpResultsPal[] = INCBIN_U16("graphics/link_games/pkmnjump_results.gbapal");
+static const u32 sPkmnJumpResultsGfx[] = INCBIN_U32("graphics/link_games/pkmnjump_results.4bpp.lz");
+static const u32 sPkmnJumpResultsTilemap[] = INCBIN_U32("graphics/link_games/pkmnjump_results.bin.lz");
+
+static const struct BgTemplate gUnknown_846D8D4[] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 27,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    },
+    {
+        .bg = 2,
+        .charBaseIndex = 1,
+        .mapBaseIndex = 30,
+        .screenSize = 2,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 12,
+        .screenSize = 3,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 29,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0
+    },
+};
+
+static const struct WindowTemplate gUnknown_846D8E4[] =
+{
+    {
+        .bg = 0,
+        .tilemapLeft = 19,
+        .tilemapTop = 0,
+        .width = 6,
+        .height = 2,
+        .paletteNum = 2,
+        .baseBlock = 0x13,
+    },
+    {
+        .bg = 0,
+        .tilemapLeft = 8,
+        .tilemapTop = 0,
+        .width = 6,
+        .height = 2,
+        .paletteNum = 2,
+        .baseBlock = 0x1F,
+    },
+    DUMMY_WIN_TEMPLATE,
+};
+
+struct
+{
+    int id;
+    void (*func)(void);
+} static const gUnknown_846D8FC[] =
+{
+    {0x00, sub_8149DC8},
+    {0x01, sub_8149F64},
+    {0x02, sub_8149FD0},
+    {0x03, sub_814A03C},
+    {0x04, sub_814A0C8},
+    {0x05, sub_814A174},
+    {0x06, sub_814A218},
+    {0x07, sub_814A264},
+    {0x09, sub_814A3AC},
+    {0x08, sub_814A308},
+};
+
+void sub_8149D40(int arg0)
+{
+    int i;
+
+    for (i = 0; i < NELEMS(gUnknown_846D8FC); i++)
+    {
+        if (gUnknown_846D8FC[i].id == arg0)
+            sub_8149D80(gUnknown_846D8FC[i].func);
+    }
+}
+
+bool32 sub_8149D68(void)
+{
+    return (gUnknown_203F3D8->unk0 != 1);
+}
+
+static void sub_8149D80(void (*func)(void))
+{
+    SetWordTaskArg(gUnknown_203F3D8->unk6, 0, (uintptr_t)func);
+    gUnknown_203F3D8->unk4 = 0;
+    gUnknown_203F3D8->unk0 = 0;
+}
+
+static void sub_8149DA4(u8 taskId)
+{
+    if (!gUnknown_203F3D8->unk0)
+    {
+        void (*func)(void) = (void *)(GetWordTaskArg(taskId, 0));
+
+        func();
+    }
+}
+
+static void sub_8149DC8(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        ResetBgsAndClearDma3BusyFlags(FALSE);
+        InitBgsFromTemplates(0, gUnknown_846D8D4, NELEMS(gUnknown_846D8D4));
+        InitWindows(gUnknown_846D8E4);
+        ResetBgPositions();
+        ResetTempTileDataBuffers();
+        sub_814AD6C(gUnknown_203F3D8);
+        sub_814A9C8();
+        LoadPalette(sPkmnJumpBgPal, 0, 0x20);
+        DecompressAndCopyTileDataToVram(3, sPkmnJumpBgGfx, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(3, sPkmnJumpBgTilemap, 0, 0, 1);
+        LoadPalette(sPkmnJumpVenusaurPal, 0x30, 0x20);
+        DecompressAndCopyTileDataToVram(2, sPkmnJumpVenusaurGfx, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(2, sPkmnJumpVenusaurTilemap, 0, 0, 1);
+        LoadPalette(sPkmnJumpResultsPal, 0x10, 0x20);
+        DecompressAndCopyTileDataToVram(1, sPkmnJumpResultsGfx, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(1, sPkmnJumpResultsTilemap, 0, 0, 1);
+        LoadPalette(sPkmnJumpPal3, 0x20, 0x20);
+        SetBgTilemapBuffer(0, gUnknown_203F3D8->tilemapBuffer);
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
+        sub_814A84C();
+        sub_814AA24(0);
+        sub_814FDA0(0, 1, 0xE0);
+        LoadUserWindowBorderGfx(0, 0x00A, 0xD0);
+        CopyBgTilemapBufferToVram(0);
+        CopyBgTilemapBufferToVram(2);
+        CopyBgTilemapBufferToVram(1);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!FreeTempTileDataBuffersIfPossible())
+        {
+            sub_814A8B8();
+            sub_814B294(gUnknown_203F3D8);
+            sub_814B348(gUnknown_203F3D8, 6);
+            ShowBg(3);
+            ShowBg(0);
+            ShowBg(2);
+            HideBg(1);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_8149F64(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        sub_814AADC();
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_814AC30(FALSE);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_814AC94();
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_8149FD0(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        sub_814AADC();
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_814AC30(TRUE);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            sub_814AC94();
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A03C(void)
+{
+    int i, numPlayers;
+
+    numPlayers = sub_81499A4();
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        for (i = 0; i < numPlayers; i++)
+            ClearWindowTilemap(gUnknown_203F3D8->unk1C[i]);
+
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            for (i = 0; i < numPlayers; i++)
+                RemoveWindow(gUnknown_203F3D8->unk1C[i]);
+
+            gUnknown_203F3D8->unk0 = 1;
+        }
+        break;
+    }
+}
+
+static void sub_814A0C8(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        gUnknown_203F3D8->unk12 = sub_814A754(1, 8, 20, 2);
+        AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gText_WantToPlayAgain2, 0, 2, TEXT_SPEED_FF, NULL);
+        CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F3D8->unk12);
+            DrawTextBorderOuter(gUnknown_203F3D8->unk12, 1, 14);
+            sub_814A7D0(23, 7, 0);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A174(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        gUnknown_203F3D8->unk12 = sub_814A754(2, 7, 26, 4);
+        AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gText_SavingDontTurnOffPower, 0, 2, TEXT_SPEED_FF, NULL);
+        CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F3D8->unk12);
+            DrawTextBorderOuter(gUnknown_203F3D8->unk12, 1, 14);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A218(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        sub_814A6CC();
+        DestroyYesNoMenu();
+        CopyBgTilemapBufferToVram(0);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!sub_814A6FC() && !IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A264(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        gUnknown_203F3D8->unk12 = sub_814A754(2, 8, 22, 4);
+        AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gText_SomeoneDroppedOut2, 0, 2, TEXT_SPEED_FF, NULL);
+        CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F3D8->unk12);
+            DrawTextBorderOuter(gUnknown_203F3D8->unk12, 1, 14);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A308(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        gUnknown_203F3D8->unk12 = sub_814A754(7, 10, 16, 2);
+        AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gText_CommunicationStandby4, 0, 2, TEXT_SPEED_FF, NULL);
+        CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F3D8->unk12);
+            DrawTextBorderOuter(gUnknown_203F3D8->unk12, 1, 14);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F3D8->unk4++;
+        }
+        break;
+    case 2:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+static void sub_814A3AC(void)
+{
+    switch (gUnknown_203F3D8->unk4)
+    {
+    case 0:
+        sub_814B43C(gUnknown_203F3D8);
+        gUnknown_203F3D8->unk4++;
+        break;
+    case 1:
+        if (!sub_814B460())
+            gUnknown_203F3D8->unk0 = 1;
+        break;
+    }
+}
+
+void sub_814A3E4(void)
+{
+    gUnknown_203F3D8->unkA = 0;
+    gUnknown_203F3D8->unkB = 0;
+    gUnknown_203F3D8->unkC = 6;
+    sub_814A95C(gUnknown_203F3D8->unkC);
+}
+
+bool32 sub_814A408(void)
+{
+    switch (gUnknown_203F3D8->unkA)
+    {
+    case 0:
+        gUnknown_203F3D8->unkB++;
+        if (gUnknown_203F3D8->unkB > 10)
+        {
+            gUnknown_203F3D8->unkB = 0;
+            gUnknown_203F3D8->unkC++;
+            if (gUnknown_203F3D8->unkC >= 10)
+            {
+                gUnknown_203F3D8->unkC = 0;
+                gUnknown_203F3D8->unkA++;
+            }
+        }
+        sub_814A95C(gUnknown_203F3D8->unkC);
+        if (gUnknown_203F3D8->unkC != 7)
+            break;
+    case 1:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static const u8 sPluralTxt[] = _("IES");
+
+void sub_814A468(u16 itemId, u16 quantity)
+{
+    CopyItemName(itemId, gUnknown_203F3D8->txtBuff[0]);
+    ConvertIntToDecimalStringN(gUnknown_203F3D8->txtBuff[1], quantity, STR_CONV_MODE_LEFT_ALIGN, 1);
+    if (itemId >= FIRST_BERRY_INDEX && itemId < LAST_BERRY_INDEX)
+    {
+        if (quantity > 1)
+        {
+            int endi = StringLength(gUnknown_203F3D8->txtBuff[0]);
+            if (endi != 0)
+            {
+                endi--;
+                endi[gUnknown_203F3D8->txtBuff[0]] = EOS;
+                StringAppend(gUnknown_203F3D8->txtBuff[0], sPluralTxt);
+            }
+        }
+    }
+    DynamicPlaceholderTextUtil_Reset();
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gUnknown_203F3D8->txtBuff[0]);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gUnknown_203F3D8->txtBuff[1]);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gUnknown_203F3D8->strBuff, gText_AwesomeWonF701F700);
+    gUnknown_203F3D8->unk12 = sub_814A754(4, 8, 22, 4);
+    AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gUnknown_203F3D8->strBuff, 0, 2, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+    gUnknown_203F3D8->unk14 = MUS_FANFA1;
+    gUnknown_203F3D8->unkD = 0;
+}
+
+void sub_814A53C(u16 itemId)
+{
+    CopyItemName(itemId, gUnknown_203F3D8->txtBuff[0]);
+    DynamicPlaceholderTextUtil_Reset();
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gUnknown_203F3D8->txtBuff[0]);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gUnknown_203F3D8->strBuff, gText_FilledStorageSpace2);
+    gUnknown_203F3D8->unk12 = sub_814A754(4, 8, 22, 4);
+    AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gUnknown_203F3D8->strBuff, 0, 2, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+    gUnknown_203F3D8->unk14 = 0;
+    gUnknown_203F3D8->unkD = 0;
+}
+
+void sub_814A5B4(u16 itemId)
+{
+    CopyItemName(itemId, gUnknown_203F3D8->txtBuff[0]);
+    DynamicPlaceholderTextUtil_Reset();
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gUnknown_203F3D8->txtBuff[0]);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gUnknown_203F3D8->strBuff, gText_CantHoldMore);
+    gUnknown_203F3D8->unk12 = sub_814A754(4, 9, 22, 2);
+    AddTextPrinterParameterized(gUnknown_203F3D8->unk12, 2, gUnknown_203F3D8->strBuff, 0, 2, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(gUnknown_203F3D8->unk12, 2);
+    gUnknown_203F3D8->unk14 = 0;
+    gUnknown_203F3D8->unkD = 0;
+}
+
+bool32 sub_814A62C(void)
+{
+    switch (gUnknown_203F3D8->unkD)
+    {
+    case 0:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            PutWindowTilemap(gUnknown_203F3D8->unk12);
+            DrawTextBorderOuter(gUnknown_203F3D8->unk12, 1, 14);
+            CopyBgTilemapBufferToVram(0);
+            gUnknown_203F3D8->unkD++;
+        }
+        break;
+    case 1:
+        if (IsDma3ManagerBusyWithBgCopy())
+            break;
+        if (gUnknown_203F3D8->unk14 == 0)
+        {
+            gUnknown_203F3D8->unkD += 2;
+            return FALSE;
+        }
+        PlayFanfare(gUnknown_203F3D8->unk14);
+        gUnknown_203F3D8->unkD++;
+    case 2:
+        if (!IsFanfareTaskInactive())
+            break;
+        gUnknown_203F3D8->unkD++;
+    case 3:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+void sub_814A6CC(void)
+{
+    if (gUnknown_203F3D8->unk12 != 0xFF)
+    {
+        rbox_fill_rectangle(gUnknown_203F3D8->unk12);
+        CopyWindowToVram(gUnknown_203F3D8->unk12, 1);
+        gUnknown_203F3D8->unkD = 0;
+    }
+}
+
+// Can't match this without the ugly GOTO, oh well.
+bool32 sub_814A6FC(void)
+{
+    if (gUnknown_203F3D8->unk12 == 0xFF)
+    {
+        RET_FALSE:
+        return FALSE;
+    }
+
+    if (gUnknown_203F3D8->unkD == 0)
+    {
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            RemoveWindow(gUnknown_203F3D8->unk12);
+            gUnknown_203F3D8->unk12 = 0xFF;
+            gUnknown_203F3D8->unkD++;
+            goto RET_FALSE;
+        }
+    }
+    else if (gUnknown_203F3D8->unkD == 1)
+        goto RET_FALSE;
+
+    return TRUE;
+}
+
+s8 sub_814A744(void)
+{
+    return Menu_ProcessInputNoWrapClearOnChoose();
+}
+
+static u32 sub_814A754(u32 left, u32 top, u32 width, u32 height)
+{
+    u32 windowId;
+    struct WindowTemplate window;
+
+    window.bg = 0;
+    window.tilemapLeft = left;
+    window.tilemapTop = top;
+    window.width = width;
+    window.height = height;
+    window.paletteNum = 0xF;
+    window.baseBlock = 0x43;
+
+    windowId = AddWindow(&window);
+    FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
+    return windowId;
+}
+
+static void sub_814A7D0(u16 left, u16 top, u8 cursorPos)
+{
+    struct WindowTemplate window;
+    u8 a = cursorPos;
+
+    window.bg = 0;
+    window.tilemapLeft = left;
+    window.tilemapTop = top;
+    window.width = 6;
+    window.height = 4;
+    window.paletteNum = 2;
+    window.baseBlock = 0x2B;
+
+    CreateYesNoMenu(&window, 2, 0, 2, 0x00a, 0xD, a);
+}
+
+static void sub_814A84C(void)
+{
+    u8 color[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY};
+
+    PutWindowTilemap(0);
+    PutWindowTilemap(1);
+    FillWindowPixelBuffer(0, PIXEL_FILL(0));
+    FillWindowPixelBuffer(1, PIXEL_FILL(0));
+    AddTextPrinterParameterized3(0, 0, 0, 2, color, 0, gText_SpacePoints2);
+    AddTextPrinterParameterized3(1, 0, 0, 2, color, 0, gText_SpaceTimes3);
+}
+
+static const u8 gUnknown_846D953[] = {2, 2, 0, 0, 1, 1, 1, 0, 0, 2, 0, 0, 0};
+
+static const struct CompressedSpriteSheet gUnknown_846D960 = {gUnknown_8479688, 0, 0x320};
+static const struct SpritePalette gUnknown_846D968 = {gUnknown_8479668, 0x320};
+
+static const u16 gUnknown_846D970[] = {0x06, 0x08, 0x10, 0x08};
+static const u16 gUnknown_846D978[] = {0x06, 0x08, 0x0b, 0x06, 0x10, 0x08};
+static const u16 gUnknown_846D984[] = {0x02, 0x06, 0x06, 0x08, 0x10, 0x08, 0x14, 0x06};
+static const u16 gUnknown_846D994[] = {0x02, 0x06, 0x06, 0x08, 0x0b, 0x06, 0x10, 0x08, 0x14, 0x06};
+
+static const u16 *const gUnknown_846D9A8[] =
+{
+    gUnknown_846D970,
+    gUnknown_846D978,
+    gUnknown_846D984,
+    gUnknown_846D994,
+};
+
+static const s16 gUnknown_846D9B8[] = {0x0058, 0x0098};
+static const s16 gUnknown_846D9BC[] = {0x0058, 0x0078, 0x0098};
+static const s16 gUnknown_846D9C2[] = {0x0038, 0x0058, 0x0098, 0x00b8};
+static const s16 gUnknown_846D9CA[] = {0x0038, 0x0058, 0x0078, 0x0098, 0x00b8};
+
+static const s16 *const gUnknown_846D9D4[] =
+{
+    gUnknown_846D9B8,
+    gUnknown_846D9BC,
+    gUnknown_846D9C2,
+    gUnknown_846D9CA,
+};
+
+static void sub_814A8B8(void)
+{
+    int i, y, playersCount = sub_81499A4();
+    const s16 *xCoords = gUnknown_846D9D4[playersCount - 2];
+
+    for (i = 0; i < playersCount; i++)
+    {
+        struct PokemonJump1_MonInfo *info = sub_81499C0(i);
+
+        y = gMonFrontPicCoords[info->species].y_offset;
+        sub_814ADCC(gUnknown_203F3D8, info, *xCoords, y + 112, i);
+        sub_814B240(gUnknown_203F3D8, *xCoords, 112, i);
+        xCoords++;
+    }
+}
+
+void sub_814A940(u32 id, s16 y)
+{
+    gUnknown_203F3D8->unk81A8[id]->pos2.y = y;
+}
+
+void sub_814A95C(int id)
+{
+    sub_814B348(gUnknown_203F3D8, id);
+    ChangeBgY(2, (gUnknown_846D953[id] * 5) << 0xD, 0);
+}
+
+int sub_814A98C(u8 flags)
+{
+    int i, count;
+
+    for (i = 0, count = 0; i < 5; i++)
+    {
+        if (flags & 1)
+        {
+            sub_814AF0C(gUnknown_203F3D8, i);
+            count++;
+        }
+        flags >>= 1;
+    }
+
+    sub_814ACCC(count - 2);
+    return count;
+}
+
+static void sub_814A9C8(void)
+{
+    struct DigitObjUtilTemplate unkStruct;
+    struct DigitObjUtilTemplate *ptr = &unkStruct; // This temp variable is needed to match, don't ask me why.
+
+    ptr->shape = SPRITE_SHAPE(8x8);
+    ptr->size = SPRITE_SIZE(8x8);
+    ptr->strConvMode = 0;
+    ptr->priority = 1;
+    ptr->oamCount = 5;
+    ptr->xDelta = 8;
+    ptr->x = 108;
+    ptr->y = 6;
+    ptr->spriteSheet.compressed = &gUnknown_846D960;
+    ptr->spritePal = &gUnknown_846D968;
+
+    DigitObjUtil_Init(2);
+    DigitObjUtil_CreatePrinter(0, 0, ptr);
+
+    unkStruct.oamCount = 4;
+    unkStruct.x = 30;
+    unkStruct.y = 6;
+    DigitObjUtil_CreatePrinter(1, 0, &unkStruct);
+}
+
+void sub_814AA24(int arg0)
+{
+    DigitObjUtil_PrintNumOn(0, arg0);
+}
+
+void sub_814AA34(u16 arg0)
+{
+    DigitObjUtil_PrintNumOn(1, arg0);
+}
+
+void sub_814AA48(u8 multiplayerId)
+{
+    sub_814AFE8(gUnknown_203F3D8, multiplayerId);
+}
+
+void sub_814AA60(u8 multiplayerId)
+{
+    sub_814B080(gUnknown_203F3D8, multiplayerId);
+}
+
+int sub_814AA78(int multiplayerId)
+{
+    return sub_814B010(gUnknown_203F3D8, multiplayerId);
+}
+
+void sub_814AA8C(void)
+{
+    sub_814B0A8(gUnknown_203F3D8);
+}
+
+void sub_814AAA0(void)
+{
+    sub_814B134(gUnknown_203F3D8);
+}
+
+void sub_814AAB4(int multiplayerId)
+{
+    sub_814B168(gUnknown_203F3D8, multiplayerId);
+}
+
+int sub_814AAC8(void)
+{
+    return sub_814B190(gUnknown_203F3D8);
+}
+
+static void sub_814AADC(void)
+{
+    struct WindowTemplate window;
+    int i, playersCount = sub_81499A4();
+    const u16 *winCoords = gUnknown_846D9A8[playersCount - 2];
+
+    window.bg = 0;
+    window.width = 8;
+    window.height = 2;
+    window.paletteNum = 2;
+    window.baseBlock = 0x2B;
+
+    for (i = 0; i < playersCount; i++)
+    {
+        window.tilemapLeft = winCoords[0];
+        window.tilemapTop = winCoords[1];
+        gUnknown_203F3D8->unk1C[i] = AddWindow(&window);
+        ClearWindowTilemap(gUnknown_203F3D8->unk1C[i]);
+        window.baseBlock += 0x10;
+        winCoords += 2;
+    }
+
+    CopyBgTilemapBufferToVram(0);
+}
+
+static void sub_814AB98(int multiplayerId, u8 clr1, u8 clr2, u8 clr3)
+{
+    u32 x;
+    u8 colors[3] = {clr1, clr2, clr3};
+
+    FillWindowPixelBuffer(gUnknown_203F3D8->unk1C[multiplayerId], PIXEL_FILL(0));
+    x = 64 - GetStringWidth(0, sub_81499E0(multiplayerId), -1);
+    x /= 2;
+    AddTextPrinterParameterized3(gUnknown_203F3D8->unk1C[multiplayerId], 0, x, 2, colors, -1, sub_81499E0(multiplayerId));
+    CopyWindowToVram(gUnknown_203F3D8->unk1C[multiplayerId], 2);
+}
+
+static void sub_814AC30(bool32 arg0)
+{
+    int i, var, playersCount = sub_81499A4();
+
+    if (!arg0)
+    {
+        for (i = 0; i < playersCount; i++)
+            sub_814AB98(i, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY);
+    }
+    else
+    {
+        var = sub_81499B4();
+        for (i = 0; i < playersCount; i++)
+        {
+            if (var != i)
+                sub_814AB98(i, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY);
+            else
+                sub_814AB98(i, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_RED, TEXT_COLOR_LIGHT_RED);
+        }
+    }
+}
+
+static void sub_814AC94(void)
+{
+    int i, playersCount = sub_81499A4();
+
+    for (i = 0; i < playersCount; i++)
+        PutWindowTilemap(gUnknown_203F3D8->unk1C[i]);
+    CopyBgTilemapBufferToVram(0);
+}
+
+static void sub_814ACCC(u8 arg0)
+{
+    gUnknown_203F3D8->unk18 = 0;
+    ChangeBgX(1, (arg0 / 2) << 16, 0);
+    ChangeBgY(1, (((arg0 % 2) << 8) - 40) << 8, 0);
+    ShowBg(1);
+    CreateTask(sub_814AD50, 4);
+}
+
+static bool32 sub_814AD18(void)
+{
+    if (gUnknown_203F3D8->unk18 >= 32)
+    {
+        return FALSE;
+    }
+    else
+    {
+        ChangeBgY(1, 128, 1);
+        if (++gUnknown_203F3D8->unk18 >= 32)
+            HideBg(1);
+        return TRUE;
+    }
+}
+
+static void sub_814AD50(u8 taskId)
+{
+    if (!sub_814AD18())
+        DestroyTask(taskId);
+}
diff --git a/src/pokemon_jump_5.c b/src/pokemon_jump_5.c
new file mode 100644
index 000000000..f8abb2a1f
--- /dev/null
+++ b/src/pokemon_jump_5.c
@@ -0,0 +1,637 @@
+#include "global.h"
+#include "gflib.h"
+#include "decompress.h"
+#include "minigame_countdown.h"
+#include "pokemon_jump.h"
+#include "data.h"
+#include "trig.h"
+#include "constants/songs.h"
+
+static void sub_814AF74(struct Sprite *sprite);
+static void sub_814B038(struct Sprite *sprite);
+static void sub_814B100(struct Sprite *sprite);
+static void sub_814B1CC(struct Sprite *sprite);
+
+static const u16 sPkmnJumpPal1[] = INCBIN_U16("graphics/link_games/pkmnjump_pal1.gbapal");
+static const u16 sPkmnJumpPal2[] = INCBIN_U16("graphics/link_games/pkmnjump_pal2.gbapal");
+
+static const u32 sPkmnJumpRopeGfx1[] = INCBIN_U32("graphics/link_games/pkmnjump_rope1.4bpp.lz");
+static const u32 sPkmnJumpRopeGfx2[] = INCBIN_U32("graphics/link_games/pkmnjump_rope2.4bpp.lz");
+static const u32 sPkmnJumpRopeGfx3[] = INCBIN_U32("graphics/link_games/pkmnjump_rope3.4bpp.lz");
+static const u32 sPkmnJumpRopeGfx4[] = INCBIN_U32("graphics/link_games/pkmnjump_rope4.4bpp.lz");
+
+static const u32 sPkmnJumpStarGfx[] = INCBIN_U32("graphics/link_games/pkmnjump_star.4bpp.lz");
+
+static const struct CompressedSpriteSheet gUnknown_846E0B0[] =
+{
+    {sPkmnJumpRopeGfx1, 0x600, 5},
+    {sPkmnJumpRopeGfx2, 0x0c00, 6},
+    {sPkmnJumpRopeGfx3, 0x0600, 7},
+    {sPkmnJumpRopeGfx4, 0x0600, 8},
+    {sPkmnJumpStarGfx, 0x0200, 10},
+};
+
+static const struct SpritePalette gUnknown_846E0D8[] =
+{
+    {sPkmnJumpPal1, 5},
+    {sPkmnJumpPal2, 6},
+};
+
+// Forward declarations.
+static const struct OamData sOamData_846E170;
+static const struct SpriteTemplate gUnknown_846E220;
+static const struct SpriteTemplate gUnknown_846E238;
+static const struct SpriteTemplate gUnknown_846E250;
+static const struct SpriteTemplate gUnknown_846E268;
+
+static const struct SpriteTemplate gUnknown_846E0E8 =
+{
+    .tileTag = 0,
+    .paletteTag = 0,
+    .oam = &sOamData_846E170,
+    .anims = gDummySpriteAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const s16 gUnknown_846E100[][10] =
+{
+    {0x60, 0x60, 0x60, 0x72, 0x78, 0x78, 0x78, 0x72, 0x60, 0x60},
+    {0x46, 0x50, 0x60, 0x72, 0x78, 0x80, 0x78, 0x72, 0x60, 0x50},
+    {0x32, 0x48, 0x60, 0x72, 0x80, 0x88, 0x80, 0x72, 0x60, 0x48},
+    {0x2a, 0x48, 0x60, 0x72, 0x80, 0x88, 0x80, 0x72, 0x60, 0x48},
+};
+
+static const s16 gUnknown_846E150[] = {0x10, 0x28, 0x48, 0x68, 0x88, 0xa8, 0xc8, 0xe0};
+
+static const struct SpriteTemplate *const gUnknown_846E160[] =
+{
+    &gUnknown_846E220,
+    &gUnknown_846E238,
+    &gUnknown_846E250,
+    &gUnknown_846E268,
+};
+
+static const struct OamData sOamData_846E170 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x64),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(64x64),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_846E178 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x32),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x32),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_846E180 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x32),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(32x32),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct OamData sOamData_846E188 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(32x16),
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const union AnimCmd sSpriteAnim_846E190[] =
+{
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E198[] =
+{
+    ANIMCMD_FRAME(8, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1A0[] =
+{
+    ANIMCMD_FRAME(16, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1A8[] =
+{
+    ANIMCMD_FRAME(24, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1B0[] =
+{
+    ANIMCMD_FRAME(32, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1B8[] =
+{
+    ANIMCMD_FRAME(40, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1C0[] =
+{
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1C8[] =
+{
+    ANIMCMD_FRAME(16, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1D0[] =
+{
+    ANIMCMD_FRAME(32, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1D8[] =
+{
+    ANIMCMD_FRAME(48, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1E0[] =
+{
+    ANIMCMD_FRAME(64, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E1E8[] =
+{
+    ANIMCMD_FRAME(80, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_846E1F0[] =
+{
+    sSpriteAnim_846E190,
+    sSpriteAnim_846E198,
+    sSpriteAnim_846E1A0,
+    sSpriteAnim_846E1A8,
+    sSpriteAnim_846E1B0,
+    sSpriteAnim_846E1B8
+};
+
+static const union AnimCmd *const sSpriteAnimTable_846E208[] =
+{
+    sSpriteAnim_846E1C0,
+    sSpriteAnim_846E1C8,
+    sSpriteAnim_846E1D0,
+    sSpriteAnim_846E1D8,
+    sSpriteAnim_846E1E0,
+    sSpriteAnim_846E1E8
+};
+
+static const struct SpriteTemplate gUnknown_846E220 =
+{
+    .tileTag = 5,
+    .paletteTag = 5,
+    .oam = &sOamData_846E178,
+    .anims = sSpriteAnimTable_846E1F0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct SpriteTemplate gUnknown_846E238 =
+{
+    .tileTag = 6,
+    .paletteTag = 5,
+    .oam = &sOamData_846E180,
+    .anims = sSpriteAnimTable_846E208,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct SpriteTemplate gUnknown_846E250 =
+{
+    .tileTag = 7,
+    .paletteTag = 5,
+    .oam = &sOamData_846E188,
+    .anims = sSpriteAnimTable_846E1F0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct SpriteTemplate gUnknown_846E268 =
+{
+    .tileTag = 8,
+    .paletteTag = 5,
+    .oam = &sOamData_846E188,
+    .anims = sSpriteAnimTable_846E1F0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct OamData sOamData_846E280 =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const union AnimCmd sSpriteAnim_846E288[] =
+{
+    ANIMCMD_FRAME(0, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_846E290[] =
+{
+    ANIMCMD_FRAME(0, 4),
+    ANIMCMD_FRAME(4, 4),
+    ANIMCMD_FRAME(8, 4),
+    ANIMCMD_FRAME(12, 4),
+    ANIMCMD_LOOP(1),
+    ANIMCMD_FRAME(0, 4),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_846E2AC[] =
+{
+    sSpriteAnim_846E288,
+    sSpriteAnim_846E290
+};
+
+static const struct SpriteTemplate gUnknown_846E2B4 =
+{
+    .tileTag = 10,
+    .paletteTag = 5,
+    .oam = &sOamData_846E280,
+    .anims = sSpriteAnimTable_846E2AC,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+void sub_814AD6C(struct PokemonJump2 *arg0)
+{
+    int i;
+
+    for (i = 0; i < NELEMS(gUnknown_846E0B0); i++)
+        LoadCompressedSpriteSheet(&gUnknown_846E0B0[i]);
+
+    for (i = 0; i < NELEMS(gUnknown_846E0D8); i++)
+        LoadSpritePalette(&gUnknown_846E0D8[i]);
+
+    arg0->unkE = IndexOfSpritePaletteTag(5);
+    arg0->unkF = IndexOfSpritePaletteTag(6);
+}
+
+static void sub_814ADB4(struct Sprite *sprite)
+{
+    int i;
+    for (i = 0; i < 8; i++)
+        sprite->data[i] = 0;
+}
+
+void sub_814ADCC(struct PokemonJump2 *arg0, struct PokemonJump1_MonInfo *jumpMon, s16 x, s16 y, u8 multiplayerId)
+{
+    struct SpriteTemplate spriteTemplate;
+    struct SpriteSheet spriteSheet;
+    struct CompressedSpritePalette spritePalette;
+    u8 *buffer;
+    u8 *unusedBuffer;
+    u8 subpriority;
+    u8 spriteId;
+
+    spriteTemplate = gUnknown_846E0E8;
+    buffer = Alloc(0x2000);
+    unusedBuffer = Alloc(0x800);
+    if (multiplayerId == sub_81499B4())
+        subpriority = 3;
+    else
+        subpriority = multiplayerId + 4;
+
+    if (buffer && unusedBuffer)
+    {
+        HandleLoadSpecialPokePic(
+            &gMonFrontPicTable[jumpMon->species],
+            buffer,
+            jumpMon->species,
+            jumpMon->personality);
+
+        spriteSheet.data = buffer;
+        spriteSheet.tag = multiplayerId;
+        spriteSheet.size = 0x800;
+        LoadSpriteSheet(&spriteSheet);
+
+        spritePalette.data = GetMonSpritePalFromSpeciesAndPersonality(jumpMon->species, jumpMon->otId, jumpMon->personality);
+        spritePalette.tag = multiplayerId;
+        LoadCompressedSpritePalette(&spritePalette);
+
+        Free(buffer);
+        Free(unusedBuffer);
+
+        spriteTemplate.tileTag += multiplayerId;
+        spriteTemplate.paletteTag += multiplayerId;
+        spriteId = CreateSprite(&spriteTemplate, x, y, subpriority);
+        if (spriteId != MAX_SPRITES)
+        {
+            arg0->unk81A8[multiplayerId] = &gSprites[spriteId];
+            arg0->unk81FC[multiplayerId] = subpriority;
+            return;
+        }
+    }
+
+    arg0->unk81A8[multiplayerId] = NULL;
+}
+
+void sub_814AF0C(struct PokemonJump2 *arg0, int multiplayerId)
+{
+    sub_814ADB4(arg0->unk81BC[multiplayerId]);
+    arg0->unk81BC[multiplayerId]->data[7] = arg0->unk81A8[multiplayerId] - gSprites;
+    arg0->unk81BC[multiplayerId]->invisible = FALSE;
+    arg0->unk81BC[multiplayerId]->pos1.y = 96;
+    arg0->unk81BC[multiplayerId]->callback = sub_814AF74;
+    StartSpriteAnim(arg0->unk81BC[multiplayerId], 1);
+}
+
+static void sub_814AF74(struct Sprite *sprite)
+{
+    switch (sprite->data[0])
+    {
+    case 0:
+        if (sprite->animEnded)
+        {
+            sprite->invisible = TRUE;
+            sprite->callback = SpriteCallbackDummy;
+        }
+        break;
+    case 1:
+        sprite->pos1.y--;
+        sprite->data[1]++;
+        if (sprite->pos1.y <= 72)
+        {
+            sprite->pos1.y = 72;
+            sprite->data[0]++;
+        }
+        break;
+    case 2:
+        if (++sprite->data[1] >= 48)
+        {
+            sprite->invisible = TRUE;
+            sprite->callback = SpriteCallbackDummy;
+        }
+        break;
+    }
+}
+
+void sub_814AFE8(struct PokemonJump2 *arg0, int multiplayerId)
+{
+    arg0->unk81A8[multiplayerId]->callback = sub_814B038;
+    arg0->unk81A8[multiplayerId]->pos2.y = 0;
+    sub_814ADB4(arg0->unk81A8[multiplayerId]);
+}
+
+bool32 sub_814B010(struct PokemonJump2 *arg0, int multiplayerId)
+{
+    return arg0->unk81A8[multiplayerId]->callback == sub_814B038;
+}
+
+static void sub_814B038(struct Sprite *sprite)
+{
+    if (++sprite->data[1] > 1)
+    {
+        if (++sprite->data[2] & 1)
+            sprite->pos2.y = 2;
+        else
+            sprite->pos2.y = -2;
+
+        sprite->data[1] = 0;
+    }
+
+    if (sprite->data[2] > 12)
+    {
+        sprite->pos2.y = 0;
+        sprite->callback = SpriteCallbackDummy;
+    }
+}
+
+void sub_814B080(struct PokemonJump2 *arg0, int multiplayerId)
+{
+    sub_814ADB4(arg0->unk81A8[multiplayerId]);
+    arg0->unk81A8[multiplayerId]->callback = sub_814B100;
+}
+
+void sub_814B0A8(struct PokemonJump2 *arg0)
+{
+    int i;
+    u16 numPlayers = sub_81499A4();
+    for (i = 0; i < numPlayers; i++)
+    {
+        if (arg0->unk81A8[i]->callback == sub_814B100)
+        {
+            arg0->unk81A8[i]->invisible = FALSE;
+            arg0->unk81A8[i]->callback = SpriteCallbackDummy;
+            arg0->unk81A8[i]->subpriority = 10;
+        }
+    }
+}
+
+static void sub_814B100(struct Sprite *sprite)
+{
+    if (++sprite->data[0] > 3)
+    {
+        sprite->data[0] = 0;
+        sprite->invisible ^= 1;
+    }
+}
+
+void sub_814B134(struct PokemonJump2 *arg0)
+{
+    int i;
+    u16 numPlayers = sub_81499A4();
+    for (i = 0; i < numPlayers; i++)
+        arg0->unk81A8[i]->subpriority = arg0->unk81FC[i];
+}
+
+void sub_814B168(struct PokemonJump2 *arg0, int multiplayerId)
+{
+    sub_814ADB4(arg0->unk81A8[multiplayerId]);
+    arg0->unk81A8[multiplayerId]->callback = sub_814B1CC;
+}
+
+bool32 sub_814B190(struct PokemonJump2 *arg0)
+{
+    int i;
+    u16 numPlayers = sub_81499A4();
+    for (i = 0; i < numPlayers; i++)
+    {
+        if (arg0->unk81A8[i]->callback == sub_814B1CC)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void sub_814B1CC(struct Sprite *sprite)
+{
+    switch (sprite->data[0])
+    {
+    case 0:
+        PlaySE(SE_JITE_PYOKO);
+        sprite->data[1] = 0;
+        sprite->data[0]++;
+        // fall through
+    case 1:
+        sprite->data[1] += 4;
+        if (sprite->data[1] > 0x7F)
+            sprite->data[1] = 0;
+
+        sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 3);
+        if (sprite->data[1] == 0)
+        {
+            if (++sprite->data[2] < 2)
+                sprite->data[0] = 0;
+            else
+                sprite->callback = SpriteCallbackDummy;
+        }
+        break;
+    }
+}
+
+void sub_814B240(struct PokemonJump2 *arg0, s16 x, s16 y, u8 multiplayerId)
+{
+    u8 spriteId = CreateSprite(&gUnknown_846E2B4, x, y, 1);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].invisible = TRUE;
+        arg0->unk81BC[multiplayerId] = &gSprites[spriteId];
+    }
+}
+
+void sub_814B294(struct PokemonJump2 *arg0)
+{
+    int i;
+    int count;
+    u8 spriteId;
+
+    count = 0;
+    for (i = 0; i < 4; i++)
+    {
+        spriteId = CreateSprite(gUnknown_846E160[i], gUnknown_846E150[count], gUnknown_846E100[i][0], 2);
+        arg0->unk81D0[count] = &gSprites[spriteId];
+        count++;
+    }
+
+    for (i = 3; i >= 0; i--)
+    {
+        spriteId = CreateSprite(gUnknown_846E160[i], gUnknown_846E150[count], gUnknown_846E100[i][0], 2);
+        arg0->unk81D0[count] = &gSprites[spriteId];
+        arg0->unk81D0[count]->hFlip = 1;
+        count++;
+    }
+}
+
+void sub_814B348(struct PokemonJump2 *arg0, int arg1)
+{
+    int i, count, palNum;
+    int priority;
+
+    if (arg1 > 5)
+    {
+        arg1 = 10 - arg1;
+        priority = 3;
+        palNum = arg0->unkF;
+    }
+    else
+    {
+        priority = 2;
+        palNum = arg0->unkE;
+    }
+
+    count = 0;
+    for (i = 0; i < 4; i++)
+    {
+        arg0->unk81D0[count]->pos1.y = gUnknown_846E100[i][arg1];
+        arg0->unk81D0[count]->oam.priority = priority;
+        arg0->unk81D0[count]->oam.paletteNum = palNum;
+        StartSpriteAnim(arg0->unk81D0[count], arg1);
+        count++;
+    }
+
+    for (i = 3; i >= 0; i--)
+    {
+        arg0->unk81D0[count]->pos1.y = gUnknown_846E100[i][arg1];
+        arg0->unk81D0[count]->oam.priority = priority;
+        arg0->unk81D0[count]->oam.paletteNum = palNum;
+        StartSpriteAnim(arg0->unk81D0[count], arg1);
+        count++;
+    }
+}
+
+void sub_814B43C(struct PokemonJump2 *arg0)
+{
+    StartMinigameCountdown(9, 7, 120, 80, 0);
+    sub_814B134(arg0);
+}
+
+bool32 sub_814B460(void)
+{
+    return IsMinigameCountdownRunning();
+}
diff --git a/src/pokemon_jump_6.c b/src/pokemon_jump_6.c
new file mode 100644
index 000000000..1e213ad75
--- /dev/null
+++ b/src/pokemon_jump_6.c
@@ -0,0 +1,140 @@
+#include "global.h"
+#include "gflib.h"
+#include "menu.h"
+#include "script.h"
+#include "strings.h"
+#include "task.h"
+#include "text_window.h"
+
+static void Task_ShowPokemonJumpRecords(u8 taskId);
+static void TruncateToFirstWordOnly(u8 *str);
+static void sub_814B5C4(u16 windowId);
+
+static struct PokemonJumpResults *sub_814B46C(void)
+{
+    return &gSaveBlock2Ptr->pokeJump;
+}
+
+void ResetPokeJumpResults(void)
+{
+    struct PokemonJumpResults *pokeJump = sub_814B46C();
+    pokeJump->jumpsInRow = 0;
+    pokeJump->bestJumpScore = 0;
+    pokeJump->excellentsInRow = 0;
+    pokeJump->field6 = 0;
+    pokeJump->field8 = 0;
+    pokeJump->field2 = 0;
+}
+
+bool32 sub_814B494(u32 jumpScore, u16 jumpsInRow, u16 excellentsInRow)
+{
+    struct PokemonJumpResults *pokeJump = sub_814B46C();
+    bool32 ret = FALSE;
+
+    if (pokeJump->bestJumpScore < jumpScore && jumpScore <= 99990)
+        pokeJump->bestJumpScore = jumpScore, ret = TRUE;
+    if (pokeJump->jumpsInRow < jumpsInRow && jumpsInRow <= 9999)
+        pokeJump->jumpsInRow = jumpsInRow, ret = TRUE;
+    if (pokeJump->excellentsInRow < excellentsInRow && excellentsInRow <= 9999)
+        pokeJump->excellentsInRow = excellentsInRow, ret = TRUE;
+
+    return ret;
+}
+
+void sub_814B4E8(void)
+{
+    struct PokemonJumpResults *pokeJump = sub_814B46C();
+    if (pokeJump->field6 < 9999)
+        pokeJump->field6++;
+}
+
+void ShowPokemonJumpRecords(void)
+{
+    u8 taskId = CreateTask(Task_ShowPokemonJumpRecords, 0);
+    Task_ShowPokemonJumpRecords(taskId);
+}
+
+static const struct WindowTemplate gUnknown_846E2CC =
+{
+    .bg = 0,
+    .tilemapLeft = 1,
+    .tilemapTop = 1,
+    .width = 28,
+    .height = 9,
+    .paletteNum = 15,
+    .baseBlock = 0x1,
+};
+
+static const u8 *const gUnknown_846E2D4[] = {gText_JumpsInARow, gText_BestScore2, gText_ExcellentsInARow};
+
+static void Task_ShowPokemonJumpRecords(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        data[1] = AddWindow(&gUnknown_846E2CC);
+        sub_814B5C4(data[1]);
+        CopyWindowToVram(data[1], 3);
+        data[0]++;
+        break;
+    case 1:
+        if (!IsDma3ManagerBusyWithBgCopy())
+            data[0]++;
+        break;
+    case 2:
+        if (JOY_NEW(A_BUTTON | B_BUTTON))
+        {
+            rbox_fill_rectangle(data[1]);
+            CopyWindowToVram(data[1], 1);
+            data[0]++;
+        }
+        break;
+    case 3:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            RemoveWindow(data[1]);
+            DestroyTask(taskId);
+            EnableBothScriptContexts();
+        }
+        break;
+    }
+}
+
+static void sub_814B5C4(u16 windowId)
+{
+    int i, x;
+    int results[3];
+    struct PokemonJumpResults *pokeJump = sub_814B46C();
+    u8 strbuf[8];
+    results[0] = pokeJump->jumpsInRow;
+    results[1] = pokeJump->bestJumpScore;
+    results[2] = pokeJump->excellentsInRow;
+
+    TextWindow_SetStdFrame0_WithPal(windowId, 0x21D, 0xD0);
+    DrawTextBorderOuter(windowId, 0x21D, 0xD);
+    FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
+    AddTextPrinterParameterized5(windowId, 2, gText_PkmnJumpRecords, 0, 0, TEXT_SPEED_FF, NULL, 1, 0);
+    for (i = 0; i < NELEMS(gUnknown_846E2D4); i++)
+    {
+        AddTextPrinterParameterized5(windowId, 2, gUnknown_846E2D4[i], 0, 20 + (i * 14), TEXT_SPEED_FF, NULL, 1, 0);
+        ConvertIntToDecimalStringN(strbuf, results[i], STR_CONV_MODE_LEFT_ALIGN, 5);
+        TruncateToFirstWordOnly(strbuf);
+        x = 0xDE - GetStringWidth(2, strbuf, 0);
+        AddTextPrinterParameterized5(windowId, 2, strbuf, x, 20 + (i * 14), TEXT_SPEED_FF, NULL, 0, 0);
+    }
+    PutWindowTilemap(windowId);
+}
+
+static void TruncateToFirstWordOnly(u8 *str)
+{
+    for (;*str != EOS; str++)
+    {
+        if (*str == CHAR_SPACE)
+        {
+            *str = EOS;
+            break;
+        }
+    }
+}
diff --git a/src/pokemon_size_record.c b/src/pokemon_size_record.c
index 6eff367c5..66bdb9194 100644
--- a/src/pokemon_size_record.c
+++ b/src/pokemon_size_record.c
@@ -3,7 +3,6 @@
 #include "event_data.h"
 #include "pokedex.h"
 #include "pokemon.h"
-#include "pokemon_size_record.h"
 #include "string_util.h"
 #include "text.h"
 #include "strings.h"
diff --git a/src/post_battle_event_funcs.c b/src/post_battle_event_funcs.c
index 112889710..b564e74ce 100644
--- a/src/post_battle_event_funcs.c
+++ b/src/post_battle_event_funcs.c
@@ -8,7 +8,7 @@
 #include "constants/flags.h"
 #include "constants/spawn_points.h"
 
-bool8 Special_HallOfFame(void)
+bool8 EnterHallOfFame(void)
 {
     bool8 ribbonState;
     bool8 *r7;
@@ -52,7 +52,7 @@ bool8 Special_HallOfFame(void)
     return FALSE;
 }
 
-bool8 sp0C8_whiteout_maybe(void)
+bool8 SetCB2WhiteOut(void)
 {
     SetMainCallback2(CB2_WhiteOut);
     return FALSE;
diff --git a/src/prof_pc.c b/src/prof_pc.c
index d1f06a2ba..c7eed8878 100644
--- a/src/prof_pc.c
+++ b/src/prof_pc.c
@@ -4,24 +4,24 @@
 #include "field_message_box.h"
 #include "constants/species.h"
 
-extern const u8 gUnknown_81A6D17[];
-extern const u8 gUnknown_81A6D6D[];
-extern const u8 gUnknown_81A6DDF[];
-extern const u8 gUnknown_81A6E36[];
-extern const u8 gUnknown_81A6EA4[];
-extern const u8 gUnknown_81A6F0B[];
-extern const u8 gUnknown_81A6F71[];
-extern const u8 gUnknown_81A6FAB[];
-extern const u8 gUnknown_81A6FF1[];
-extern const u8 gUnknown_81A7031[];
-extern const u8 gUnknown_81A7063[];
-extern const u8 gUnknown_81A70A5[];
-extern const u8 gUnknown_81A70D8[];
-extern const u8 gUnknown_81A7108[];
-extern const u8 gUnknown_81A7137[];
-extern const u8 gUnknown_81A7175[];
-
-u16 Special_GetPokedexCount(void)
+extern const u8 PokedexRating_Text_LessThan10[];
+extern const u8 PokedexRating_Text_LessThan20[];
+extern const u8 PokedexRating_Text_LessThan30[];
+extern const u8 PokedexRating_Text_LessThan40[];
+extern const u8 PokedexRating_Text_LessThan50[];
+extern const u8 PokedexRating_Text_LessThan60[];
+extern const u8 PokedexRating_Text_LessThan70[];
+extern const u8 PokedexRating_Text_LessThan80[];
+extern const u8 PokedexRating_Text_LessThan90[];
+extern const u8 PokedexRating_Text_LessThan100[];
+extern const u8 PokedexRating_Text_LessThan110[];
+extern const u8 PokedexRating_Text_LessThan120[];
+extern const u8 PokedexRating_Text_LessThan130[];
+extern const u8 PokedexRating_Text_LessThan140[];
+extern const u8 PokedexRating_Text_LessThan150[];
+extern const u8 PokedexRating_Text_Complete[];
+
+u16 GetPokedexCount(void)
 {
     if (gSpecialVar_0x8004 == 0)
     {
@@ -41,68 +41,70 @@ static const u8 *GetProfOaksRatingMessageByCount(u16 count)
     gSpecialVar_Result = FALSE;
 
     if (count < 10)
-        return gUnknown_81A6D17;
+        return PokedexRating_Text_LessThan10;
 
     if (count < 20)
-        return gUnknown_81A6D6D;
+        return PokedexRating_Text_LessThan20;
 
     if (count < 30)
-        return gUnknown_81A6DDF;
+        return PokedexRating_Text_LessThan30;
 
     if (count < 40)
-        return gUnknown_81A6E36;
+        return PokedexRating_Text_LessThan40;
 
     if (count < 50)
-        return gUnknown_81A6EA4;
+        return PokedexRating_Text_LessThan50;
 
     if (count < 60)
-        return gUnknown_81A6F0B;
+        return PokedexRating_Text_LessThan60;
 
     if (count < 70)
-        return gUnknown_81A6F71;
+        return PokedexRating_Text_LessThan70;
 
     if (count < 80)
-        return gUnknown_81A6FAB;
+        return PokedexRating_Text_LessThan80;
 
     if (count < 90)
-        return gUnknown_81A6FF1;
+        return PokedexRating_Text_LessThan90;
 
     if (count < 100)
-        return gUnknown_81A7031;
+        return PokedexRating_Text_LessThan100;
 
     if (count < 110)
-        return gUnknown_81A7063;
+        return PokedexRating_Text_LessThan110;
 
     if (count < 120)
-        return gUnknown_81A70A5;
+        return PokedexRating_Text_LessThan120;
 
     if (count < 130)
-        return gUnknown_81A70D8;
+        return PokedexRating_Text_LessThan130;
 
     if (count < 140)
-        return gUnknown_81A7108;
+        return PokedexRating_Text_LessThan140;
 
     if (count < 150)
-        return gUnknown_81A7137;
+        return PokedexRating_Text_LessThan150;
 
     if (count == 150)
     {
+        // Mew doesn't count for completing the pokedex
         if (GetSetPokedexFlag(SpeciesToNationalPokedexNum(SPECIES_MEW), 1))
-            return gUnknown_81A7137;
+            return PokedexRating_Text_LessThan150;
+
         gSpecialVar_Result = TRUE;
-        return gUnknown_81A7175;
+        return PokedexRating_Text_Complete;
     }
 
     if (count == 151)
     {
         gSpecialVar_Result = TRUE;
-        return gUnknown_81A7175;
+        return PokedexRating_Text_Complete;
     }
 
-    return gUnknown_81A6D17;
+    return PokedexRating_Text_LessThan10;
 }
 
-void Special_GetProfOaksRatingMessage(void)
+void GetProfOaksRatingMessage(void)
 {
     ShowFieldMessage(GetProfOaksRatingMessageByCount(gSpecialVar_0x8004));
 }
diff --git a/src/quest_log.c b/src/quest_log.c
index a02aea302..91c07223e 100644
--- a/src/quest_log.c
+++ b/src/quest_log.c
@@ -18,10 +18,8 @@
 #include "field_fadetransition.h"
 #include "field_weather.h"
 #include "event_object_movement.h"
-#include "event_object_80688E4.h"
 #include "event_object_lock.h"
 #include "field_player_avatar.h"
-#include "field_control_avatar.h"
 #include "battle.h"
 #include "item.h"
 #include "region_map.h"
@@ -44,6 +42,7 @@
 #include "constants/trainer_classes.h"
 #include "constants/species.h"
 #include "constants/items.h"
+#include "constants/field_weather.h"
 
 u8 gUnknown_3005E88;
 
@@ -115,7 +114,7 @@ static EWRAM_DATA u16 *gUnknown_203AE90 = NULL;
 static EWRAM_DATA struct UnkStruct_203AE94 gUnknown_203AE94 = {0};
 static EWRAM_DATA struct UnkStruct_203AE98 gUnknown_203AE98[32] = {0};
 static EWRAM_DATA u16 sQuestLogIdx = 0;
-static EWRAM_DATA u8 gUnknown_203AF9A[64][2] = {{0}};
+static EWRAM_DATA u8 sMovementScripts[64][2] = {{0}};
 static EWRAM_DATA u16 gUnknown_203B01A = 0;
 static EWRAM_DATA u16 gUnknown_203B01C = 0;
 static EWRAM_DATA u16 sFlagOrVarPlayhead = 0;
@@ -154,7 +153,7 @@ static u8 sub_8111BD4(void);
 static void DrawQuestLogSceneDescription(void);
 static void sub_8111D90(u8);
 static void QuestLog_CloseTextWindow(void);
-static void QuestLog_SkipToEndOfPlayback(s8);
+static void QuestLog_SkipToEndOfPlayback(s8 delay);
 static void QuestLog_WaitFadeAndCancelPlayback(void);
 static bool8 sub_8111F60(void);
 static void sub_8111F8C(u8);
@@ -283,133 +282,6 @@ static bool8 sub_81153A8(u16, const u16 *);
 static bool8 sub_81153E4(u16, const u16 *);
 static void BufferLinkPartnersName(u8 *);
 
-extern const u8 QuestLog_Text_PreviouslyOnYourQuest[];
-extern const u8 QuestLog_Text_SwitchMon1WithMon2[];
-extern const u8 QuestLog_Text_SwappedHeldItemsOnMon[];
-extern const u8 QuestLog_Text_TookHeldItemFromMon[];
-extern const u8 QuestLog_Text_UsedItemOnMonAtThisLocation[];
-extern const u8 QuestLog_Text_UsedTheItem[];
-extern const u8 QuestLog_Text_UsedTheKeyItem[];
-extern const u8 QuestLog_Text_MonLearnedMoveFromTM[];
-extern const u8 QuestLog_Text_MonReplacedMoveWithTM[];
-extern const u8 QuestLog_Text_MonsWereFullyRestoredAtCenter[];
-extern const u8 QuestLog_Text_PlayerBattledChampionRival[];
-extern const u8 QuestLog_Text_PlayerSentOutMon1RivalSentOutMon2[];
-extern const u8 QuestLog_Text_WonTheMatchAsAResult[];
-extern const u8 QuestLog_Text_StoredItemInPC[];
-extern const u8 QuestLog_Text_WithdrewItemFromPC[];
-extern const u8 QuestLog_Text_TradedMon1ForPersonsMon2[];
-extern const u8 QuestLog_Text_SingleBattleWithPersonResultedInOutcome[];
-extern const u8 QuestLog_Text_DoubleBattleWithPersonResultedInOutcome[];
-extern const u8 QuestLog_Text_MultiBattleWithPeopleResultedInOutcome[];
-extern const u8 QuestLog_Text_Win[];
-extern const u8 QuestLog_Text_Loss[];
-extern const u8 QuestLog_Text_MingledInUnionRoom[];
-extern const u8 QuestLog_Text_DepartedPlaceInTownForNextDestination[];
-extern const u8 QuestLog_Text_SwitchedMonsBetweenBoxes[];
-extern const u8 QuestLog_Text_MovedMonToNewBox[];
-extern const u8 QuestLog_Text_SwitchedMonsWithinBox[];
-extern const u8 QuestLog_Text_MovedMonWithinBox[];
-extern const u8 QuestLog_Text_SwitchedPartyMonForPCMon[];
-extern const u8 QuestLog_Text_WithdrewMonFromPC[];
-extern const u8 QuestLog_Text_DepositedMonInPC[];
-extern const u8 QuestLog_Text_SwitchedMultipleMons[];
-extern const u8 QuestLog_Text_ADifferentSpot[];
-extern const u8 QuestLog_Text_GaveMonHeldItemFromPC[];
-extern const u8 QuestLog_Text_SwappedHeldItemFromPC[];
-extern const u8 QuestLog_Text_ChattedWithManyTrainers[];
-extern const u8 QuestLog_Text_Handily[];
-extern const u8 QuestLog_Text_Tenaciously[];
-extern const u8 QuestLog_Text_Somehow[];
-extern const u8 QuestLog_Text_TradedMon1ForTrainersMon2[];
-extern const u8 QuestLog_Text_BattledTrainerEndedInOutcome[];
-extern const u8 QuestLog_Text_BoughtItem[];
-extern const u8 QuestLog_Text_BoughtItemsIncludingItem[];
-extern const u8 QuestLog_Text_SoldNumOfItem[];
-extern const u8 QuestLog_Text_SoldItemsIncludingItem[];
-extern const u8 QuestLog_Text_JustOne[];
-extern const u8 QuestLog_Text_Num[];
-extern const u8 QuestLog_Text_UsedSoftboiled[];
-extern const u8 QuestLog_Text_UsedMilkDrink[];
-extern const u8 QuestLog_Text_MonLearnedMoveFromHM[];
-extern const u8 QuestLog_Text_MonReplacedMoveWithHM[];
-extern const u8 QuestLog_Text_DefeatedWildMon[];
-extern const u8 QuestLog_Text_DefeatedWildMons[];
-extern const u8 QuestLog_Text_CaughtWildMon[];
-extern const u8 QuestLog_Text_CaughtWildMons[];
-extern const u8 QuestLog_Text_DefeatedWildMonAndCaughtWildMon[];
-extern const u8 QuestLog_Text_DefeatedWildMonAndCaughtWildMons[];
-extern const u8 QuestLog_Text_DefeatedWildMonsAndCaughtWildMon[];
-extern const u8 QuestLog_Text_DefeatedWildMonsAndCaughtWildMons[];
-extern const u8 QuestLog_Text_GaveMonHeldItem[];
-extern const u8 QuestLog_Text_GaveMonHeldItem2[];
-extern const u8 QuestLog_Text_UsedCut[];
-extern const u8 QuestLog_Text_UsedFly[];
-extern const u8 QuestLog_Text_UsedSurf[];
-extern const u8 QuestLog_Text_UsedStrength[];
-extern const u8 QuestLog_Text_UsedFlash[];
-extern const u8 QuestLog_Text_UsedRockSmash[];
-extern const u8 QuestLog_Text_UsedWaterfall[];
-extern const u8 QuestLog_Text_UsedDive[];
-extern const u8 QuestLog_Text_UsedDigInLocation[];
-extern const u8 QuestLog_Text_UsedSweetScent[];
-extern const u8 QuestLog_Text_UsedTeleportToLocation[];
-extern const u8 QuestLog_Text_LeftTownsLocationForNextDestination[];
-extern const u8 QuestLog_Text_PlayedGamesAtGameCorner[];
-extern const u8 QuestLog_Text_RestedAtHome[];
-extern const u8 QuestLog_Text_LeftOaksLab[];
-extern const u8 QuestLog_Text_GymWasFullOfToughTrainers[];
-extern const u8 QuestLog_Text_DepartedGym[];
-extern const u8 QuestLog_Text_HadGreatTimeInSafariZone[];
-extern const u8 QuestLog_Text_ManagedToGetOutOfLocation[];
-extern const u8 QuestLog_Text_TookOnGymLeadersMonWithMonAndWon[];
-extern const u8 QuestLog_Text_TookOnEliteFoursMonWithMonAndWon[];
-extern const u8 QuestLog_Text_TookOnTrainersMonWithMonAndWon[];
-extern const u8 QuestLog_Text_Coolly[];
-extern const u8 QuestLog_Text_Barely[];
-extern const u8 QuestLog_Text_UsedEscapeRope[];
-extern const u8 QuestLog_Text_Draw[];
-extern const u8 QuestLog_Text_DepartedTheLocationForNextDestination[];
-extern const u8 QuestLog_Text_DepartedFromLocationToNextDestination[];
-extern const u8 QuestLog_Text_ObtainedItemInLocation[];
-extern const u8 QuestLog_Text_ArrivedInLocation[];
-extern const u8 QuestLog_Text_SavedGameAtLocation[];
-extern const u8 QuestLog_Text_Home[];
-extern const u8 QuestLog_Text_OakResearchLab[];
-extern const u8 QuestLog_Text_Gym[];
-extern const u8 QuestLog_Text_PokemonLeagueGate[];
-extern const u8 QuestLog_Text_ViridianForest[];
-extern const u8 QuestLog_Text_PewterMuseumOfScience[];
-extern const u8 QuestLog_Text_MtMoon[];
-extern const u8 QuestLog_Text_BikeShop[];
-extern const u8 QuestLog_Text_BillsHouse[];
-extern const u8 QuestLog_Text_DayCare[];
-extern const u8 QuestLog_Text_UndergroundPath[];
-extern const u8 QuestLog_Text_PokemonFanClub[];
-extern const u8 QuestLog_Text_SSAnne[];
-extern const u8 QuestLog_Text_DiglettsCave[];
-extern const u8 QuestLog_Text_RockTunnel[];
-extern const u8 QuestLog_Text_PowerPlant[];
-extern const u8 QuestLog_Text_PokemonTower[];
-extern const u8 QuestLog_Text_VolunteerHouse[];
-extern const u8 QuestLog_Text_NameRatersHouse[];
-extern const u8 QuestLog_Text_CeladonDeptStore[];
-extern const u8 QuestLog_Text_CeladonMansion[];
-extern const u8 QuestLog_Text_RocketGameCorner[];
-extern const u8 QuestLog_Text_Restaurant[];
-extern const u8 QuestLog_Text_RocketHideout[];
-extern const u8 QuestLog_Text_SafariZone[];
-extern const u8 QuestLog_Text_WardensHome[];
-extern const u8 QuestLog_Text_FightingDojo[];
-extern const u8 QuestLog_Text_SilphCo[];
-extern const u8 QuestLog_Text_SeafoamIslands[];
-extern const u8 QuestLog_Text_PokemonMansion[];
-extern const u8 QuestLog_Text_PokemonResearchLab[];
-extern const u8 QuestLog_Text_VictoryRoad[];
-extern const u8 QuestLog_Text_PokemonLeague[];
-extern const u8 QuestLog_Text_CeruleanCave[];
-
-
 static const struct WindowTemplate gUnknown_845661C[3] = {
     { 0, 0,  0, 30, 2, 15, 0x0e9 },
     { 0, 0, 18, 30, 2, 15, 0x0ad },
@@ -528,7 +400,7 @@ static void sub_8110A3C(void)
     }
 }
 
-void Special_GetQuestLogState(void)
+void GetQuestLogState(void)
 {
     gSpecialVar_Result = gQuestLogState;
 }
@@ -753,7 +625,7 @@ void DrawPreviouslyOnQuestHeader(u8 sceneNum)
         FillWindowPixelRect(gUnknown_203ADFE[i], 15, 0, 0, gUnknown_845661C[i].width * 8, gUnknown_845661C[i].height * 8);
     }
 
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_PreviouslyOnYourQuest);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_PreviouslyOnYourQuest);
 
     // Scene numbers count from 4 to 0, 0 being where the player saved
     if (sceneNum != 0)
@@ -1049,7 +921,7 @@ static void sub_811175C(u8 sceneNum, struct UnkStruct_203AE98 * a1)
 
 static void sub_81118F4(s8 a0)
 {
-    FadeScreen(1, a0);
+    FadeScreen(FADE_TO_BLACK, a0);
     sQuestLogCB = QuestLog_AdvancePlayhead;
 }
 
@@ -1307,9 +1179,9 @@ static void QuestLog_CloseTextWindow(void)
     CopyWindowToVram(gUnknown_203ADFE[1], 1);
 }
 
-static void QuestLog_SkipToEndOfPlayback(s8 a0)
+static void QuestLog_SkipToEndOfPlayback(s8 delay)
 {
-    FadeScreen(1, a0);
+    FadeScreen(FADE_TO_BLACK, delay);
     sQuestLogCB = QuestLog_WaitFadeAndCancelPlayback;
 }
 
@@ -1372,7 +1244,7 @@ static void Task_QuestLogScene_SavedGame(u8 taskId)
         if (gUnknown_203AE94.unk_0_6 != 1)
         {
             GetMapNameGeneric(gStringVar1, gMapHeader.regionMapSectionId);
-            StringExpandPlaceholders(gStringVar4, QuestLog_Text_SavedGameAtLocation);
+            StringExpandPlaceholders(gStringVar4, gText_QuestLog_SavedGameAtLocation);
             DrawQuestLogSceneDescription();
         }
         task->data[0] = 0;
@@ -1553,24 +1425,24 @@ void sub_811246C(struct Sprite *sprite)
     struct ObjectEvent *objectEvent = &gObjectEvents[sprite->data[0]];
     if (objectEvent->localId == OBJ_EVENT_ID_PLAYER)
     {
-        if (gUnknown_203AF9A[0][0] != OBJ_EVENT_ID_PLAYER)
+        if (sMovementScripts[0][0] != 0xFF)
         {
-            ObjectEventSetHeldMovement(objectEvent, gUnknown_203AF9A[0][0]);
-            gUnknown_203AF9A[0][0] = OBJ_EVENT_ID_PLAYER;
+            ObjectEventSetHeldMovement(objectEvent, sMovementScripts[0][0]);
+            sMovementScripts[0][0] = 0xFF;
         }
-        if (gUnknown_203AF9A[0][1] != OBJ_EVENT_ID_PLAYER)
+        if (sMovementScripts[0][1] != OBJ_EVENT_ID_PLAYER)
         {
             sub_8150454();
-            gUnknown_203AF9A[0][1] = OBJ_EVENT_ID_PLAYER;
+            sMovementScripts[0][1] = OBJ_EVENT_ID_PLAYER;
         }
         sub_8063E28(objectEvent, sprite);
     }
     else
     {
-        if (gUnknown_203AF9A[objectEvent->localId][0] != OBJ_EVENT_ID_PLAYER)
+        if (sMovementScripts[objectEvent->localId][0] != 0xFF)
         {
-            ObjectEventSetHeldMovement(objectEvent, gUnknown_203AF9A[objectEvent->localId][0]);
-            gUnknown_203AF9A[objectEvent->localId][0] = OBJ_EVENT_ID_PLAYER;
+            ObjectEventSetHeldMovement(objectEvent, sMovementScripts[objectEvent->localId][0]);
+            sMovementScripts[objectEvent->localId][0] = 0xFF;
         }
         sub_8063E28(objectEvent, sprite);
     }
@@ -1738,15 +1610,15 @@ static void sub_8112940(u8 a0, struct UnkStruct_203AE98 *a1, u16 a2)
         sNumQuestLogs = a2 / 8;
         for (i = 0; i < 0x40; i++)
         {
-            gUnknown_203AF9A[i][0] |= 0xFF;
-            gUnknown_203AF9A[i][1] |= 0xFF;
+            sMovementScripts[i][0] |= 0xFF;
+            sMovementScripts[i][1] |= 0xFF;
         }
         sQuestLogIdx = 0;
         gUnknown_203B01C = 0;
         gUnknown_3005E90 = (struct UnkStruct_3005E90){};
         gUnknown_203B01A = gUnknown_3005E94[sQuestLogIdx].unk_4;
-        gUnknown_203AF9A[0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3;
-        gUnknown_203AF9A[0][1] = 0xFF;
+        sMovementScripts[0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3;
+        sMovementScripts[0][1] = 0xFF;
         gUnknown_3005E88 = 1;
         break;
     case 2:
@@ -1809,10 +1681,10 @@ void sub_8112B3C(void)
                     switch (gUnknown_3005E94[sQuestLogIdx].unk_6)
                     {
                     case 0:
-                        gUnknown_203AF9A[gUnknown_3005E94[sQuestLogIdx].unk_0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3;
+                        sMovementScripts[gUnknown_3005E94[sQuestLogIdx].unk_0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3;
                         break;
                     case 1:
-                        gUnknown_203AF9A[gUnknown_3005E94[sQuestLogIdx].unk_0][1] = gUnknown_3005E94[sQuestLogIdx].unk_3;
+                        sMovementScripts[gUnknown_3005E94[sQuestLogIdx].unk_0][1] = gUnknown_3005E94[sQuestLogIdx].unk_3;
                         break;
                     case 2:
                         *(u32 *)&gUnknown_3005E90 = ((gUnknown_3005E94[sQuestLogIdx].unk_3 << 24) | (gUnknown_3005E94[sQuestLogIdx].unk_2 << 16) | (gUnknown_3005E94[sQuestLogIdx].unk_1 << 8) | (gUnknown_3005E94[sQuestLogIdx].unk_0 << 0));
@@ -2153,7 +2025,7 @@ void ResetTrainerFanClub(void)
     VarSet(VAR_FANCLUB_LOSE_FAN_TIMER, 0);
 }
 
-void Special_TryLoseFansFromPlayTimeAfterLinkBattle(void)
+void Script_TryLoseFansFromPlayTimeAfterLinkBattle(void)
 {
     TryLoseFansFromPlayTimeAfterLinkBattle(TRAINER_FAN_CLUB);
 }
@@ -2167,7 +2039,7 @@ static void TryLoseFansFromPlayTimeAfterLinkBattle(struct TrainerFanClub *fanClu
     }
 }
 
-void Special_UpdateTrainerFanClubGameClear(void)
+void Script_UpdateTrainerFanClubGameClear(void)
 {
     UpdateTrainerFanClubGameClear(TRAINER_FAN_CLUB);
 }
@@ -2284,7 +2156,7 @@ static u8 PlayerLoseRandomTrainerFan(struct TrainerFanClub *fanClub)
     return sFanClubMemberIds[idx];
 }
 
-u16 Special_GetNumFansOfPlayerInTrainerFanClub(void)
+u16 Script_GetNumFansOfPlayerInTrainerFanClub(void)
 {
     return GetNumFansOfPlayerInTrainerFanClub(TRAINER_FAN_CLUB);
 }
@@ -2303,7 +2175,7 @@ static u16 GetNumFansOfPlayerInTrainerFanClub(struct TrainerFanClub *fanClub)
     return count;
 }
 
-void Special_TryLoseFansFromPlayTime(void)
+void Script_TryLoseFansFromPlayTime(void)
 {
     TryLoseFansFromPlayTime(TRAINER_FAN_CLUB);
 }
@@ -2337,7 +2209,7 @@ static void TryLoseFansFromPlayTime(struct TrainerFanClub *fanClub)
     }
 }
 
-bool16 Special_IsFanClubMemberFanOfPlayer(void)
+bool16 Script_IsFanClubMemberFanOfPlayer(void)
 {
     return IsFanClubMemberFanOfPlayer(TRAINER_FAN_CLUB);
 }
@@ -2354,7 +2226,7 @@ static void SetInitialFansOfPlayer(struct TrainerFanClub *fanClub)
     SET_TRAINER_FAN_CLUB_FLAG(FANCLUB_MEMBER3);
 }
 
-void Special_BufferFanClubTrainerName(void)
+void Script_BufferFanClubTrainerName(void)
 {
     u8 whichLinkTrainer = 0;
     u8 whichNPCTrainer = 0;
@@ -2448,7 +2320,7 @@ static bool8 DidPlayerGetFirstFans(struct TrainerFanClub *fanClub)
     return fanClub->gotInitialFans;
 }
 
-void Special_SetPlayerGotFirstFans(void)
+void Script_SetPlayerGotFirstFans(void)
 {
     SetPlayerGotFirstFans(TRAINER_FAN_CLUB);
 }
@@ -2458,7 +2330,7 @@ static void SetPlayerGotFirstFans(struct TrainerFanClub *fanClub)
     fanClub->gotInitialFans = TRUE;
 }
 
-u8 Special_TryGainNewFanFromCounter(void)
+u8 Script_TryGainNewFanFromCounter(void)
 {
     return TryGainNewFanFromCounter(TRAINER_FAN_CLUB, gSpecialVar_0x8004);
 }
@@ -2602,18 +2474,18 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData)
 static bool8 InQuestLogDisabledLocation(void)
 {
     // In Trainer Tower
-    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_1F)
-        && (gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_1F)
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_2F)
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_3F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_4F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_5F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_6F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_7F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_8F) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_ROOF) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_LOBBY) 
-         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_ELEVATOR)))
+    if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)
+        && (gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_1F)
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_2F)
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_3F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_4F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_5F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_6F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_7F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_8F) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_ROOF) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_LOBBY) 
+         || gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_ELEVATOR)))
         return TRUE;
 
     // In pokemon trainer fan club
@@ -2629,7 +2501,7 @@ static bool8 InQuestLogDisabledLocation(void)
     // In elevator
     if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_ELEVATOR) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROCKET_HIDEOUT_ELEVATOR)) 
      || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SILPH_CO_ELEVATOR) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SILPH_CO_ELEVATOR)) 
-     || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEVEN_ISLAND_TRAINER_TOWER_ELEVATOR) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEVEN_ISLAND_TRAINER_TOWER_ELEVATOR)) 
+     || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(TRAINER_TOWER_ELEVATOR) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(TRAINER_TOWER_ELEVATOR)) 
      || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_ELEVATOR) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_ELEVATOR)))
         return TRUE;
 
@@ -2763,7 +2635,7 @@ static bool8 TrySetTrainerBattleQuestLogEvent(u16 eventId, const u16 *eventData)
         return FALSE;
 
     sub_81138F8();
-    if (gUnknown_3005E88 || FlagGet(FLAG_SYS_GAME_CLEAR) || sub_81137E4(eventId, eventData) != TRUE)
+    if (gUnknown_3005E88 != 0 || FlagGet(FLAG_SYS_GAME_CLEAR) || sub_81137E4(eventId, eventData) != TRUE)
     {
         gUnknown_203B024.unk_00 = eventId;
         memcpy(gUnknown_203B024.unk_04, eventData, 8);
@@ -3172,7 +3044,7 @@ static const u16 *BufferQuestLogText_SwitchedPartyOrder(const u16 *eventData)
     const u16 *r4 = sub_8113E88(QL_EVENT_SWITCHED_PARTY_ORDER, eventData);
     QuestLog_GetSpeciesName(r4[0], gStringVar1, 0);
     QuestLog_GetSpeciesName(r4[1], gStringVar2, 0);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_SwitchMon1WithMon2);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_SwitchMon1WithMon2);
     r4 += 2;
     return r4;
 }
@@ -3206,21 +3078,21 @@ static const u16 *BufferQuestLogText_UsedItem(const u16 *eventData)
         if (r5[0] == ITEM_ESCAPE_ROPE)
         {
             GetMapNameGeneric(gStringVar2, (u8)r5[2]);
-            StringExpandPlaceholders(gStringVar4, QuestLog_Text_UsedEscapeRope);
+            StringExpandPlaceholders(gStringVar4, gText_QuestLog_UsedEscapeRope);
         }
         else if (r5[1] != 0xFFFF)
         {
             QuestLog_GetSpeciesName(r5[1], gStringVar2, 0);
-            StringExpandPlaceholders(gStringVar4, QuestLog_Text_UsedItemOnMonAtThisLocation);
+            StringExpandPlaceholders(gStringVar4, gText_QuestLog_UsedItemOnMonAtThisLocation);
         }
         else
         {
-            StringExpandPlaceholders(gStringVar4, QuestLog_Text_UsedTheItem);
+            StringExpandPlaceholders(gStringVar4, gText_QuestLog_UsedTheItem);
         }
         break;
     case POCKET_KEY_ITEMS:
         StringCopy(gStringVar1, ItemId_GetName(r5[0]));
-        StringExpandPlaceholders(gStringVar4, QuestLog_Text_UsedTheKeyItem);
+        StringExpandPlaceholders(gStringVar4, gText_QuestLog_UsedTheKeyItem);
         break;
     case POCKET_TM_CASE:
         QuestLog_GetSpeciesName(r5[1], gStringVar1, 0);
@@ -3229,16 +3101,16 @@ static const u16 *BufferQuestLogText_UsedItem(const u16 *eventData)
         {
             StringCopy(gStringVar3, gMoveNames[r5[2]]);
             if (r5[0] > ITEM_TM50)
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_MonReplacedMoveWithHM);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_MonReplacedMoveWithHM);
             else
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_MonReplacedMoveWithTM);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_MonReplacedMoveWithTM);
         }
         else
         {
             if (r5[0] > ITEM_TM50)
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_MonLearnedMoveFromHM);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_MonLearnedMoveFromHM);
             else
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_MonLearnedMoveFromTM);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_MonLearnedMoveFromTM);
         }
         break;
     }
@@ -3266,7 +3138,7 @@ static const u16 *BufferQuestLogText_GaveHeldItemFromPartyMenu(const u16 *eventD
     const u16 *r4 = sub_8113E88(QL_EVENT_GAVE_HELD_ITEM, eventData);
     QuestLog_GetSpeciesName(r4[1], gStringVar1, 0);
     StringCopy(gStringVar2, ItemId_GetName(r4[0]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_GaveMonHeldItem);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_GaveMonHeldItem);
     r4 += 2;
     return r4;
 }
@@ -3281,7 +3153,7 @@ static const u16 *BufferQuestLogText_GaveHeldItemFromBagMenu(const u16 *eventDat
     const u16 *r4 = sub_8113E88(QL_EVENT_GAVE_HELD_ITEM_BAG, eventData);
     QuestLog_GetSpeciesName(r4[1], gStringVar1, 0);
     StringCopy(gStringVar2, ItemId_GetName(r4[0]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_GaveMonHeldItem2);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_GaveMonHeldItem2);
     r4 += 2;
     return r4;
 }
@@ -3297,7 +3169,7 @@ static const u16 *BufferQuestLogText_GaveHeldItemFromPC(const u16 *eventData)
 
     QuestLog_GetSpeciesName(r4[1], gStringVar2, 0);
     StringCopy(gStringVar1, ItemId_GetName(r4[0]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_GaveMonHeldItemFromPC);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_GaveMonHeldItemFromPC);
     r4 += 2;
     return r4;
 }
@@ -3313,7 +3185,7 @@ static const u16 *BufferQuestLogText_TookHeldItem(const u16 *eventData)
 
     QuestLog_GetSpeciesName(r4[1], gStringVar1, 0);
     StringCopy(gStringVar2, ItemId_GetName(r4[0]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_TookHeldItemFromMon);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_TookHeldItemFromMon);
     r4 += 2;
     return r4;
 }
@@ -3341,7 +3213,7 @@ static const u16 *BufferQuestLogText_SwappedHeldItem(const u16 *eventData)
     QuestLog_GetSpeciesName(r4[2], gStringVar1, 0);
     StringCopy(gStringVar2, ItemId_GetName(r4[0])); // Item taken
     StringCopy(gStringVar3, ItemId_GetName(r4[1])); // Item given
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_SwappedHeldItemsOnMon);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_SwappedHeldItemsOnMon);
     r4 += 3;
     return r4;
 }
@@ -3357,7 +3229,7 @@ static const u16 *BufferQuestLogText_SwappedHeldItemFromPC(const u16 *eventData)
     QuestLog_GetSpeciesName(r4[2], gStringVar2, 0);
     StringCopy(gStringVar3, ItemId_GetName(r4[0]));
     StringCopy(gStringVar1, ItemId_GetName(r4[1]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_SwappedHeldItemFromPC);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_SwappedHeldItemFromPC);
     r4 += 3;
     return r4;
 }
@@ -3378,7 +3250,7 @@ static u16 *BufferQuestLogData_UsedPkmnCenter(u16 *a0, const u16 *eventData)
 
 static const u16 *BufferQuestLogText_UsedPkmnCenter(const u16 *a0)
 {
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_MonsWereFullyRestoredAtCenter);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_MonsWereFullyRestoredAtCenter);
     a0 += 2;
     return a0;
 }
@@ -3407,27 +3279,27 @@ static const u16 *BufferQuestLogText_LinkTraded(const u16 *a0)
     BufferLinkPartnersName(gStringVar1);
     QuestLog_GetSpeciesName(a0[3], gStringVar2, 0); // Mon received
     QuestLog_GetSpeciesName(a0[2], gStringVar3, 0); // Mon sent
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_TradedMon1ForPersonsMon2);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_TradedMon1ForPersonsMon2);
     r6 += 4;
     return r6;
 }
 
 static const u8 *const sDefeatedOpponentFlavorTexts[] = {
-    QuestLog_Text_Handily,
-    QuestLog_Text_Tenaciously,
-    QuestLog_Text_Somehow
+    gText_QuestLog_Handily,
+    gText_QuestLog_Tenaciously,
+    gText_QuestLog_Somehow
 };
 
 static const u8 *const sDefeatedChampionFlavorTexts[] = {
-    QuestLog_Text_Coolly,
-    QuestLog_Text_Somehow,
-    QuestLog_Text_Barely
+    gText_QuestLog_Coolly,
+    gText_QuestLog_Somehow,
+    gText_QuestLog_Barely
 };
 
 static const u8 *const sBattleOutcomeTexts[] = {
-    QuestLog_Text_Win,
-    QuestLog_Text_Loss,
-    QuestLog_Text_Draw
+    gText_QuestLog_Win,
+    gText_QuestLog_Loss,
+    gText_QuestLog_Draw
 };
 
 static u16 *BufferQuestLogData_LinkBattledSingle(u16 *a0, const u16 *eventData)
@@ -3449,7 +3321,7 @@ static const u16 *BufferQuestLogText_LinkBattledSingle(const u16 *a0)
     BufferLinkPartnersName(gStringVar1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, sBattleOutcomeTexts[((const u8 *)a0)[4]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SingleBattleWithPersonResultedInOutcome);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SingleBattleWithPersonResultedInOutcome);
     a0 += 6;
     return a0;
 }
@@ -3473,7 +3345,7 @@ static const u16 *BufferQuestLogText_LinkBattledDouble(const u16 *a0)
     BufferLinkPartnersName(gStringVar1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, sBattleOutcomeTexts[((const u8 *)a0)[4]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DoubleBattleWithPersonResultedInOutcome);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DoubleBattleWithPersonResultedInOutcome);
     a0 += 6;
     return a0;
 }
@@ -3508,7 +3380,7 @@ static const u16 *BufferQuestLogText_LinkBattledMulti(const u16 *a0)
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, gStringVar2); // opponent 1
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, gStringVar3); // opponent 2
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, sBattleOutcomeTexts[((const u8 *)a0)[4]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_MultiBattleWithPeopleResultedInOutcome);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_MultiBattleWithPeopleResultedInOutcome);
     a0 += 13;
     return a0;
 }
@@ -3522,7 +3394,7 @@ static u16 *BufferQuestLogData_UsedUnionRoom(u16 *a0, const u16 *eventData)
 
 static const u16 *BufferQuestLogText_UsedUnionRoom(const u16 *a0)
 {
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_MingledInUnionRoom);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_MingledInUnionRoom);
     a0 += 2;
     return a0;
 }
@@ -3536,7 +3408,7 @@ static u16 *BufferQuestLogData_UsedUnionRoomChat(u16 *a0, const u16 *eventData)
 
 static const u16 *BufferQuestLogText_UsedUnionRoomChat(const u16 *a0)
 {
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_ChattedWithManyTrainers);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_ChattedWithManyTrainers);
     a0 += 2;
     return a0;
 }
@@ -3561,7 +3433,7 @@ static const u16 *BufferQuestLogText_LinkTradedUnionRoom(const u16 *a0)
     BufferLinkPartnersName(gStringVar1);
     QuestLog_GetSpeciesName(a0[3], gStringVar2, 0);
     QuestLog_GetSpeciesName(a0[2], gStringVar3, 0);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_TradedMon1ForTrainersMon2);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_TradedMon1ForTrainersMon2);
     r6 += 8;
     return (const u16 *)r6;
 }
@@ -3582,7 +3454,7 @@ static const u16 *BufferQuestLogText_LinkBattledUnionRoom(const u16 *a0)
     memcpy(gStringVar1, (const u8 *)a0 + 5, PLAYER_NAME_LENGTH);
     BufferLinkPartnersName(gStringVar1);
     StringCopy(gStringVar2, sBattleOutcomeTexts[*(const u8 *)&a0[2]]);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_BattledTrainerEndedInOutcome);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_BattledTrainerEndedInOutcome);
     a0 += 6;
     return a0;
 }
@@ -3609,7 +3481,7 @@ static const u16 *BufferQuestLogText_SwitchedMonsBetweenBoxes(const u16 *eventDa
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, GetBoxNamePtr(boxIdxs[1]));
     QuestLog_GetSpeciesName(eventData[1], NULL, 3);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SwitchedMonsBetweenBoxes);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SwitchedMonsBetweenBoxes);
     return eventData + 3;
 }
 
@@ -3633,7 +3505,7 @@ static const u16 *BufferQuestLogText_SwitchedMonsWithinBox(const u16 *eventData)
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(boxIdxs[0]));
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
     QuestLog_GetSpeciesName(eventData[1], NULL, 2);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SwitchedMonsWithinBox);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SwitchedMonsWithinBox);
     return eventData + 3;
 }
 
@@ -3669,7 +3541,7 @@ static const u16 *BufferQuestLogText_SwitchedPartyMonForPCMon(const u16 *eventDa
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(boxIdxs[0]));
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
     QuestLog_GetSpeciesName(eventData[1], NULL, 2);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SwitchedPartyMonForPCMon);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SwitchedPartyMonForPCMon);
     return eventData + 3;
 }
 
@@ -3696,7 +3568,7 @@ static const u16 *BufferQuestLogText_MovedMonBetweenBoxes(const u16 *eventData)
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(boxIdxs[0]));
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, GetBoxNamePtr(boxIdxs[1]));
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_MovedMonToNewBox);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_MovedMonToNewBox);
     return (const u16 *)boxIdxs + 1;
 }
 
@@ -3719,7 +3591,7 @@ static const u16 *BufferQuestLogText_MovedMonWithinBox(const u16 *eventData)
     DynamicPlaceholderTextUtil_Reset();
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(boxIdxs[0]));
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_MovedMonWithinBox);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_MovedMonWithinBox);
     return (const u16 *)boxIdxs + 1;
 }
 
@@ -3742,7 +3614,7 @@ static const u16 *BufferQuestLogText_WithdrewMonFromPC(const u16 *eventData)
     DynamicPlaceholderTextUtil_Reset();
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(boxIdxs[0]));
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_WithdrewMonFromPC);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_WithdrewMonFromPC);
     return (const u16 *)boxIdxs + 1;
 }
 
@@ -3765,7 +3637,7 @@ static const u16 *BufferQuestLogText_DepositedMonInPC(const u16 *eventData)
     DynamicPlaceholderTextUtil_Reset();
     QuestLog_GetSpeciesName(eventData[0], NULL, 0);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, GetBoxNamePtr(boxIdxs[0]));
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DepositedMonInPC);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DepositedMonInPC);
     return (const u16 *)boxIdxs + 1;
 }
 
@@ -3786,10 +3658,10 @@ static const u16 *BufferQuestLogText_SwitchedMultipleMons(const u16 *eventData)
     DynamicPlaceholderTextUtil_Reset();
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, GetBoxNamePtr(*((const u8 *)r4 + 0)));
     if (*((const u8 *)r4 + 0) == *((const u8 *)r4 + 1))
-        DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, QuestLog_Text_ADifferentSpot);
+        DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gText_QuestLog_ADifferentSpot);
     else
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, GetBoxNamePtr(*((const u8 *)r4 + 1)));
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SwitchedMultipleMons);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SwitchedMultipleMons);
     return r4 + 1;
 }
 
@@ -3806,7 +3678,7 @@ static const u16 *BufferQuestLogText_DepositedItemInPC(const u16 *eventData)
 {
     const u16 *r4 = sub_8113E88(QL_EVENT_DEPOSITED_ITEM_PC, eventData);
     CopyItemName(r4[0], gStringVar1);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_StoredItemInPC);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_StoredItemInPC);
     return r4 + 1;
 }
 
@@ -3823,7 +3695,7 @@ static const u16 *BufferQuestLogText_WithdrewItemFromPC(const u16 *eventData)
 {
     const u16 *r4 = sub_8113E88(QL_EVENT_WITHDREW_ITEM_PC, eventData);
     CopyItemName(r4[0], gStringVar1);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_WithdrewItemFromPC);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_WithdrewItemFromPC);
     return r4 + 1;
 }
 
@@ -3858,7 +3730,7 @@ static const u16 *BufferQuestLogText_DefeatedGymLeader(const u16 *eventData)
     QuestLog_GetSpeciesName(eventData[0], 0, 2);
     QuestLog_GetSpeciesName(eventData[1], 0, 3);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, sDefeatedOpponentFlavorTexts[r6[1]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_TookOnGymLeadersMonWithMonAndWon);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_TookOnGymLeadersMonWithMonAndWon);
     return eventData + 4;
 }
 
@@ -3905,30 +3777,30 @@ static const u16 *BufferQuestLogText_DefeatedWildMon(const u16 *a0)
     if (data[0] == 0)
     {
         if (data[1] == 1)
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_CaughtWildMon);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_CaughtWildMon);
         else
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_CaughtWildMons);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_CaughtWildMons);
     }
     else if (data[1] == 0)
     {
         if (data[0] == 1)
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMon);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMon);
         else
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMons);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMons);
     }
     else if (data[0] == 1)
     {
         if (data[1] == 1)
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMonAndCaughtWildMon);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMonAndCaughtWildMon);
         else
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMonAndCaughtWildMons);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMonAndCaughtWildMons);
     }
     else
     {
         if (data[1] == 1)
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMonsAndCaughtWildMon);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMonsAndCaughtWildMon);
         else
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_DefeatedWildMonsAndCaughtWildMons);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_DefeatedWildMonsAndCaughtWildMons);
     }
     return (const u16 *)(data + 4);
 }
@@ -3966,7 +3838,7 @@ static const u16 *BufferQuestLogText_DefeatedEliteFourMember(const u16 *eventDat
     QuestLog_GetSpeciesName(eventData[0], NULL, 1);
     QuestLog_GetSpeciesName(eventData[1], NULL, 2);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, sDefeatedOpponentFlavorTexts[r5[1]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_TookOnEliteFoursMonWithMonAndWon);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_TookOnEliteFoursMonWithMonAndWon);
     return eventData + 4;
 }
 
@@ -3997,18 +3869,18 @@ static const u16 *BufferQuestLogText_DefeatedChampion(const u16 *a0)
     case 0:
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gSaveBlock2Ptr->playerName);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gSaveBlock1Ptr->rivalName);
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_PlayerBattledChampionRival);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_PlayerBattledChampionRival);
         break;
     case 1:
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gSaveBlock1Ptr->rivalName);
         QuestLog_GetSpeciesName(a0[2], NULL, 1);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, gSaveBlock2Ptr->playerName);
         QuestLog_GetSpeciesName(a0[3], NULL, 3);
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_PlayerSentOutMon1RivalSentOutMon2);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_PlayerSentOutMon1RivalSentOutMon2);
         break;
     case 2:
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, sDefeatedChampionFlavorTexts[r5[0]]);
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_WonTheMatchAsAResult);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_WonTheMatchAsAResult);
         break;
     }
     return (const u16 *)(r5 + 2);
@@ -4038,77 +3910,77 @@ static const u16 *BufferQuestLogText_DefeatedTrainer(const u16 *eventData)
     QuestLog_GetSpeciesName(r5[0], NULL, 2);
     QuestLog_GetSpeciesName(r5[1], NULL, 3);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, sDefeatedOpponentFlavorTexts[r6[1]]);
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_TookOnTrainersMonWithMonAndWon);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_TookOnTrainersMonWithMonAndWon);
     return (const u16 *)(r6 + 2);
 }
 
 static const u8 *const sLocationNameTexts[] = 
 {
-    [QL_LOCATION_HOME]               = QuestLog_Text_Home,
-    [QL_LOCATION_OAKS_LAB]           = QuestLog_Text_OakResearchLab,
-    [QL_LOCATION_VIRIDIAN_GYM]       = QuestLog_Text_Gym,
-    [QL_LOCATION_LEAGUE_GATE_1]      = QuestLog_Text_PokemonLeagueGate,
-    [QL_LOCATION_LEAGUE_GATE_2]      = QuestLog_Text_PokemonLeagueGate,
-    [QL_LOCATION_VIRIDIAN_FOREST_1]  = QuestLog_Text_ViridianForest,
-    [QL_LOCATION_VIRIDIAN_FOREST_2]  = QuestLog_Text_ViridianForest,
-    [QL_LOCATION_PEWTER_MUSEUM]      = QuestLog_Text_PewterMuseumOfScience,
-    [QL_LOCATION_PEWTER_GYM]         = QuestLog_Text_Gym,
-    [QL_LOCATION_MT_MOON_1]          = QuestLog_Text_MtMoon,
-    [QL_LOCATION_MT_MOON_2]          = QuestLog_Text_MtMoon,
-    [QL_LOCATION_CERULEAN_GYM]       = QuestLog_Text_Gym,
-    [QL_LOCATION_BIKE_SHOP]          = QuestLog_Text_BikeShop,
-    [QL_LOCATION_BILLS_HOUSE]        = QuestLog_Text_BillsHouse,
-    [QL_LOCATION_DAY_CARE]           = QuestLog_Text_DayCare,
-    [QL_LOCATION_UNDERGROUND_PATH_1] = QuestLog_Text_UndergroundPath,
-    [QL_LOCATION_UNDERGROUND_PATH_2] = QuestLog_Text_UndergroundPath,
-    [QL_LOCATION_PKMN_FAN_CLUB]      = QuestLog_Text_PokemonFanClub,
-    [QL_LOCATION_VERMILION_GYM]      = QuestLog_Text_Gym,
-    [QL_LOCATION_SS_ANNE]            = QuestLog_Text_SSAnne,
-    [QL_LOCATION_DIGLETTS_CAVE_1]    = QuestLog_Text_DiglettsCave,
-    [QL_LOCATION_DIGLETTS_CAVE_2]    = QuestLog_Text_DiglettsCave,
-    [QL_LOCATION_ROCK_TUNNEL_1]      = QuestLog_Text_RockTunnel,
-    [QL_LOCATION_ROCK_TUNNEL_2]      = QuestLog_Text_RockTunnel,
-    [QL_LOCATION_POWER_PLANT]        = QuestLog_Text_PowerPlant,
-    [QL_LOCATION_PKMN_TOWER]         = QuestLog_Text_PokemonTower,
-    [QL_LOCATION_VOLUNTEER_HOUSE]    = QuestLog_Text_VolunteerHouse,
-    [QL_LOCATION_NAME_RATERS_HOUSE]  = QuestLog_Text_NameRatersHouse,
-    [QL_LOCATION_UNDERGROUND_PATH_3] = QuestLog_Text_UndergroundPath,
-    [QL_LOCATION_UNDERGROUND_PATH_4] = QuestLog_Text_UndergroundPath,
-    [QL_LOCATION_CELADON_DEPT_STORE] = QuestLog_Text_CeladonDeptStore,
-    [QL_LOCATION_CELADON_MANSION]    = QuestLog_Text_CeladonMansion,
-    [QL_LOCATION_GAME_CORNER]        = QuestLog_Text_RocketGameCorner,
-    [QL_LOCATION_CELADON_GYM]        = QuestLog_Text_Gym,
-    [QL_LOCATION_CELADON_RESTAURANT] = QuestLog_Text_Restaurant,
-    [QL_LOCATION_ROCKET_HIDEOUT]     = QuestLog_Text_RocketHideout,
-    [QL_LOCATION_SAFARI_ZONE]        = QuestLog_Text_SafariZone,
-    [QL_LOCATION_FUCHSIA_GYM]        = QuestLog_Text_Gym,
-    [QL_LOCATION_WARDENS_HOME]       = QuestLog_Text_WardensHome,
-    [QL_LOCATION_FIGHTING_DOJO]      = QuestLog_Text_FightingDojo,
-    [QL_LOCATION_SAFFRON_GYM]        = QuestLog_Text_Gym,
-    [QL_LOCATION_SILPH_CO]           = QuestLog_Text_SilphCo,
-    [QL_LOCATION_SEAFOAM_ISLANDS_1]  = QuestLog_Text_SeafoamIslands,
-    [QL_LOCATION_SEAFOAM_ISLANDS_2]  = QuestLog_Text_SeafoamIslands,
-    [QL_LOCATION_PKMN_MANSION]       = QuestLog_Text_PokemonMansion,
-    [QL_LOCATION_CINNABAR_GYM]       = QuestLog_Text_Gym,
-    [QL_LOCATION_CINNABAR_LAB]       = QuestLog_Text_PokemonResearchLab,
-    [QL_LOCATION_VICTORY_ROAD_1]     = QuestLog_Text_VictoryRoad,
-    [QL_LOCATION_VICTORY_ROAD_2]     = QuestLog_Text_VictoryRoad,
-    [QL_LOCATION_PKMN_LEAGUE]        = QuestLog_Text_PokemonLeague,
-    [QL_LOCATION_CERULEAN_CAVE]      = QuestLog_Text_CeruleanCave
+    [QL_LOCATION_HOME]               = gText_QuestLog_Home,
+    [QL_LOCATION_OAKS_LAB]           = gText_QuestLog_OakResearchLab,
+    [QL_LOCATION_VIRIDIAN_GYM]       = gText_QuestLog_Gym,
+    [QL_LOCATION_LEAGUE_GATE_1]      = gText_QuestLog_PokemonLeagueGate,
+    [QL_LOCATION_LEAGUE_GATE_2]      = gText_QuestLog_PokemonLeagueGate,
+    [QL_LOCATION_VIRIDIAN_FOREST_1]  = gText_QuestLog_ViridianForest,
+    [QL_LOCATION_VIRIDIAN_FOREST_2]  = gText_QuestLog_ViridianForest,
+    [QL_LOCATION_PEWTER_MUSEUM]      = gText_QuestLog_PewterMuseumOfScience,
+    [QL_LOCATION_PEWTER_GYM]         = gText_QuestLog_Gym,
+    [QL_LOCATION_MT_MOON_1]          = gText_QuestLog_MtMoon,
+    [QL_LOCATION_MT_MOON_2]          = gText_QuestLog_MtMoon,
+    [QL_LOCATION_CERULEAN_GYM]       = gText_QuestLog_Gym,
+    [QL_LOCATION_BIKE_SHOP]          = gText_QuestLog_BikeShop,
+    [QL_LOCATION_BILLS_HOUSE]        = gText_QuestLog_BillsHouse,
+    [QL_LOCATION_DAY_CARE]           = gText_QuestLog_DayCare,
+    [QL_LOCATION_UNDERGROUND_PATH_1] = gText_QuestLog_UndergroundPath,
+    [QL_LOCATION_UNDERGROUND_PATH_2] = gText_QuestLog_UndergroundPath,
+    [QL_LOCATION_PKMN_FAN_CLUB]      = gText_QuestLog_PokemonFanClub,
+    [QL_LOCATION_VERMILION_GYM]      = gText_QuestLog_Gym,
+    [QL_LOCATION_SS_ANNE]            = gText_QuestLog_SSAnne,
+    [QL_LOCATION_DIGLETTS_CAVE_1]    = gText_QuestLog_DiglettsCave,
+    [QL_LOCATION_DIGLETTS_CAVE_2]    = gText_QuestLog_DiglettsCave,
+    [QL_LOCATION_ROCK_TUNNEL_1]      = gText_QuestLog_RockTunnel,
+    [QL_LOCATION_ROCK_TUNNEL_2]      = gText_QuestLog_RockTunnel,
+    [QL_LOCATION_POWER_PLANT]        = gText_QuestLog_PowerPlant,
+    [QL_LOCATION_PKMN_TOWER]         = gText_QuestLog_PokemonTower,
+    [QL_LOCATION_VOLUNTEER_HOUSE]    = gText_QuestLog_VolunteerHouse,
+    [QL_LOCATION_NAME_RATERS_HOUSE]  = gText_QuestLog_NameRatersHouse,
+    [QL_LOCATION_UNDERGROUND_PATH_3] = gText_QuestLog_UndergroundPath,
+    [QL_LOCATION_UNDERGROUND_PATH_4] = gText_QuestLog_UndergroundPath,
+    [QL_LOCATION_CELADON_DEPT_STORE] = gText_QuestLog_CeladonDeptStore,
+    [QL_LOCATION_CELADON_MANSION]    = gText_QuestLog_CeladonMansion,
+    [QL_LOCATION_GAME_CORNER]        = gText_QuestLog_RocketGameCorner,
+    [QL_LOCATION_CELADON_GYM]        = gText_QuestLog_Gym,
+    [QL_LOCATION_CELADON_RESTAURANT] = gText_QuestLog_Restaurant,
+    [QL_LOCATION_ROCKET_HIDEOUT]     = gText_QuestLog_RocketHideout,
+    [QL_LOCATION_SAFARI_ZONE]        = gText_QuestLog_SafariZone,
+    [QL_LOCATION_FUCHSIA_GYM]        = gText_QuestLog_Gym,
+    [QL_LOCATION_WARDENS_HOME]       = gText_QuestLog_WardensHome,
+    [QL_LOCATION_FIGHTING_DOJO]      = gText_QuestLog_FightingDojo,
+    [QL_LOCATION_SAFFRON_GYM]        = gText_QuestLog_Gym,
+    [QL_LOCATION_SILPH_CO]           = gText_QuestLog_SilphCo,
+    [QL_LOCATION_SEAFOAM_ISLANDS_1]  = gText_QuestLog_SeafoamIslands,
+    [QL_LOCATION_SEAFOAM_ISLANDS_2]  = gText_QuestLog_SeafoamIslands,
+    [QL_LOCATION_PKMN_MANSION]       = gText_QuestLog_PokemonMansion,
+    [QL_LOCATION_CINNABAR_GYM]       = gText_QuestLog_Gym,
+    [QL_LOCATION_CINNABAR_LAB]       = gText_QuestLog_PokemonResearchLab,
+    [QL_LOCATION_VICTORY_ROAD_1]     = gText_QuestLog_VictoryRoad,
+    [QL_LOCATION_VICTORY_ROAD_2]     = gText_QuestLog_VictoryRoad,
+    [QL_LOCATION_PKMN_LEAGUE]        = gText_QuestLog_PokemonLeague,
+    [QL_LOCATION_CERULEAN_CAVE]      = gText_QuestLog_CeruleanCave
 };
 
 static const u8 *const sDepartedLocationTexts[] = 
 {
-    [QL_DEPARTED_TOWN_BUILDING]   = QuestLog_Text_DepartedPlaceInTownForNextDestination,
-    [QL_DEPARTED_MUSEUM]          = QuestLog_Text_LeftTownsLocationForNextDestination,
-    [QL_DEPARTED_GAME_CORNER]     = QuestLog_Text_PlayedGamesAtGameCorner,
-    [QL_DEPARTED_HOME]            = QuestLog_Text_RestedAtHome,
-    [QL_DEPARTED_OAKS_LAB]        = QuestLog_Text_LeftOaksLab,
-    [QL_DEPARTED_GYM]             = QuestLog_Text_GymWasFullOfToughTrainers,
-    [QL_DEPARTED_SAFARI_ZONE]     = QuestLog_Text_HadGreatTimeInSafariZone,
-    [QL_DEPARTED_CAVE]            = QuestLog_Text_ManagedToGetOutOfLocation,
-    [QL_DEPARTED_MISC_BUILDING_1] = QuestLog_Text_DepartedTheLocationForNextDestination,
-    [QL_DEPARTED_MISC_BUILDING_2] = QuestLog_Text_DepartedFromLocationToNextDestination
+    [QL_DEPARTED_TOWN_BUILDING]   = gText_QuestLog_DepartedPlaceInTownForNextDestination,
+    [QL_DEPARTED_MUSEUM]          = gText_QuestLog_LeftTownsLocationForNextDestination,
+    [QL_DEPARTED_GAME_CORNER]     = gText_QuestLog_PlayedGamesAtGameCorner,
+    [QL_DEPARTED_HOME]            = gText_QuestLog_RestedAtHome,
+    [QL_DEPARTED_OAKS_LAB]        = gText_QuestLog_LeftOaksLab,
+    [QL_DEPARTED_GYM]             = gText_QuestLog_GymWasFullOfToughTrainers,
+    [QL_DEPARTED_SAFARI_ZONE]     = gText_QuestLog_HadGreatTimeInSafariZone,
+    [QL_DEPARTED_CAVE]            = gText_QuestLog_ManagedToGetOutOfLocation,
+    [QL_DEPARTED_MISC_BUILDING_1] = gText_QuestLog_DepartedTheLocationForNextDestination,
+    [QL_DEPARTED_MISC_BUILDING_2] = gText_QuestLog_DepartedFromLocationToNextDestination
 };
 
 static const u8 sLocationToDepartedTextId[] = 
@@ -4179,18 +4051,18 @@ static const u8 gUnknown_8456C17[] = {
 
 static const u8 *const sUsedFieldMoveTexts[] = 
 {
-    [FIELD_MOVE_FLASH]       = QuestLog_Text_UsedFlash,
-    [FIELD_MOVE_CUT]         = QuestLog_Text_UsedCut,
-    [FIELD_MOVE_FLY]         = QuestLog_Text_UsedFly,
-    [FIELD_MOVE_STRENGTH]    = QuestLog_Text_UsedStrength,
-    [FIELD_MOVE_SURF]        = QuestLog_Text_UsedSurf,
-    [FIELD_MOVE_ROCK_SMASH]  = QuestLog_Text_UsedRockSmash,
-    [FIELD_MOVE_WATERFALL]   = QuestLog_Text_UsedWaterfall,
-    [FIELD_MOVE_TELEPORT]    = QuestLog_Text_UsedTeleportToLocation,
-    [FIELD_MOVE_DIG]         = QuestLog_Text_UsedDigInLocation,
-    [FIELD_MOVE_MILK_DRINK]  = QuestLog_Text_UsedMilkDrink,
-    [FIELD_MOVE_SOFT_BOILED] = QuestLog_Text_UsedSoftboiled,
-    [FIELD_MOVE_SWEET_SCENT] = QuestLog_Text_UsedSweetScent
+    [FIELD_MOVE_FLASH]       = gText_QuestLog_UsedFlash,
+    [FIELD_MOVE_CUT]         = gText_QuestLog_UsedCut,
+    [FIELD_MOVE_FLY]         = gText_QuestLog_UsedFly,
+    [FIELD_MOVE_STRENGTH]    = gText_QuestLog_UsedStrength,
+    [FIELD_MOVE_SURF]        = gText_QuestLog_UsedSurf,
+    [FIELD_MOVE_ROCK_SMASH]  = gText_QuestLog_UsedRockSmash,
+    [FIELD_MOVE_WATERFALL]   = gText_QuestLog_UsedWaterfall,
+    [FIELD_MOVE_TELEPORT]    = gText_QuestLog_UsedTeleportToLocation,
+    [FIELD_MOVE_DIG]         = gText_QuestLog_UsedDigInLocation,
+    [FIELD_MOVE_MILK_DRINK]  = gText_QuestLog_UsedMilkDrink,
+    [FIELD_MOVE_SOFT_BOILED] = gText_QuestLog_UsedSoftboiled,
+    [FIELD_MOVE_SWEET_SCENT] = gText_QuestLog_UsedSweetScent
 };
 
 static u16 *BufferQuestLogData_DepartedLocation(u16 *a0, const u16 *eventData)
@@ -4219,9 +4091,9 @@ static const u16 *BufferQuestLogText_DepartedLocation(const u16 *eventData)
             if (r5_2[0] != gUnknown_8456C17[r4])
                 continue;
             if (FlagGet(FLAG_BADGE01_GET + r4) == TRUE)
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_DepartedGym);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_DepartedGym);
             else
-                StringExpandPlaceholders(gStringVar4, QuestLog_Text_GymWasFullOfToughTrainers);
+                StringExpandPlaceholders(gStringVar4, gText_QuestLog_GymWasFullOfToughTrainers);
             break;
         }
         if (r4 == 8)
@@ -4292,7 +4164,7 @@ static const u16 *BufferQuestLogText_UsedFieldMove(const u16 *eventData)
     if (r5[0] == FIELD_MOVE_TELEPORT)
     {
         if (r5[1] == 0x58)
-            StringCopy(gStringVar3, QuestLog_Text_Home);
+            StringCopy(gStringVar3, gText_QuestLog_Home);
         else
             StringCopy(gStringVar3, gText_PokemonCenter);
     }
@@ -4325,12 +4197,12 @@ static const u16 *BufferQuestLogText_BoughtItem(const u16 *eventData)
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, ItemId_GetName(r4[0]));
     if (r4[1] < 2)
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_BoughtItem);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_BoughtItem);
     else
     {
         ConvertIntToDecimalStringN(gStringVar2, r6, STR_CONV_MODE_LEFT_ALIGN, 6);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, gStringVar2);
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_BoughtItemsIncludingItem);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_BoughtItemsIncludingItem);
     }
     return (const u16 *)(r7 + 2);
 }
@@ -4361,15 +4233,15 @@ static const u16 *BufferQuestLogText_SoldItem(const u16 *eventData)
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gStringVar1);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, ItemId_GetName(r5[0]));
         if (r5[1] == 1)
-            DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, QuestLog_Text_JustOne);
+            DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, gText_QuestLog_JustOne);
         else
         {
             ConvertIntToDecimalStringN(gStringVar2, r5[1], STR_CONV_MODE_LEFT_ALIGN, 3);
             DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, gStringVar2);
-            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar3, QuestLog_Text_Num);
+            DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar3, gText_QuestLog_Num);
             DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, gStringVar3);
         }
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SoldNumOfItem);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SoldNumOfItem);
     }
     else
     {
@@ -4377,7 +4249,7 @@ static const u16 *BufferQuestLogText_SoldItem(const u16 *eventData)
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, ItemId_GetName(r5[0]));
         ConvertIntToDecimalStringN(gStringVar2, r6, STR_CONV_MODE_LEFT_ALIGN, 6);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, gStringVar2);
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, QuestLog_Text_SoldItemsIncludingItem);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_QuestLog_SoldItemsIncludingItem);
     }
     return (const u16 *)(r7 + 2);
 }
@@ -4398,7 +4270,7 @@ static const u16 *BufferQuestLogText_ObtainedItem(const u16 *eventData)
     const u8 *r5 = (const u8 *)r4 + 2;
     GetMapNameGeneric(gStringVar1, r5[0]);
     StringCopy(gStringVar2, ItemId_GetName(r4[0]));
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_ObtainedItemInLocation);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_ObtainedItemInLocation);
     return (const u16 *)(r5 + 2);
 }
 
@@ -4423,7 +4295,7 @@ static const u16 sQuestLogWorldMapFlags[] =
     FLAG_WORLD_MAP_SIX_ISLAND
 };
 
-void sub_8115748(u16 worldMapFlag)
+void QuestLog_RecordEnteredMap(u16 worldMapFlag)
 {
     s32 i;
 
@@ -4476,7 +4348,7 @@ static const u16 *BufferQuestLogText_ArrivedInLocation(const u16 *eventData)
 {
     const u16 *r4 = sub_8113E88(QL_EVENT_ARRIVED, eventData);
     GetMapNameGeneric(gStringVar1, (u8)r4[0]);
-    StringExpandPlaceholders(gStringVar4, QuestLog_Text_ArrivedInLocation);
+    StringExpandPlaceholders(gStringVar4, gText_QuestLog_ArrivedInLocation);
     return r4 + 1;
 }
 
diff --git a/src/quest_log_objects.c b/src/quest_log_objects.c
index c021bbb61..2c17987e8 100644
--- a/src/quest_log_objects.c
+++ b/src/quest_log_objects.c
@@ -1,11 +1,8 @@
 #include "global.h"
-#include "event_data.h"
 #include "quest_log.h"
 #include "fieldmap.h"
 #include "field_player_avatar.h"
 #include "metatile_behavior.h"
-#include "link.h"
-#include "link_rfu.h"
 
 void SetQuestLogObjectEventsData(struct QuestLog * questLog)
 {
@@ -14,22 +11,22 @@ void SetQuestLogObjectEventsData(struct QuestLog * questLog)
     for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
     {
         questLog->unk_008[i].active = gObjectEvents[i].active;
-        questLog->unk_008[i].mapobj_bit_3 = gObjectEvents[i].triggerGroundEffectsOnStop;
-        questLog->unk_008[i].mapobj_bit_4 = gObjectEvents[i].disableCoveringGroundEffects;
-        questLog->unk_008[i].mapobj_bit_5 = gObjectEvents[i].landingJump;
-        questLog->unk_008[i].mapobj_bit_8 = gObjectEvents[i].frozen;
-        questLog->unk_008[i].mapobj_bit_9 = gObjectEvents[i].facingDirectionLocked;
-        questLog->unk_008[i].mapobj_bit_10 = gObjectEvents[i].disableAnim;
-        questLog->unk_008[i].mapobj_bit_11 = gObjectEvents[i].enableAnim;
-        questLog->unk_008[i].mapobj_bit_12 = gObjectEvents[i].inanimate;
-        questLog->unk_008[i].mapobj_bit_13 = gObjectEvents[i].invisible;
-        questLog->unk_008[i].mapobj_bit_14 = gObjectEvents[i].offScreen;
-        questLog->unk_008[i].mapobj_bit_15 = gObjectEvents[i].trackedByCamera;
-        questLog->unk_008[i].mapobj_bit_16 = gObjectEvents[i].isPlayer;
-        questLog->unk_008[i].mapobj_bit_23 = gObjectEvents[i].spriteAnimPausedBackup;
-        questLog->unk_008[i].mapobj_bit_24 = gObjectEvents[i].spriteAffineAnimPausedBackup;
-        questLog->unk_008[i].mapobj_bit_25 = gObjectEvents[i].disableJumpLandingGroundEffect;
-        questLog->unk_008[i].mapobj_bit_26 = gObjectEvents[i].fixedPriority;
+        questLog->unk_008[i].triggerGroundEffectsOnStop = gObjectEvents[i].triggerGroundEffectsOnStop;
+        questLog->unk_008[i].disableCoveringGroundEffects = gObjectEvents[i].disableCoveringGroundEffects;
+        questLog->unk_008[i].landingJump = gObjectEvents[i].landingJump;
+        questLog->unk_008[i].frozen = gObjectEvents[i].frozen;
+        questLog->unk_008[i].facingDirectionLocked = gObjectEvents[i].facingDirectionLocked;
+        questLog->unk_008[i].disableAnim = gObjectEvents[i].disableAnim;
+        questLog->unk_008[i].enableAnim = gObjectEvents[i].enableAnim;
+        questLog->unk_008[i].inanimate = gObjectEvents[i].inanimate;
+        questLog->unk_008[i].invisible = gObjectEvents[i].invisible;
+        questLog->unk_008[i].offScreen = gObjectEvents[i].offScreen;
+        questLog->unk_008[i].trackedByCamera = gObjectEvents[i].trackedByCamera;
+        questLog->unk_008[i].isPlayer = gObjectEvents[i].isPlayer;
+        questLog->unk_008[i].spriteAnimPausedBackup = gObjectEvents[i].spriteAnimPausedBackup;
+        questLog->unk_008[i].spriteAffineAnimPausedBackup = gObjectEvents[i].spriteAffineAnimPausedBackup;
+        questLog->unk_008[i].disableJumpLandingGroundEffect = gObjectEvents[i].disableJumpLandingGroundEffect;
+        questLog->unk_008[i].fixedPriority = gObjectEvents[i].fixedPriority;
         questLog->unk_008[i].mapobj_unk_18 = gObjectEvents[i].facingDirection;
         questLog->unk_008[i].mapobj_unk_0B_0 = gObjectEvents[i].currentElevation;
         questLog->unk_008[i].elevation = gObjectEvents[i].previousElevation;
@@ -42,8 +39,8 @@ void SetQuestLogObjectEventsData(struct QuestLog * questLog)
         questLog->unk_008[i].x = gObjectEvents[i].currentCoords.x;
         questLog->unk_008[i].y = gObjectEvents[i].currentCoords.y;
         questLog->unk_008[i].trainerRange_berryTreeId = gObjectEvents[i].trainerRange_berryTreeId;
-        questLog->unk_008[i].mapobj_unk_1F = gObjectEvents[i].previousMetatileBehavior;
-        questLog->unk_008[i].mapobj_unk_21 = gObjectEvents[i].directionSequenceIndex;
+        questLog->unk_008[i].previousMetatileBehavior = gObjectEvents[i].previousMetatileBehavior;
+        questLog->unk_008[i].directionSequenceIndex = gObjectEvents[i].directionSequenceIndex;
         questLog->unk_008[i].animId = gObjectEvents[i].playerCopyableMovement;
     }
 }
@@ -58,22 +55,22 @@ void sub_815A1F8(const struct QuestLog * questLog, const struct ObjectEventTempl
     for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
     {
         gObjectEvents[i].active = questLogObjectEvents[i].active;
-        gObjectEvents[i].triggerGroundEffectsOnStop = questLogObjectEvents[i].mapobj_bit_3;
-        gObjectEvents[i].disableCoveringGroundEffects = questLogObjectEvents[i].mapobj_bit_4;
-        gObjectEvents[i].landingJump = questLogObjectEvents[i].mapobj_bit_5;
-        gObjectEvents[i].frozen = questLogObjectEvents[i].mapobj_bit_8;
-        gObjectEvents[i].facingDirectionLocked = questLogObjectEvents[i].mapobj_bit_9;
-        gObjectEvents[i].disableAnim = questLogObjectEvents[i].mapobj_bit_10;
-        gObjectEvents[i].enableAnim = questLogObjectEvents[i].mapobj_bit_11;
-        gObjectEvents[i].inanimate = questLogObjectEvents[i].mapobj_bit_12;
-        gObjectEvents[i].invisible = questLogObjectEvents[i].mapobj_bit_13;
-        gObjectEvents[i].offScreen = questLogObjectEvents[i].mapobj_bit_14;
-        gObjectEvents[i].trackedByCamera = questLogObjectEvents[i].mapobj_bit_15;
-        gObjectEvents[i].isPlayer = questLogObjectEvents[i].mapobj_bit_16;
-        gObjectEvents[i].spriteAnimPausedBackup = questLogObjectEvents[i].mapobj_bit_23;
-        gObjectEvents[i].spriteAffineAnimPausedBackup = questLogObjectEvents[i].mapobj_bit_24;
-        gObjectEvents[i].disableJumpLandingGroundEffect = questLogObjectEvents[i].mapobj_bit_25;
-        gObjectEvents[i].fixedPriority = questLogObjectEvents[i].mapobj_bit_26;
+        gObjectEvents[i].triggerGroundEffectsOnStop = questLogObjectEvents[i].triggerGroundEffectsOnStop;
+        gObjectEvents[i].disableCoveringGroundEffects = questLogObjectEvents[i].disableCoveringGroundEffects;
+        gObjectEvents[i].landingJump = questLogObjectEvents[i].landingJump;
+        gObjectEvents[i].frozen = questLogObjectEvents[i].frozen;
+        gObjectEvents[i].facingDirectionLocked = questLogObjectEvents[i].facingDirectionLocked;
+        gObjectEvents[i].disableAnim = questLogObjectEvents[i].disableAnim;
+        gObjectEvents[i].enableAnim = questLogObjectEvents[i].enableAnim;
+        gObjectEvents[i].inanimate = questLogObjectEvents[i].inanimate;
+        gObjectEvents[i].invisible = questLogObjectEvents[i].invisible;
+        gObjectEvents[i].offScreen = questLogObjectEvents[i].offScreen;
+        gObjectEvents[i].trackedByCamera = questLogObjectEvents[i].trackedByCamera;
+        gObjectEvents[i].isPlayer = questLogObjectEvents[i].isPlayer;
+        gObjectEvents[i].spriteAnimPausedBackup = questLogObjectEvents[i].spriteAnimPausedBackup;
+        gObjectEvents[i].spriteAffineAnimPausedBackup = questLogObjectEvents[i].spriteAffineAnimPausedBackup;
+        gObjectEvents[i].disableJumpLandingGroundEffect = questLogObjectEvents[i].disableJumpLandingGroundEffect;
+        gObjectEvents[i].fixedPriority = questLogObjectEvents[i].fixedPriority;
         gObjectEvents[i].facingDirection = questLogObjectEvents[i].mapobj_unk_18;
         gObjectEvents[i].currentElevation = questLogObjectEvents[i].mapobj_unk_0B_0;
         gObjectEvents[i].previousElevation = questLogObjectEvents[i].elevation;
@@ -86,8 +83,8 @@ void sub_815A1F8(const struct QuestLog * questLog, const struct ObjectEventTempl
         gObjectEvents[i].currentCoords.x = questLogObjectEvents[i].x;
         gObjectEvents[i].currentCoords.y = questLogObjectEvents[i].y;
         gObjectEvents[i].trainerRange_berryTreeId = questLogObjectEvents[i].trainerRange_berryTreeId;
-        gObjectEvents[i].previousMetatileBehavior = questLogObjectEvents[i].mapobj_unk_1F;
-        gObjectEvents[i].directionSequenceIndex = questLogObjectEvents[i].mapobj_unk_21;
+        gObjectEvents[i].previousMetatileBehavior = questLogObjectEvents[i].previousMetatileBehavior;
+        gObjectEvents[i].directionSequenceIndex = questLogObjectEvents[i].directionSequenceIndex;
         gObjectEvents[i].playerCopyableMovement = questLogObjectEvents[i].animId;
 
         for (j = 0; j < 0x40; j++)
diff --git a/src/quest_log_player.c b/src/quest_log_player.c
index 5a2152d8e..be40042b3 100644
--- a/src/quest_log_player.c
+++ b/src/quest_log_player.c
@@ -57,7 +57,7 @@ void sub_8150498(u8 a0)
 static void sub_81504A8(void)
 {
     struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
-    sub_81507BC(objectEvent, sub_805C808(0));
+    sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(0));
     ObjectEventTurn(objectEvent, objectEvent->movementDirection);
     SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_ON_FOOT);
 }
@@ -65,7 +65,7 @@ static void sub_81504A8(void)
 static void sub_81504E8(void)
 {
     struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId];
-    sub_81507BC(objectEvent, sub_805C808(1));
+    sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(1));
     ObjectEventTurn(objectEvent, objectEvent->movementDirection);
     SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_MACH_BIKE);
     sub_80BD620(0, 0);
@@ -80,13 +80,13 @@ static void sub_8150530(void)
     {
         u8 taskId;
         ScriptContext2_Enable();
-        gPlayerAvatar.unk6 = 1;
+        gPlayerAvatar.preventStep = TRUE;
         taskId = CreateTask(sub_81505C4, 0xFF);
         gTasks[taskId].data[0] = 0;
     }
     else
     {
-        sub_81507BC(objectEvent, sub_805C808(4));
+        sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(4));
         StartSpriteAnim(sprite, GetFishingNoCatchDirectionAnimNum(objectEvent->facingDirection));
     }
 }
@@ -101,7 +101,7 @@ static void sub_81505C4(u8 taskId)
         case 0:
             ObjectEventClearHeldMovementIfActive(objectEvent);
             objectEvent->enableAnim = TRUE;
-            sub_81507BC(objectEvent, sub_805C808(4));
+            sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(4));
             StartSpriteAnim(sprite, GetFishingNoCatchDirectionAnimNum(objectEvent->facingDirection));
             gTasks[taskId].data[0]++;
             gTasks[taskId].data[1] = 0;
@@ -122,9 +122,9 @@ static void sub_81505C4(u8 taskId)
             if (sprite->animEnded)
             {
                 if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING))
-                    sub_81507BC(objectEvent, sub_805C808(0));
+                    sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(0));
                 else
-                    sub_81507BC(objectEvent, sub_805C808(2));
+                    sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2));
                 ObjectEventTurn(objectEvent, objectEvent->movementDirection);
                 sprite->pos2.x = 0;
                 sprite->pos2.y = 0;
@@ -142,7 +142,7 @@ static void sub_8150708(void)
 
     if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING))
     {
-        sub_81507BC(objectEvent, sub_805C808(2));
+        sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2));
         ObjectEventTurn(objectEvent, objectEvent->movementDirection);
         SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_SURFING);
         gFieldEffectArguments[0] = objectEvent->currentCoords.x;
@@ -156,13 +156,13 @@ static void sub_8150708(void)
 
 static void sub_815077C(void)
 {
-    FieldEffectStart(FLDEFF_UNK_41);
+    FieldEffectStart(FLDEFF_USE_VS_SEEKER);
     CreateTask(sub_8150794, 0x00);
 }
 
 static void sub_8150794(u8 taskId)
 {
-    if (!FieldEffectActiveListContains(0x41))
+    if (!FieldEffectActiveListContains(FLDEFF_USE_VS_SEEKER))
     {
         UnfreezeObjectEvents();
         ScriptContext2_Disable();
diff --git a/src/random.c b/src/random.c
index f6c49971d..cb12ec805 100644
--- a/src/random.c
+++ b/src/random.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "random.h"
 
 // The number 1103515245 comes from the example implementation
 // of rand and srand in the ISO C standard.
diff --git a/src/region_map.c b/src/region_map.c
index d526f9aaa..731abc59f 100644
--- a/src/region_map.c
+++ b/src/region_map.c
@@ -19,7 +19,7 @@
 #include "map_preview_screen.h"
 #include "constants/flags.h"
 #include "constants/songs.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 #include "constants/spawn_points.h"
 #include "constants/maps.h"
 
@@ -1269,10 +1269,10 @@ static const u8 sMapsecToSpawn[][3] = {
     [MAPSEC_CAPE_BRINK         - MAPSECS_KANTO] = {MAP_GROUP(TWO_ISLAND_CAPE_BRINK), MAP_NUM(TWO_ISLAND_CAPE_BRINK), 0},
     [MAPSEC_BOND_BRIDGE        - MAPSECS_KANTO] = {MAP_GROUP(THREE_ISLAND_BOND_BRIDGE), MAP_NUM(THREE_ISLAND_BOND_BRIDGE), 0},
     [MAPSEC_THREE_ISLE_PORT    - MAPSECS_KANTO] = {MAP_GROUP(THREE_ISLAND_PORT), MAP_NUM(THREE_ISLAND_PORT), 0},
-    [MAPSEC_SEVII_ISLE_6       - MAPSECS_KANTO] = {MAP_GROUP(UNKNOWN_MAP_03_50), MAP_NUM(UNKNOWN_MAP_03_50), 0},
-    [MAPSEC_SEVII_ISLE_7       - MAPSECS_KANTO] = {MAP_GROUP(UNKNOWN_MAP_03_51), MAP_NUM(UNKNOWN_MAP_03_51), 0},
-    [MAPSEC_SEVII_ISLE_8       - MAPSECS_KANTO] = {MAP_GROUP(UNKNOWN_MAP_03_52), MAP_NUM(UNKNOWN_MAP_03_52), 0},
-    [MAPSEC_SEVII_ISLE_9       - MAPSECS_KANTO] = {MAP_GROUP(UNKNOWN_MAP_03_53), MAP_NUM(UNKNOWN_MAP_03_53), 0},
+    [MAPSEC_SEVII_ISLE_6       - MAPSECS_KANTO] = {MAP_GROUP(PROTOTYPE_SEVII_ISLE_6), MAP_NUM(PROTOTYPE_SEVII_ISLE_6), 0},
+    [MAPSEC_SEVII_ISLE_7       - MAPSECS_KANTO] = {MAP_GROUP(PROTOTYPE_SEVII_ISLE_7), MAP_NUM(PROTOTYPE_SEVII_ISLE_7), 0},
+    [MAPSEC_SEVII_ISLE_8       - MAPSECS_KANTO] = {MAP_GROUP(PROTOTYPE_SEVII_ISLE_8), MAP_NUM(PROTOTYPE_SEVII_ISLE_8), 0},
+    [MAPSEC_SEVII_ISLE_9       - MAPSECS_KANTO] = {MAP_GROUP(PROTOTYPE_SEVII_ISLE_9), MAP_NUM(PROTOTYPE_SEVII_ISLE_9), 0},
     [MAPSEC_RESORT_GORGEOUS    - MAPSECS_KANTO] = {MAP_GROUP(FIVE_ISLAND_RESORT_GORGEOUS), MAP_NUM(FIVE_ISLAND_RESORT_GORGEOUS), 0},
     [MAPSEC_WATER_LABYRINTH    - MAPSECS_KANTO] = {MAP_GROUP(FIVE_ISLAND_WATER_LABYRINTH), MAP_NUM(FIVE_ISLAND_WATER_LABYRINTH), 0},
     [MAPSEC_FIVE_ISLE_MEADOW   - MAPSECS_KANTO] = {MAP_GROUP(FIVE_ISLAND_MEADOW), MAP_NUM(FIVE_ISLAND_MEADOW), 0},
@@ -3420,7 +3420,7 @@ static u8 sub_80C3878(u8 mapsec)
     case MAPSEC_ROCKET_WAREHOUSE:
         return FlagGet(FLAG_WORLD_MAP_FIVE_ISLAND_ROCKET_WAREHOUSE) ? 2 : 3;
     case MAPSEC_TRAINER_TOWER_2:
-        return FlagGet(FLAG_WORLD_MAP_SEVEN_ISLAND_TRAINER_TOWER_LOBBY) ? 2 : 3;
+        return FlagGet(FLAG_WORLD_MAP_TRAINER_TOWER_LOBBY) ? 2 : 3;
     case MAPSEC_DOTTED_HOLE:
         return FlagGet(FLAG_WORLD_MAP_SIX_ISLAND_DOTTED_HOLE_1F) ? 2 : 3;
     case MAPSEC_LOST_CAVE:
@@ -4395,5 +4395,5 @@ static void sub_80C527C(u16 mapsec)
     {
         warp1_set_2(sMapsecToSpawn[idx][0], sMapsecToSpawn[idx][1], -1);
     }
-    sub_80842C8();
+    ReturnToFieldFromFlyMapSelect();
 }
diff --git a/src/renewable_hidden_items.c b/src/renewable_hidden_items.c
index cbaa780e6..c0406fe94 100644
--- a/src/renewable_hidden_items.c
+++ b/src/renewable_hidden_items.c
@@ -529,12 +529,6 @@ static const struct RenewableHiddenItemData sRenewableHiddenItems[] = {
     },
 };
 
-bool32 sub_815D834(void)
-{
-    // Stubbed out?
-    return FALSE;
-}
-
 void SetAllRenewableItemFlags(void)
 {
     u8 i, j;
diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c
index ebfd18493..25470fc43 100644
--- a/src/reshow_battle_screen.c
+++ b/src/reshow_battle_screen.c
@@ -6,7 +6,6 @@
 #include "link.h"
 #include "data.h"
 #include "sprite.h"
-#include "text.h"
 #include "gpu_regs.h"
 #include "scanline_effect.h"
 #include "help_system.h"
@@ -14,8 +13,6 @@
 #include "battle_interface.h"
 #include "battle_anim.h"
 #include "battle_controllers.h"
-#include "reshow_battle_screen.h"
-#include "constants/species.h"
 
 static void CB2_ReshowBattleScreenAfterMenu(void);
 static void sub_8077AAC(void);
@@ -39,17 +36,17 @@ void ReshowBattleScreenAfterMenu(void)
         if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
         {
             if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
-                HelpSystem_SetSomeVariable2(0x19);
+                SetHelpContext(HELPCONTEXT_TRAINER_BATTLE_DOUBLE);
             else
-                HelpSystem_SetSomeVariable2(0x18);
+                SetHelpContext(HELPCONTEXT_TRAINER_BATTLE_SINGLE);
         }
         else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
         {
-            HelpSystem_SetSomeVariable2(0x1A);
+            SetHelpContext(HELPCONTEXT_SAFARI_BATTLE);
         }
         else
         {
-            HelpSystem_SetSomeVariable2(0x17);
+            SetHelpContext(HELPCONTEXT_WILD_BATTLE);
         }
     }
     SetMainCallback2(CB2_ReshowBattleScreenAfterMenu);
diff --git a/src/rfu_union_tool.c b/src/rfu_union_tool.c
index 20b29de9b..132ac7b85 100644
--- a/src/rfu_union_tool.c
+++ b/src/rfu_union_tool.c
@@ -1,8 +1,6 @@
 #include "global.h"
 #include "event_data.h"
 #include "event_object_movement.h"
-#include "event_object_80688E4.h"
-#include "event_object_8097404.h"
 #include "field_player_avatar.h"
 #include "fieldmap.h"
 #include "rfu_union_tool.h"
@@ -10,35 +8,36 @@
 #include "task.h"
 #include "constants/flags.h"
 #include "constants/event_object_movement.h"
-#include "constants/object_events.h"
+#include "constants/union_room.h"
+#include "constants/event_objects.h"
 
 static EWRAM_DATA struct UnionObj * UnionObjWork = NULL;
 static EWRAM_DATA u32 sUnionObjRefreshTimer = 0;
 
 static u8 StartUnionObjAnimTask(void);
-static u32 sub_811BBC8(u32 playerIdx, u32 arg1);
-static void sub_811C008(s32 arg0, s32 arg1, u8 arg2);
+static u32 RfuUnionGroupMemberIsInvisible(u32 group, u32 member);
+static void UnionPartnerObjectSetFacing(s32 member, s32 group, u8 direction);
 
 static const u8 sUnionObjectEventGfxIds[][10] = {
     [MALE]   = {
-        OBJECT_EVENT_GFX_COOLTRAINER_M,
-        OBJECT_EVENT_GFX_BLACKBELT,
-        OBJECT_EVENT_GFX_CAMPER,
-        OBJECT_EVENT_GFX_YOUNGSTER,
-        OBJECT_EVENT_GFX_BOY,
-        OBJECT_EVENT_GFX_BUG_CATCHER,
-        OBJECT_EVENT_GFX_MAN,
-        OBJECT_EVENT_GFX_ROCKER
+        OBJ_EVENT_GFX_COOLTRAINER_M,
+        OBJ_EVENT_GFX_BLACKBELT,
+        OBJ_EVENT_GFX_CAMPER,
+        OBJ_EVENT_GFX_YOUNGSTER,
+        OBJ_EVENT_GFX_BOY,
+        OBJ_EVENT_GFX_BUG_CATCHER,
+        OBJ_EVENT_GFX_MAN,
+        OBJ_EVENT_GFX_ROCKER
     },
     [FEMALE] = {
-        OBJECT_EVENT_GFX_COOLTRAINER_F,
-        OBJECT_EVENT_GFX_CHANNELER,
-        OBJECT_EVENT_GFX_PICNICKER,
-        OBJECT_EVENT_GFX_LASS,
-        OBJECT_EVENT_GFX_WOMAN_1,
-        OBJECT_EVENT_GFX_BATTLE_GIRL,
-        OBJECT_EVENT_GFX_WOMAN_2,
-        OBJECT_EVENT_GFX_BEAUTY
+        OBJ_EVENT_GFX_COOLTRAINER_F,
+        OBJ_EVENT_GFX_CHANNELER,
+        OBJ_EVENT_GFX_PICNICKER,
+        OBJ_EVENT_GFX_LASS,
+        OBJ_EVENT_GFX_WOMAN_1,
+        OBJ_EVENT_GFX_BATTLE_GIRL,
+        OBJ_EVENT_GFX_WOMAN_2,
+        OBJ_EVENT_GFX_BEAUTY
     }
 };
 
@@ -69,12 +68,12 @@ static const u8 sOppositeFacingDirection[] = {
     [DIR_EAST]  = DIR_WEST
 };
 
-static const u8 gUnknown_845711B[] = {
-    1,
-    3,
-    1,
-    4, 
-    2
+static const u8 sUnionGroupMemberFacings[] = {
+    DIR_SOUTH,
+    DIR_WEST,
+    DIR_SOUTH,
+    DIR_EAST,
+    DIR_NORTH
 };
 
 static const u8 sUnionRoomLocalIds[] = {
@@ -116,19 +115,19 @@ static u8 GetUnionRoomPlayerGraphicsId(u32 gender, u32 id)
     return sUnionObjectEventGfxIds[gender][id % 8];
 }
 
-static void GetUnionRoomPlayerFacingCoords(u32 id, u32 dirn, s32 * xp, s32 * yp)
+static void GetUnionRoomPlayerFacingCoords(u32 group, u32 member, s32 * xp, s32 * yp)
 {
-    *xp = sUnionPartnerCoords[id][0] + sFacingDirectionOffsets[dirn][0] + 7;
-    *yp = sUnionPartnerCoords[id][1] + sFacingDirectionOffsets[dirn][1] + 7;
+    *xp = sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[member][0] + 7;
+    *yp = sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[member][1] + 7;
 }
 
-static bool32 sub_811B58C(u32 id, u32 dirn, s32 x, s32 y)
+static bool32 IsUnionRoomPlayerFacingTileAt(u32 group, u32 member, s32 x, s32 y)
 {
-    if (sUnionPartnerCoords[id][0] + sFacingDirectionOffsets[dirn][0] + 7 != x)
+    if (sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[member][0] + 7 != x)
     {
         return FALSE;
     }
-    else if (sUnionPartnerCoords[id][1] + sFacingDirectionOffsets[dirn][1] + 7 != y)
+    else if (sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[member][1] + 7 != y)
     {
         return FALSE;
     }
@@ -188,6 +187,7 @@ static bool32 SetUnionRoomPlayerEnterExitMovement(u32 playerIdx, const u8 * move
     }
     return TRUE;
 }
+
 static bool32 TryReleaseUnionRoomPlayerObjectEvent(u32 playerIdx)
 {
     u8 objectId;
@@ -263,11 +263,11 @@ static const u8 sMovement_UnionPlayerEnter[2] = {
     MOVEMENT_ACTION_STEP_END
 };
 
-static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionObj * ptr)
+static bool32 AnimateUnionRoomPlayerSpawn(s8 * state_p, u32 playerIdx, struct UnionObj * ptr)
 {
     s16 x, y;
 
-    switch (*a0)
+    switch (*state_p)
     {
     case 0:
         if (!is_walking_or_running())
@@ -275,30 +275,30 @@ static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionOb
             break;
         }
         PlayerGetDestCoords(&x, &y);
-        if (sub_811B58C(playerIdx, 0, x, y) == TRUE)
+        if (IsUnionRoomPlayerFacingTileAt(playerIdx, 0, x, y) == TRUE)
         {
             break;
         }
         player_get_pos_including_state_based_drift(&x, &y);
-        if (sub_811B58C(playerIdx, 0, x, y) == TRUE)
+        if (IsUnionRoomPlayerFacingTileAt(playerIdx, 0, x, y) == TRUE)
         {
             break;
         }
         SetUnionRoomPlayerGfx(playerIdx, ptr->gfxId);
         CreateUnionRoomPlayerObjectEvent(playerIdx);
         ShowUnionRoomPlayer(playerIdx);
-        (*a0)++;
+        (*state_p)++;
         // fallthrough
     case 3: // incorrect?
         if (SetUnionRoomPlayerEnterExitMovement(playerIdx, sMovement_UnionPlayerEnter) == 1)
         {
-            (*a0)++;
+            (*state_p)++;
         }
         break;
     case 2:
         if (TryReleaseUnionRoomPlayerObjectEvent(playerIdx))
         {
-            *a0 = 0;
+            *state_p = 0;
             return TRUE;
         }
         break;
@@ -306,12 +306,12 @@ static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionOb
     return FALSE;
 }
 
-static bool32 sub_811B8BC(u32 playerIdx, u32 a1, u32 a2)
+static bool32 SpawnGroupLeader(u32 playerIdx, u32 gender, u32 idMod256)
 {
     struct UnionObj * ptr = &UnionObjWork[playerIdx];
     AGB_ASSERT_EX(UnionObjWork != NULL, ABSPATH("rfu_union_tool.c"), 561)
-    ptr->schedAnim = 1;
-    ptr->gfxId = GetUnionRoomPlayerGraphicsId(a1, a2);
+    ptr->schedAnim = UNION_ROOM_SPAWN_IN;
+    ptr->gfxId = GetUnionRoomPlayerGraphicsId(gender, idMod256);
     if (ptr->state == 0)
     {
         return TRUE;
@@ -322,11 +322,11 @@ static bool32 sub_811B8BC(u32 playerIdx, u32 a1, u32 a2)
     }
 }
 
-static bool32 sub_811B90C(u32 playerIdx)
+static bool32 DespawnGroupLeader(u32 playerIdx)
 {
     struct UnionObj * ptr = &UnionObjWork[playerIdx];
     AGB_ASSERT_EX(UnionObjWork != NULL, ABSPATH("rfu_union_tool.c"), 577)
-    ptr->schedAnim = 2;
+    ptr->schedAnim = UNION_ROOM_SPAWN_OUT;
     if (ptr->state == 1)
     {
         return TRUE;
@@ -342,7 +342,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr)
     switch (ptr->state)
     {
     case 0:
-        if (ptr->schedAnim == 1)
+        if (ptr->schedAnim == UNION_ROOM_SPAWN_IN)
         {
             ptr->state = 2;
             ptr->animState = 0;
@@ -353,7 +353,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr)
         }
         // fallthrough
     case 2:
-        if (!sub_811BBC8(playerIdx, 0) && ptr->schedAnim == 2)
+        if (!RfuUnionGroupMemberIsInvisible(playerIdx, 0) && ptr->schedAnim == 2)
         {
             ptr->state = 0;
             ptr->animState = 0;
@@ -366,7 +366,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr)
         }
         break;
     case 1:
-        if (ptr->schedAnim == 2)
+        if (ptr->schedAnim == UNION_ROOM_SPAWN_OUT)
         {
             ptr->state = 3;
             ptr->animState = 0;
@@ -383,7 +383,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr)
         }
         break;
     }
-    ptr->schedAnim = 0;
+    ptr->schedAnim = UNION_ROOM_SPAWN_NONE;
 }
 
 static void Task_AnimateUnionObjs(u8 taskId)
@@ -409,7 +409,7 @@ static u8 StartUnionObjAnimTask(void)
     }
 }
 
-static void sub_811BA5C(void)
+static void DestroyAnimateUnionObjsTask(void)
 {
     u8 taskId = FindTaskIdByFunc(Task_AnimateUnionObjs);
     if (taskId < NUM_TASKS)
@@ -418,7 +418,7 @@ static void sub_811BA5C(void)
     }
 }
 
-void sub_811BA78(void)
+void DeleteUnionObjWorkAndStopTask(void)
 {
     s32 i;
     for (i = 0; i < 8; i++)
@@ -430,31 +430,31 @@ void sub_811BA78(void)
         }
     }
     UnionObjWork = NULL;
-    sub_811BA5C();
+    DestroyAnimateUnionObjsTask();
 }
 
-void sub_811BAAC(u8 * sp8, s32 r9)
+void CreateGroupMemberObjectsInvisible(u8 * sprite_ids, s32 group)
 {
-    s32 r7;
+    s32 i;
 
-    for (r7 = 0; r7 < 5; r7++)
+    for (i = 0; i < 5; i++)
     {
-        s32 r5 = 5 * r9 + r7;
-        sp8[r5] = sprite_new(OBJECT_EVENT_GFX_MAN, r5 - 0x38, sUnionPartnerCoords[r9][0] + sFacingDirectionOffsets[r7][0], sUnionPartnerCoords[r9][1] + sFacingDirectionOffsets[r7][1], 3, 1);
-        sub_8069124(r5 - 0x38, TRUE);
+        s32 obj_id = 5 * group + i;
+        sprite_ids[obj_id] = sprite_new(OBJ_EVENT_GFX_MAN, obj_id - 0x38, sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[i][0], sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[i][1], 3, 1);
+        RfuUnionObjectToggleInvisibility(obj_id - 0x38, TRUE);
     }
 }
 
-void sub_811BB40(u8 * r5)
+void DestroyGroupMemberObjects(u8 *spriteIds)
 {
     s32 i;
     for (i = 0; i < 40; i++)
     {
-        DestroySprite(&gSprites[r5[i]]);
+        DestroySprite(&gSprites[spriteIds[i]]);
     }
 }
 
-void sub_811BB68(void)
+void MakeGroupAssemblyAreasPassable(void)
 {
     s32 i, j, x, y;
     for (i = 0; i < 8; i++)
@@ -462,94 +462,94 @@ void sub_811BB68(void)
         for (j = 0; j < 5; j++)
         {
             GetUnionRoomPlayerFacingCoords(i, j, &x, &y);
-            sub_8059024(x, y, 0);
+            MapGridSetMetatileImpassabilityAt(x, y, FALSE);
         }
     }
 }
 
-static u8 sub_811BBA0(u32 r1, u32 unused, struct GFtgtGname * r2)
+static u8 UnionPartnerObjectGetFacing(u32 member, u32 group, struct GFtgtGname * gname)
 {
-    if (r1 != 0)
+    if (member != 0)
     {
-        return gUnknown_845711B[r1];
+        return sUnionGroupMemberFacings[member];
     }
-    else if (r2->unk_0a_0 == 0x45)
+    else if (gname->activity == 0x45)
     {
-        return 1;
+        return DIR_SOUTH;
     }
     else
     {
-        return 4;
+        return DIR_EAST;
     }
 }
 
-static u32 sub_811BBC8(u32 a0, u32 a1)
+static u32 RfuUnionGroupMemberIsInvisible(u32 group, u32 member)
 {
-    return sub_806916C(5 * a0 + a1 - 0x38);
+    return RfuUnionObjectIsInvisible(5 * group + member - 0x38);
 }
 
-static void sub_811BBE0(u32 r5, u32 r6, u8 r8, struct GFtgtGname * r9)
+static void SpawnGroupMember(u32 groupNo, u32 memberNo, u8 direction, struct GFtgtGname * gname)
 {
     s32 x, y;
-    s32 r7 = 5 * r5 + r6;
-    if (sub_811BBC8(r5, r6) == 1)
+    s32 objId = 5 * groupNo + memberNo;
+    if (RfuUnionGroupMemberIsInvisible(groupNo, memberNo) == TRUE)
     {
-        sub_8069124(r7 - 0x38, FALSE);
-        sub_80691A4(r7 - 0x38, 1);
+        RfuUnionObjectToggleInvisibility(objId - 0x38, FALSE);
+        RfuUnionObjectStartWarp(objId - 0x38, UNION_ROOM_SPAWN_IN);
     }
-    sub_8069094(r7 - 0x38, r8);
-    sub_811C008(r6, r5, sub_811BBA0(r6, r5, r9));
-    GetUnionRoomPlayerFacingCoords(r5, r6, &x, &y);
-    sub_8059024(x, y, 1);
+    RfuUnionObjectSetFacingDirection(objId - 0x38, direction);
+    UnionPartnerObjectSetFacing(memberNo, groupNo, UnionPartnerObjectGetFacing(memberNo, groupNo, gname));
+    GetUnionRoomPlayerFacingCoords(groupNo, memberNo, &x, &y);
+    MapGridSetMetatileImpassabilityAt(x, y, TRUE);
 }
 
-static void sub_811BC68(u32 a0, u32 a1)
+static void DespawnGroupMember(u32 group, u32 member)
 {
     s32 x, y;
-    sub_80691A4(5 * a0 + a1 - 0x38, 2);
-    GetUnionRoomPlayerFacingCoords(a0, a1, &x, &y);
-    sub_8059024(x, y, 0);
+    RfuUnionObjectStartWarp(5 * group + member - 0x38, UNION_ROOM_SPAWN_OUT);
+    GetUnionRoomPlayerFacingCoords(group, member, &x, &y);
+    MapGridSetMetatileImpassabilityAt(x, y, FALSE);
 }
 
-static void sub_811BCA0(u32 r7, struct GFtgtGname * r8)
+static void AssembleGroup(u32 group, struct GFtgtGname * gname)
 {
     s16 x, y, x2, y2;
     s32 i;
 
     PlayerGetDestCoords(&x, &y);
     player_get_pos_including_state_based_drift(&x2, &y2);
-    if (sub_806916C(5 * r7 - 0x38) == 1)
+    if (RfuUnionObjectIsInvisible(5 * group - 0x38) == TRUE)
     {
-        if (sub_811B58C(r7, 0, x, y) == TRUE || sub_811B58C(r7, 0, x2, y2) == TRUE)
+        if (IsUnionRoomPlayerFacingTileAt(group, 0, x, y) == TRUE || IsUnionRoomPlayerFacingTileAt(group, 0, x2, y2) == TRUE)
         {
             return;
         }
-        sub_811BBE0(r7, 0, GetUnionRoomPlayerGraphicsId(r8->playerGender, r8->unk_00.playerTrainerId[0]), r8);
+        SpawnGroupMember(group, 0, GetUnionRoomPlayerGraphicsId(gname->playerGender, gname->unk_00.playerTrainerId[0]), gname);
     }
     for (i = 1; i < 5; i++)
     {
-        if (r8->unk_04[i - 1] == 0)
+        if (gname->child_sprite_gender[i - 1] == 0)
         {
-            sub_811BC68(r7, i);
+            DespawnGroupMember(group, i);
         }
-        else if (sub_811B58C(r7, i, x, y) == FALSE && sub_811B58C(r7, i, x2, y2) == FALSE)
+        else if (IsUnionRoomPlayerFacingTileAt(group, i, x, y) == FALSE && IsUnionRoomPlayerFacingTileAt(group, i, x2, y2) == FALSE)
         {
-            sub_811BBE0(r7, i, GetUnionRoomPlayerGraphicsId((r8->unk_04[i - 1] >> 3) & 1, r8->unk_04[i - 1] & 7), r8);
+            SpawnGroupMember(group, i, GetUnionRoomPlayerGraphicsId((gname->child_sprite_gender[i - 1] >> 3) & 1, gname->child_sprite_gender[i - 1] & 7), gname);
         }
     }
 }
 
-static void sub_811BDA8(u32 r5, struct GFtgtGname * r4)
+static void SpawnGroupLeaderAndMembers(u32 group, struct GFtgtGname * gname)
 {
     u32 i;
-    switch (r4->unk_0a_0)
+    switch (gname->activity)
     {
     case 0x40:
     case 0x54:
-        sub_811B8BC(r5, r4->playerGender, r4->unk_00.playerTrainerId[0]);
+        SpawnGroupLeader(group, gname->playerGender, gname->unk_00.playerTrainerId[0]);
         for (i = 0; i < 5; i++)
         {
-            sub_811BC68(r5, i);
+            DespawnGroupMember(group, i);
         }
         break;
     case 0x41:
@@ -559,70 +559,70 @@ static void sub_811BDA8(u32 r5, struct GFtgtGname * r4)
     case 0x51:
     case 0x52:
     case 0x53:
-        sub_811B90C(r5);
-        sub_811BCA0(r5, r4);
+        DespawnGroupLeader(group);
+        AssembleGroup(group, gname);
         break;
     default:
         AGB_ASSERT_EX(0, ABSPATH("rfu_union_tool.c"), 979)
     }
 }
 
-static void sub_811BE6C(u32 r5, struct GFtgtGname * unused)
+static void DespawnGroupLeaderAndMembers(u32 group, struct GFtgtGname * gname)
 {
     s32 i;
-    sub_811B90C(r5);
+    DespawnGroupLeader(group);
     for (i = 0; i < 5; i++)
     {
-        sub_811BC68(r5, i);
+        DespawnGroupMember(group, i);
     }
 }
 
-static void UpdateUnionRoomPlayerSprites(struct UnkStruct_URoom *r0)
+static void UpdateUnionRoomPlayerSprites(struct UnkStruct_URoom * groups)
 {
     s32 i;
-    struct UnkStruct_x20 * r4;
+    struct UnkStruct_x20 * x20_p;
     sUnionObjRefreshTimer = 0;
-    for (i = 0, r4 = r0->field_0->arr; i < 8; i++)
+    for (i = 0, x20_p = groups->field_0->arr; i < 8; i++)
     {
-        if (r4[i].field_1A_0 == 1)
+        if (x20_p[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
         {
-            sub_811BDA8(i, &r4[i].unk.gname);
+            SpawnGroupLeaderAndMembers(i, &x20_p[i].gname_uname.gname);
         }
-        else if (r4[i].field_1A_0 == 2)
+        else if (x20_p[i].groupScheduledAnim == UNION_ROOM_SPAWN_OUT)
         {
-            sub_811BE6C(i, &r4[i].unk.gname);
+            DespawnGroupLeaderAndMembers(i, &x20_p[i].gname_uname.gname);
         }
     }
 }
 
-void sub_811BECC(struct UnkStruct_URoom *unused)
+void ScheduleUnionRoomPlayerRefresh(struct UnkStruct_URoom *uroom_p)
 {
     sUnionObjRefreshTimer = 300;
 }
 
-void sub_811BEDC(struct UnkStruct_URoom *r2)
+void HandleUnionRoomPlayerRefresh(struct UnkStruct_URoom *uroom_p)
 {
     if (++sUnionObjRefreshTimer > 300)
     {
-        UpdateUnionRoomPlayerSprites(r2);
+        UpdateUnionRoomPlayerSprites(uroom_p);
     }
 }
 
-bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3)
+bool32 RfuUnionTool_GetGroupAndMemberInFrontOfPlayer(struct UnkStruct_Main0 *main0_p, s16 *member_p, s16 *group_p, u8 *spriteIds)
 {
     s16 x, y;
     s32 i, j;
-    struct UnkStruct_x20 * r4;
+    struct UnkStruct_x20 * x20_p;
     if (!is_walking_or_running())
     {
         return FALSE;
     }
     GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
-    for (i = 0, r4 = arg0->arr; i < 8; i++)
+    for (i = 0, x20_p = main0_p->arr; i < 8; i++)
     {
         for (j = 0; j < 5; j++)
         {
-            s32 r3 = 5 * i + j;
+            s32 objId = 5 * i + j;
             if (x != sUnionPartnerCoords[i][0] + sFacingDirectionOffsets[j][0] + 7)
             {
                 continue;
@@ -631,33 +631,33 @@ bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3)
             {
                 continue;
             }
-            if (sub_806916C(r3 - 0x38) != 0)
+            if (RfuUnionObjectIsInvisible(objId - 0x38) != 0)
             {
                 continue;
             }
-            if (sub_8069294(r3 - 0x38) != 0)
+            if (RfuUnionObjectIsWarping(objId - 0x38) != 0)
             {
                 continue;
             }
-            if (r4[i].field_1A_0 != 1)
+            if (x20_p[i].groupScheduledAnim != UNION_ROOM_SPAWN_IN)
             {
                 continue;
             }
-            sub_811C008(j, i, sOppositeFacingDirection[GetPlayerFacingDirection()]);
-            *arg1 = j;
-            *arg2 = i;
+            UnionPartnerObjectSetFacing(j, i, sOppositeFacingDirection[GetPlayerFacingDirection()]);
+            *member_p = j;
+            *group_p = i;
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static void sub_811C008(s32 arg0, s32 arg1, u8 arg2)
+static void UnionPartnerObjectSetFacing(s32 member, s32 group, u8 direction)
 {
-    sub_8069058(5 * arg1 - 0x38 + arg0, arg2);
+    TurnObjectEvent(5 * group - 0x38 + member, direction);
 }
 
-void sub_811C028(u32 arg0, u32 arg1, struct UnkStruct_Main0 *arg2)
+void UpdateUnionGroupMemberFacing(u32 member, u32 group, struct UnkStruct_Main0 *main0_p)
 {
-    return sub_811C008(arg0, arg1, sub_811BBA0(arg0, arg1, &arg2->arr[arg1].unk.gname));
+    return UnionPartnerObjectSetFacing(member, group, UnionPartnerObjectGetFacing(member, group, &main0_p->arr[group].gname_uname.gname));
 }
diff --git a/src/roamer.c b/src/roamer.c
index b3cc67f85..f3e8bbccd 100644
--- a/src/roamer.c
+++ b/src/roamer.c
@@ -1,11 +1,10 @@
 #include "global.h"
-#include "roamer.h"
 #include "random.h"
 #include "overworld.h"
 #include "field_specials.h"
 #include "constants/species.h"
 #include "constants/maps.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 
 EWRAM_DATA u8 sLocationHistory[3][2] = {};
 EWRAM_DATA u8 sRoamerLocation[2] = {};
@@ -62,7 +61,7 @@ void ClearRoamerData(void)
 
 #define GetRoamerSpecies() ({\
     u16 a;\
-    switch (ScrSpecial_GetStarter())\
+    switch (GetStarterSpecies())\
     {\
     default:\
         a = SPECIES_RAIKOU;\
diff --git a/src/rock.c b/src/rock.c
index 082f3b655..3ec9cec04 100644
--- a/src/rock.c
+++ b/src/rock.c
@@ -704,7 +704,7 @@ static void sub_80B4F78(struct Sprite *sprite)
     {
         u8 taskId = FindTaskIdByFunc(sub_80B4D00);
 
-        if (taskId != TASK_NONE)
+        if (taskId != TAIL_SENTINEL)
             --gTasks[taskId].data[11];
         DestroySprite(sprite);
     }
diff --git a/src/safari_zone.c b/src/safari_zone.c
index 65fb89bca..29e436d35 100644
--- a/src/safari_zone.c
+++ b/src/safari_zone.c
@@ -2,7 +2,6 @@
 #include "battle.h"
 #include "event_scripts.h"
 #include "overworld.h"
-#include "battle.h"
 #include "script.h"
 #include "event_data.h"
 #include "field_screen_effect.h"
diff --git a/src/save.c b/src/save.c
index a2d365886..3db8dcdbf 100644
--- a/src/save.c
+++ b/src/save.c
@@ -856,7 +856,7 @@ void sub_80DA634(u8 taskId)
         gTasks[taskId].data[0] = 1;
         break;
     case 1:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         gTasks[taskId].data[0] = 2;
         break;
     case 2:
@@ -890,7 +890,7 @@ void sub_80DA634(u8 taskId)
         break;
     case 7:
         ClearContinueGameWarpStatus2();
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         gTasks[taskId].data[0] = 8;
         break;
     case 8:
@@ -901,7 +901,7 @@ void sub_80DA634(u8 taskId)
         }
         break;
     case 9:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         gTasks[taskId].data[0] = 10;
         break;
     case 10:
diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c
index b6cce890a..09e49a1bb 100644
--- a/src/save_failed_screen.c
+++ b/src/save_failed_screen.c
@@ -6,7 +6,6 @@
 #include "help_system.h"
 #include "m4a.h"
 #include "save.h"
-#include "save_failed_screen.h"
 #include "strings.h"
 #include "text.h"
 
diff --git a/src/scanline_effect.c b/src/scanline_effect.c
index 22699b96d..e664945cd 100644
--- a/src/scanline_effect.c
+++ b/src/scanline_effect.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "battle.h"
 #include "task.h"
 #include "trig.h"
 #include "scanline_effect.h"
diff --git a/src/scrcmd.c b/src/scrcmd.c
index c79a8bd1f..32ac5c4e2 100644
--- a/src/scrcmd.c
+++ b/src/scrcmd.c
@@ -21,7 +21,6 @@
 #include "field_message_box.h"
 #include "new_menu_helpers.h"
 #include "window.h"
-#include "start_menu.h"
 #include "script_menu.h"
 #include "string_util.h"
 #include "data.h"
@@ -38,7 +37,6 @@
 #include "field_effect.h"
 #include "fieldmap.h"
 #include "field_door.h"
-#include "scrcmd.h"
 
 extern u16 (*const gSpecials[])(void);
 extern u16 (*const gSpecialsEnd[])(void);
@@ -62,7 +60,7 @@ extern u8 gSelectedObjectEvent;
 
 // This is defined in here so the optimizer can't see its value when compiling
 // script.c.
-void * const gNullScriptPtr = NULL;
+void *const gNullScriptPtr = NULL;
 
 static const u8 sScriptConditionTable[6][3] =
 {
@@ -75,30 +73,30 @@ static const u8 sScriptConditionTable[6][3] =
     1, 0, 1, // !=
 };
 
-bool8 ScrCmd_nop(struct ScriptContext *ctx)
+bool8 ScrCmd_nop(struct ScriptContext * ctx)
 {
     return FALSE;
 }
 
-bool8 ScrCmd_nop1(struct ScriptContext *ctx)
+bool8 ScrCmd_nop1(struct ScriptContext * ctx)
 {
     return FALSE;
 }
 
-bool8 ScrCmd_end(struct ScriptContext *ctx)
+bool8 ScrCmd_end(struct ScriptContext * ctx)
 {
     StopScript(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_gotonative(struct ScriptContext *ctx)
+bool8 ScrCmd_gotonative(struct ScriptContext * ctx)
 {
     bool8 (*func)(void) = (bool8 (*)(void))ScriptReadWord(ctx);
     SetupNativeScript(ctx, func);
     return TRUE;
 }
 
-bool8 ScrCmd_special(struct ScriptContext *ctx)
+bool8 ScrCmd_special(struct ScriptContext * ctx)
 {
     u16 (*const *specialPtr)(void) = gSpecials + ScriptReadHalfword(ctx);
     if (specialPtr < gSpecialsEnd)
@@ -108,7 +106,7 @@ bool8 ScrCmd_special(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_specialvar(struct ScriptContext *ctx)
+bool8 ScrCmd_specialvar(struct ScriptContext * ctx)
 {
     u16 * varPtr = GetVarPointer(ScriptReadHalfword(ctx));
     u16 (*const *specialPtr)(void) = gSpecials + ScriptReadHalfword(ctx);
@@ -119,40 +117,40 @@ bool8 ScrCmd_specialvar(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_callnative(struct ScriptContext *ctx)
+bool8 ScrCmd_callnative(struct ScriptContext * ctx)
 {
     void (*func )(void) = ((void (*)(void))ScriptReadWord(ctx));
     func();
     return FALSE;
 }
 
-bool8 ScrCmd_waitstate(struct ScriptContext *ctx)
+bool8 ScrCmd_waitstate(struct ScriptContext * ctx)
 {
     ScriptContext1_Stop();
     return TRUE;
 }
 
-bool8 ScrCmd_goto(struct ScriptContext *ctx)
+bool8 ScrCmd_goto(struct ScriptContext * ctx)
 {
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
     ScriptJump(ctx, scrptr);
     return FALSE;
 }
 
-bool8 ScrCmd_return(struct ScriptContext *ctx)
+bool8 ScrCmd_return(struct ScriptContext * ctx)
 {
     ScriptReturn(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_call(struct ScriptContext *ctx)
+bool8 ScrCmd_call(struct ScriptContext * ctx)
 {
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
     ScriptCall(ctx, scrptr);
     return FALSE;
 }
 
-bool8 ScrCmd_goto_if(struct ScriptContext *ctx)
+bool8 ScrCmd_goto_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
@@ -161,7 +159,7 @@ bool8 ScrCmd_goto_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_call_if(struct ScriptContext *ctx)
+bool8 ScrCmd_call_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
@@ -170,7 +168,7 @@ bool8 ScrCmd_call_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setvaddress(struct ScriptContext *ctx)
+bool8 ScrCmd_setvaddress(struct ScriptContext * ctx)
 {
     u32 addr1 = (u32)ctx->scriptPtr - 1;
     u32 addr2 = ScriptReadWord(ctx);
@@ -179,21 +177,21 @@ bool8 ScrCmd_setvaddress(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_vgoto(struct ScriptContext *ctx)
+bool8 ScrCmd_vgoto(struct ScriptContext * ctx)
 {
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
     ScriptJump(ctx, scrptr - gVScriptOffset);
     return FALSE;
 }
 
-bool8 ScrCmd_vcall(struct ScriptContext *ctx)
+bool8 ScrCmd_vcall(struct ScriptContext * ctx)
 {
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx);
     ScriptCall(ctx, scrptr - gVScriptOffset);
     return FALSE;
 }
 
-bool8 ScrCmd_vgoto_if(struct ScriptContext *ctx)
+bool8 ScrCmd_vgoto_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx) - gVScriptOffset;
@@ -202,7 +200,7 @@ bool8 ScrCmd_vgoto_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_vcall_if(struct ScriptContext *ctx)
+bool8 ScrCmd_vcall_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     const u8 * scrptr = (const u8 *)ScriptReadWord(ctx) - gVScriptOffset;
@@ -211,7 +209,7 @@ bool8 ScrCmd_vcall_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_gotostd(struct ScriptContext *ctx)
+bool8 ScrCmd_gotostd(struct ScriptContext * ctx)
 {
     u8 stdIdx = ScriptReadByte(ctx);
     const u8 *const * script = gStdScripts + stdIdx;
@@ -220,7 +218,7 @@ bool8 ScrCmd_gotostd(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_callstd(struct ScriptContext *ctx)
+bool8 ScrCmd_callstd(struct ScriptContext * ctx)
 {
     u8 stdIdx = ScriptReadByte(ctx);
     const u8 *const * script = gStdScripts + stdIdx;
@@ -229,7 +227,7 @@ bool8 ScrCmd_callstd(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_gotostd_if(struct ScriptContext *ctx)
+bool8 ScrCmd_gotostd_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     u8 stdIdx = ScriptReadByte(ctx);
@@ -242,7 +240,7 @@ bool8 ScrCmd_gotostd_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_callstd_if(struct ScriptContext *ctx)
+bool8 ScrCmd_callstd_if(struct ScriptContext * ctx)
 {
     u8 condition = ScriptReadByte(ctx);
     u8 stdIdx = ScriptReadByte(ctx);
@@ -255,26 +253,26 @@ bool8 ScrCmd_callstd_if(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_gotoram(struct ScriptContext *ctx)
+bool8 ScrCmd_gotoram(struct ScriptContext * ctx)
 {
     ScriptJump(ctx, gRAMScriptPtr);
     return FALSE;
 }
 
-bool8 ScrCmd_killscript(struct ScriptContext *ctx)
+bool8 ScrCmd_killscript(struct ScriptContext * ctx)
 {
     ClearRamScript();
     StopScript(ctx);
     return TRUE;
 }
 
-bool8 ScrCmd_setmysteryeventstatus(struct ScriptContext *ctx)
+bool8 ScrCmd_setmysteryeventstatus(struct ScriptContext * ctx)
 {
     SetMysteryEventScriptStatus(ScriptReadByte(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_execram(struct ScriptContext *ctx)
+bool8 ScrCmd_execram(struct ScriptContext * ctx)
 {
     const u8 * script = sub_8069E48();
     if (script != NULL)
@@ -285,42 +283,42 @@ bool8 ScrCmd_execram(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_loadword(struct ScriptContext *ctx)
+bool8 ScrCmd_loadword(struct ScriptContext * ctx)
 {
     u8 which = ScriptReadByte(ctx);
     ctx->data[which] = ScriptReadWord(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_loadbytefromaddr(struct ScriptContext *ctx)
+bool8 ScrCmd_loadbytefromaddr(struct ScriptContext * ctx)
 {
     u8 which = ScriptReadByte(ctx);
     ctx->data[which] = *(const u8 *)ScriptReadWord(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_writebytetoaddr(struct ScriptContext *ctx)
+bool8 ScrCmd_writebytetoaddr(struct ScriptContext * ctx)
 {
     u8 value = ScriptReadByte(ctx);
     *(u8 *)ScriptReadWord(ctx) = value;
     return FALSE;
 }
 
-bool8 ScrCmd_loadbyte(struct ScriptContext *ctx)
+bool8 ScrCmd_loadbyte(struct ScriptContext * ctx)
 {
     u8 which = ScriptReadByte(ctx);
     ctx->data[which] = ScriptReadByte(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_setptrbyte(struct ScriptContext *ctx)
+bool8 ScrCmd_setptrbyte(struct ScriptContext * ctx)
 {
     u8 which = ScriptReadByte(ctx);
     *(u8 *)ScriptReadWord(ctx) = ctx->data[which];
     return FALSE;
 }
 
-bool8 ScrCmd_copylocal(struct ScriptContext *ctx)
+bool8 ScrCmd_copylocal(struct ScriptContext * ctx)
 {
     u8 whichDst = ScriptReadByte(ctx);
     u8 whichSrc = ScriptReadByte(ctx);
@@ -328,21 +326,21 @@ bool8 ScrCmd_copylocal(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_copybyte(struct ScriptContext *ctx)
+bool8 ScrCmd_copybyte(struct ScriptContext * ctx)
 {
     u8 * dest = (u8 *)ScriptReadWord(ctx);
     *dest = *(const u8 *)ScriptReadWord(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_setvar(struct ScriptContext *ctx)
+bool8 ScrCmd_setvar(struct ScriptContext * ctx)
 {
     u16 * varPtr = GetVarPointer(ScriptReadHalfword(ctx));
     *varPtr = ScriptReadHalfword(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_copyvar(struct ScriptContext *ctx)
+bool8 ScrCmd_copyvar(struct ScriptContext * ctx)
 {
     u16 * destPtr = GetVarPointer(ScriptReadHalfword(ctx));
     u16 * srcPtr = GetVarPointer(ScriptReadHalfword(ctx));
@@ -350,7 +348,7 @@ bool8 ScrCmd_copyvar(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setorcopyvar(struct ScriptContext *ctx)
+bool8 ScrCmd_setorcopyvar(struct ScriptContext * ctx)
 {
     u16 * destPtr = GetVarPointer(ScriptReadHalfword(ctx));
     *destPtr = VarGet(ScriptReadHalfword(ctx));
@@ -368,7 +366,7 @@ u8 compare_012(u16 left, u16 right)
 }
 
 // comparelocaltolocal
-bool8 ScrCmd_compare_local_to_local(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_local_to_local(struct ScriptContext * ctx)
 {
     const u8 value1 = ctx->data[ScriptReadByte(ctx)];
     const u8 value2 = ctx->data[ScriptReadByte(ctx)];
@@ -378,7 +376,7 @@ bool8 ScrCmd_compare_local_to_local(struct ScriptContext *ctx)
 }
 
 // comparelocaltoimm
-bool8 ScrCmd_compare_local_to_value(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_local_to_value(struct ScriptContext * ctx)
 {
     const u8 value1 = ctx->data[ScriptReadByte(ctx)];
     const u8 value2 = ScriptReadByte(ctx);
@@ -387,7 +385,7 @@ bool8 ScrCmd_compare_local_to_value(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_local_to_addr(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_local_to_addr(struct ScriptContext * ctx)
 {
     const u8 value1 = ctx->data[ScriptReadByte(ctx)];
     const u8 value2 = *(const u8 *)ScriptReadWord(ctx);
@@ -396,7 +394,7 @@ bool8 ScrCmd_compare_local_to_addr(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_addr_to_local(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_addr_to_local(struct ScriptContext * ctx)
 {
     const u8 value1 = *(const u8 *)ScriptReadWord(ctx);
     const u8 value2 = ctx->data[ScriptReadByte(ctx)];
@@ -405,7 +403,7 @@ bool8 ScrCmd_compare_addr_to_local(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_addr_to_value(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_addr_to_value(struct ScriptContext * ctx)
 {
     const u8 value1 = *(const u8 *)ScriptReadWord(ctx);
     const u8 value2 = ScriptReadByte(ctx);
@@ -414,7 +412,7 @@ bool8 ScrCmd_compare_addr_to_value(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_addr_to_addr(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_addr_to_addr(struct ScriptContext * ctx)
 {
     const u8 value1 = *(const u8 *)ScriptReadWord(ctx);
     const u8 value2 = *(const u8 *)ScriptReadWord(ctx);
@@ -423,7 +421,7 @@ bool8 ScrCmd_compare_addr_to_addr(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_var_to_value(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_var_to_value(struct ScriptContext * ctx)
 {
     const u16 value1 = *GetVarPointer(ScriptReadHalfword(ctx));
     const u16 value2 = ScriptReadHalfword(ctx);
@@ -432,7 +430,7 @@ bool8 ScrCmd_compare_var_to_value(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_compare_var_to_var(struct ScriptContext *ctx)
+bool8 ScrCmd_compare_var_to_var(struct ScriptContext * ctx)
 {
     const u16 *ptr1 = GetVarPointer(ScriptReadHalfword(ctx));
     const u16 *ptr2 = GetVarPointer(ScriptReadHalfword(ctx));
@@ -441,21 +439,21 @@ bool8 ScrCmd_compare_var_to_var(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addvar(struct ScriptContext *ctx)
+bool8 ScrCmd_addvar(struct ScriptContext * ctx)
 {
     u16 *ptr = GetVarPointer(ScriptReadHalfword(ctx));
     *ptr += ScriptReadHalfword(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_subvar(struct ScriptContext *ctx)
+bool8 ScrCmd_subvar(struct ScriptContext * ctx)
 {
     u16 *ptr = GetVarPointer(ScriptReadHalfword(ctx));
     *ptr -= VarGet(ScriptReadHalfword(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_random(struct ScriptContext *ctx)
+bool8 ScrCmd_random(struct ScriptContext * ctx)
 {
     u16 max = VarGet(ScriptReadHalfword(ctx));
 
@@ -463,7 +461,7 @@ bool8 ScrCmd_random(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_additem(struct ScriptContext *ctx)
+bool8 ScrCmd_additem(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u32 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -473,7 +471,7 @@ bool8 ScrCmd_additem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_removeitem(struct ScriptContext *ctx)
+bool8 ScrCmd_removeitem(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u32 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -482,7 +480,7 @@ bool8 ScrCmd_removeitem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkitemspace(struct ScriptContext *ctx)
+bool8 ScrCmd_checkitemspace(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u32 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -491,7 +489,7 @@ bool8 ScrCmd_checkitemspace(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkitem(struct ScriptContext *ctx)
+bool8 ScrCmd_checkitem(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u32 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -500,7 +498,7 @@ bool8 ScrCmd_checkitem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkitemtype(struct ScriptContext *ctx)
+bool8 ScrCmd_checkitemtype(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
 
@@ -508,7 +506,7 @@ bool8 ScrCmd_checkitemtype(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addpcitem(struct ScriptContext *ctx)
+bool8 ScrCmd_addpcitem(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u16 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -517,7 +515,7 @@ bool8 ScrCmd_addpcitem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkpcitem(struct ScriptContext *ctx)
+bool8 ScrCmd_checkpcitem(struct ScriptContext * ctx)
 {
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
     u16 quantity = VarGet(ScriptReadHalfword(ctx));
@@ -526,7 +524,7 @@ bool8 ScrCmd_checkpcitem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_givedecoration(struct ScriptContext *ctx)
+bool8 ScrCmd_givedecoration(struct ScriptContext * ctx)
 {
     u32 decorId = VarGet(ScriptReadHalfword(ctx));
 
@@ -534,7 +532,7 @@ bool8 ScrCmd_givedecoration(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_takedecoration(struct ScriptContext *ctx)
+bool8 ScrCmd_takedecoration(struct ScriptContext * ctx)
 {
     u32 decorId = VarGet(ScriptReadHalfword(ctx));
 
@@ -542,7 +540,7 @@ bool8 ScrCmd_takedecoration(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkdecorspace(struct ScriptContext *ctx)
+bool8 ScrCmd_checkdecorspace(struct ScriptContext * ctx)
 {
     u32 decorId = VarGet(ScriptReadHalfword(ctx));
 
@@ -550,7 +548,7 @@ bool8 ScrCmd_checkdecorspace(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkdecor(struct ScriptContext *ctx)
+bool8 ScrCmd_checkdecor(struct ScriptContext * ctx)
 {
     u32 decorId = VarGet(ScriptReadHalfword(ctx));
 
@@ -558,31 +556,31 @@ bool8 ScrCmd_checkdecor(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setflag(struct ScriptContext *ctx)
+bool8 ScrCmd_setflag(struct ScriptContext * ctx)
 {
     FlagSet(ScriptReadHalfword(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_clearflag(struct ScriptContext *ctx)
+bool8 ScrCmd_clearflag(struct ScriptContext * ctx)
 {
     FlagClear(ScriptReadHalfword(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_checkflag(struct ScriptContext *ctx)
+bool8 ScrCmd_checkflag(struct ScriptContext * ctx)
 {
     ctx->comparisonResult = FlagGet(ScriptReadHalfword(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_incrementgamestat(struct ScriptContext *ctx)
+bool8 ScrCmd_incrementgamestat(struct ScriptContext * ctx)
 {
     IncrementGameStat(ScriptReadByte(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_comparestattoword(struct ScriptContext *ctx)
+bool8 ScrCmd_comparestattoword(struct ScriptContext * ctx)
 {
     u8 statIdx = ScriptReadByte(ctx);
     u32 value = ScriptReadWord(ctx);
@@ -597,22 +595,22 @@ bool8 ScrCmd_comparestattoword(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setworldmapflag(struct ScriptContext *ctx)
+bool8 ScrCmd_setworldmapflag(struct ScriptContext * ctx)
 {
     u16 value = ScriptReadHalfword(ctx);
-    sub_8115748(value);
-    sub_80F85BC(value);
+    QuestLog_RecordEnteredMap(value);
+    MapPreview_SetFlag(value);
     return FALSE;
 }
 
-bool8 ScrCmd_animateflash(struct ScriptContext *ctx)
+bool8 ScrCmd_animateflash(struct ScriptContext * ctx)
 {
     AnimateFlash(ScriptReadByte(ctx));
     ScriptContext1_Stop();
     return TRUE;
 }
 
-bool8 ScrCmd_setflashradius(struct ScriptContext *ctx)
+bool8 ScrCmd_setflashradius(struct ScriptContext * ctx)
 {
     u16 flashLevel = VarGet(ScriptReadHalfword(ctx));
 
@@ -628,14 +626,14 @@ static bool8 IsPaletteNotActive(void)
         return FALSE;
 }
 
-bool8 ScrCmd_fadescreen(struct ScriptContext *ctx)
+bool8 ScrCmd_fadescreen(struct ScriptContext * ctx)
 {
     FadeScreen(ScriptReadByte(ctx), 0);
     SetupNativeScript(ctx, IsPaletteNotActive);
     return TRUE;
 }
 
-bool8 ScrCmd_fadescreenspeed(struct ScriptContext *ctx)
+bool8 ScrCmd_fadescreenspeed(struct ScriptContext * ctx)
 {
     u8 mode = ScriptReadByte(ctx);
     u8 speed = ScriptReadByte(ctx);
@@ -655,14 +653,14 @@ static bool8 RunPauseTimer(void)
         return FALSE;
 }
 
-bool8 ScrCmd_delay(struct ScriptContext *ctx)
+bool8 ScrCmd_delay(struct ScriptContext * ctx)
 {
     sPauseCounter = ScriptReadHalfword(ctx);
     SetupNativeScript(ctx, RunPauseTimer);
     return TRUE;
 }
 
-bool8 ScrCmd_initclock(struct ScriptContext *ctx)
+bool8 ScrCmd_initclock(struct ScriptContext * ctx)
 {
 //    u8 hour = VarGet(ScriptReadHalfword(ctx));
 //    u8 minute = VarGet(ScriptReadHalfword(ctx));
@@ -671,13 +669,13 @@ bool8 ScrCmd_initclock(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_dodailyevents(struct ScriptContext *ctx)
+bool8 ScrCmd_dodailyevents(struct ScriptContext * ctx)
 {
 //    DoTimeBasedEvents();
     return FALSE;
 }
 
-bool8 ScrCmd_gettime(struct ScriptContext *ctx)
+bool8 ScrCmd_gettime(struct ScriptContext * ctx)
 {
 //    RtcCalcLocalTime();
 //    gSpecialVar_0x8000 = gLocalTime.hours;
@@ -689,7 +687,7 @@ bool8 ScrCmd_gettime(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setweather(struct ScriptContext *ctx)
+bool8 ScrCmd_setweather(struct ScriptContext * ctx)
 {
     u16 weather = VarGet(ScriptReadHalfword(ctx));
 
@@ -697,25 +695,25 @@ bool8 ScrCmd_setweather(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_resetweather(struct ScriptContext *ctx)
+bool8 ScrCmd_resetweather(struct ScriptContext * ctx)
 {
     SetSav1WeatherFromCurrMapHeader();
     return FALSE;
 }
 
-bool8 ScrCmd_doweather(struct ScriptContext *ctx)
+bool8 ScrCmd_doweather(struct ScriptContext * ctx)
 {
     DoCurrentWeather();
     return FALSE;
 }
 
-bool8 ScrCmd_setstepcallback(struct ScriptContext *ctx)
+bool8 ScrCmd_setstepcallback(struct ScriptContext * ctx)
 {
     ActivatePerStepCallback(ScriptReadByte(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_setmaplayoutindex(struct ScriptContext *ctx)
+bool8 ScrCmd_setmaplayoutindex(struct ScriptContext * ctx)
 {
     u16 value = VarGet(ScriptReadHalfword(ctx));
 
@@ -723,7 +721,7 @@ bool8 ScrCmd_setmaplayoutindex(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_warp(struct ScriptContext *ctx)
+bool8 ScrCmd_warp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -737,7 +735,7 @@ bool8 ScrCmd_warp(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_warpsilent(struct ScriptContext *ctx)
+bool8 ScrCmd_warpsilent(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -751,7 +749,7 @@ bool8 ScrCmd_warpsilent(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_warpdoor(struct ScriptContext *ctx)
+bool8 ScrCmd_warpdoor(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -765,7 +763,7 @@ bool8 ScrCmd_warpdoor(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_warphole(struct ScriptContext *ctx)
+bool8 ScrCmd_warphole(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -782,7 +780,7 @@ bool8 ScrCmd_warphole(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_warpteleport(struct ScriptContext *ctx)
+bool8 ScrCmd_warpteleport(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -796,7 +794,7 @@ bool8 ScrCmd_warpteleport(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_warpteleport2(struct ScriptContext *ctx)
+bool8 ScrCmd_warpteleport2(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -811,7 +809,7 @@ bool8 ScrCmd_warpteleport2(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_setwarp(struct ScriptContext *ctx)
+bool8 ScrCmd_setwarp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -823,7 +821,7 @@ bool8 ScrCmd_setwarp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setdynamicwarp(struct ScriptContext *ctx)
+bool8 ScrCmd_setdynamicwarp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -835,7 +833,7 @@ bool8 ScrCmd_setdynamicwarp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setdivewarp(struct ScriptContext *ctx)
+bool8 ScrCmd_setdivewarp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -847,7 +845,7 @@ bool8 ScrCmd_setdivewarp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setholewarp(struct ScriptContext *ctx)
+bool8 ScrCmd_setholewarp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -859,7 +857,7 @@ bool8 ScrCmd_setholewarp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setescapewarp(struct ScriptContext *ctx)
+bool8 ScrCmd_setescapewarp(struct ScriptContext * ctx)
 {
     u8 mapGroup = ScriptReadByte(ctx);
     u8 mapNum = ScriptReadByte(ctx);
@@ -871,7 +869,7 @@ bool8 ScrCmd_setescapewarp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_getplayerxy(struct ScriptContext *ctx)
+bool8 ScrCmd_getplayerxy(struct ScriptContext * ctx)
 {
     u16 *pX = GetVarPointer(ScriptReadHalfword(ctx));
     u16 *pY = GetVarPointer(ScriptReadHalfword(ctx));
@@ -881,13 +879,13 @@ bool8 ScrCmd_getplayerxy(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_getpartysize(struct ScriptContext *ctx)
+bool8 ScrCmd_getpartysize(struct ScriptContext * ctx)
 {
     gSpecialVar_Result = CalculatePlayerPartyCount();
     return FALSE;
 }
 
-bool8 ScrCmd_playse(struct ScriptContext *ctx)
+bool8 ScrCmd_playse(struct ScriptContext * ctx)
 {
     PlaySE(ScriptReadHalfword(ctx));
     return FALSE;
@@ -901,13 +899,13 @@ static bool8 WaitForSoundEffectFinish(void)
         return FALSE;
 }
 
-bool8 ScrCmd_waitse(struct ScriptContext *ctx)
+bool8 ScrCmd_waitse(struct ScriptContext * ctx)
 {
     SetupNativeScript(ctx, WaitForSoundEffectFinish);
     return TRUE;
 }
 
-bool8 ScrCmd_playfanfare(struct ScriptContext *ctx)
+bool8 ScrCmd_playfanfare(struct ScriptContext * ctx)
 {
     PlayFanfare(ScriptReadHalfword(ctx));
     return FALSE;
@@ -918,13 +916,13 @@ static bool8 WaitForFanfareFinish(void)
     return IsFanfareTaskInactive();
 }
 
-bool8 ScrCmd_waitfanfare(struct ScriptContext *ctx)
+bool8 ScrCmd_waitfanfare(struct ScriptContext * ctx)
 {
     SetupNativeScript(ctx, WaitForFanfareFinish);
     return TRUE;
 }
 
-bool8 ScrCmd_playbgm(struct ScriptContext *ctx)
+bool8 ScrCmd_playbgm(struct ScriptContext * ctx)
 {
     u16 songId = ScriptReadHalfword(ctx);
     bool8 val = ScriptReadByte(ctx);
@@ -937,13 +935,13 @@ bool8 ScrCmd_playbgm(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_savebgm(struct ScriptContext *ctx)
+bool8 ScrCmd_savebgm(struct ScriptContext * ctx)
 {
     Overworld_SetSavedMusic(ScriptReadHalfword(ctx));
     return FALSE;
 }
 
-bool8 ScrCmd_fadedefaultbgm(struct ScriptContext *ctx)
+bool8 ScrCmd_fadedefaultbgm(struct ScriptContext * ctx)
 {
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return FALSE;
@@ -951,7 +949,7 @@ bool8 ScrCmd_fadedefaultbgm(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_fadenewbgm(struct ScriptContext *ctx)
+bool8 ScrCmd_fadenewbgm(struct ScriptContext * ctx)
 {
     u16 music = ScriptReadHalfword(ctx);
     if (gQuestLogState == 2 || gQuestLogState == 3)
@@ -960,7 +958,7 @@ bool8 ScrCmd_fadenewbgm(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_fadeoutbgm(struct ScriptContext *ctx)
+bool8 ScrCmd_fadeoutbgm(struct ScriptContext * ctx)
 {
     u8 speed = ScriptReadByte(ctx);
 
@@ -974,7 +972,7 @@ bool8 ScrCmd_fadeoutbgm(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_fadeinbgm(struct ScriptContext *ctx)
+bool8 ScrCmd_fadeinbgm(struct ScriptContext * ctx)
 {
     u8 speed = ScriptReadByte(ctx);
 
@@ -987,7 +985,7 @@ bool8 ScrCmd_fadeinbgm(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_applymovement(struct ScriptContext *ctx)
+bool8 ScrCmd_applymovement(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     const void *movementScript = (const void *)ScriptReadWord(ctx);
@@ -997,7 +995,7 @@ bool8 ScrCmd_applymovement(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_applymovement_at(struct ScriptContext *ctx)
+bool8 ScrCmd_applymovement_at(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     const void *movementScript = (const void *)ScriptReadWord(ctx);
@@ -1014,7 +1012,7 @@ static bool8 WaitForMovementFinish(void)
     return ScriptMovement_IsObjectMovementFinished(sMovingNpcId, sMovingNpcMapId, sMovingNpcMapBank);
 }
 
-bool8 ScrCmd_waitmovement(struct ScriptContext *ctx)
+bool8 ScrCmd_waitmovement(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
 
@@ -1026,7 +1024,7 @@ bool8 ScrCmd_waitmovement(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_waitmovement_at(struct ScriptContext *ctx)
+bool8 ScrCmd_waitmovement_at(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 mapBank;
@@ -1042,7 +1040,7 @@ bool8 ScrCmd_waitmovement_at(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_removeobject(struct ScriptContext *ctx)
+bool8 ScrCmd_removeobject(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
 
@@ -1050,7 +1048,7 @@ bool8 ScrCmd_removeobject(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_removeobject_at(struct ScriptContext *ctx)
+bool8 ScrCmd_removeobject_at(struct ScriptContext * ctx)
 {
     u16 objectId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1060,7 +1058,7 @@ bool8 ScrCmd_removeobject_at(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addobject(struct ScriptContext *ctx)
+bool8 ScrCmd_addobject(struct ScriptContext * ctx)
 {
     u16 objectId = VarGet(ScriptReadHalfword(ctx));
 
@@ -1068,7 +1066,7 @@ bool8 ScrCmd_addobject(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addobject_at(struct ScriptContext *ctx)
+bool8 ScrCmd_addobject_at(struct ScriptContext * ctx)
 {
     u16 objectId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1078,7 +1076,7 @@ bool8 ScrCmd_addobject_at(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setobjectxy(struct ScriptContext *ctx)
+bool8 ScrCmd_setobjectxy(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u16 x = VarGet(ScriptReadHalfword(ctx));
@@ -1088,7 +1086,7 @@ bool8 ScrCmd_setobjectxy(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setobjectxyperm(struct ScriptContext *ctx)
+bool8 ScrCmd_setobjectxyperm(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u16 x = VarGet(ScriptReadHalfword(ctx));
@@ -1098,7 +1096,7 @@ bool8 ScrCmd_setobjectxyperm(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_moveobjectoffscreen(struct ScriptContext *ctx)
+bool8 ScrCmd_moveobjectoffscreen(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
 
@@ -1106,7 +1104,7 @@ bool8 ScrCmd_moveobjectoffscreen(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showobject_at(struct ScriptContext *ctx)
+bool8 ScrCmd_showobject_at(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1116,7 +1114,7 @@ bool8 ScrCmd_showobject_at(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_hideobject_at(struct ScriptContext *ctx)
+bool8 ScrCmd_hideobject_at(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1126,7 +1124,7 @@ bool8 ScrCmd_hideobject_at(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setobjectpriority(struct ScriptContext *ctx)
+bool8 ScrCmd_setobjectpriority(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1137,7 +1135,7 @@ bool8 ScrCmd_setobjectpriority(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_resetobjectpriority(struct ScriptContext *ctx)
+bool8 ScrCmd_resetobjectpriority(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 mapGroup = ScriptReadByte(ctx);
@@ -1147,7 +1145,7 @@ bool8 ScrCmd_resetobjectpriority(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_faceplayer(struct ScriptContext *ctx)
+bool8 ScrCmd_faceplayer(struct ScriptContext * ctx)
 {
     if (gObjectEvents[gSelectedObjectEvent].active)
     {
@@ -1157,7 +1155,7 @@ bool8 ScrCmd_faceplayer(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_turnobject(struct ScriptContext *ctx)
+bool8 ScrCmd_turnobject(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 direction = ScriptReadByte(ctx);
@@ -1166,7 +1164,7 @@ bool8 ScrCmd_turnobject(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setobjectmovementtype(struct ScriptContext *ctx)
+bool8 ScrCmd_setobjectmovementtype(struct ScriptContext * ctx)
 {
     u16 localId = VarGet(ScriptReadHalfword(ctx));
     u8 movementType = ScriptReadByte(ctx);
@@ -1175,7 +1173,7 @@ bool8 ScrCmd_setobjectmovementtype(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_createvobject(struct ScriptContext *ctx)
+bool8 ScrCmd_createvobject(struct ScriptContext * ctx)
 {
     u8 graphicsId = ScriptReadByte(ctx);
     u8 v2 = ScriptReadByte(ctx);
@@ -1188,16 +1186,16 @@ bool8 ScrCmd_createvobject(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_turnvobject(struct ScriptContext *ctx)
+bool8 ScrCmd_turnvobject(struct ScriptContext * ctx)
 {
     u8 v1 = ScriptReadByte(ctx);
     u8 direction = ScriptReadByte(ctx);
 
-    sub_8069058(v1, direction);
+    TurnObjectEvent(v1, direction);
     return FALSE;
 }
 
-bool8 ScrCmd_lockall(struct ScriptContext *ctx)
+bool8 ScrCmd_lockall(struct ScriptContext * ctx)
 {
     if (IsUpdateLinkStateCBActive())
     {
@@ -1211,7 +1209,7 @@ bool8 ScrCmd_lockall(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_lock(struct ScriptContext *ctx)
+bool8 ScrCmd_lock(struct ScriptContext * ctx)
 {
     if (IsUpdateLinkStateCBActive())
     {
@@ -1233,19 +1231,19 @@ bool8 ScrCmd_lock(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_releaseall(struct ScriptContext *ctx)
+bool8 ScrCmd_releaseall(struct ScriptContext * ctx)
 {
     u8 playerObjectId;
 
     HideFieldMessageBox();
     playerObjectId = GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0);
     ObjectEventClearHeldMovementIfFinished(&gObjectEvents[playerObjectId]);
-    sub_80974D8();
+    ScriptMovement_UnfreezeObjectEvents();
     UnfreezeObjectEvents();
     return FALSE;
 }
 
-bool8 ScrCmd_release(struct ScriptContext *ctx)
+bool8 ScrCmd_release(struct ScriptContext * ctx)
 {
     u8 playerObjectId;
 
@@ -1254,19 +1252,19 @@ bool8 ScrCmd_release(struct ScriptContext *ctx)
         ObjectEventClearHeldMovementIfFinished(&gObjectEvents[gSelectedObjectEvent]);
     playerObjectId = GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0);
     ObjectEventClearHeldMovementIfFinished(&gObjectEvents[playerObjectId]);
-    sub_80974D8();
+    ScriptMovement_UnfreezeObjectEvents();
     UnfreezeObjectEvents();
     return FALSE;
 }
 
-bool8 ScrCmd_textcolor(struct ScriptContext *ctx)
+bool8 ScrCmd_textcolor(struct ScriptContext * ctx)
 {
     gSpecialVar_PrevTextColor = gSpecialVar_TextColor;
     gSpecialVar_TextColor = ScriptReadByte(ctx);
     return FALSE;
 }
 
-bool8 ScrCmd_message(struct ScriptContext *ctx)
+bool8 ScrCmd_message(struct ScriptContext * ctx)
 {
     const u8 *msg = (const u8 *)ScriptReadWord(ctx);
 
@@ -1276,7 +1274,7 @@ bool8 ScrCmd_message(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_loadhelp(struct ScriptContext *ctx)
+bool8 ScrCmd_loadhelp(struct ScriptContext * ctx)
 {
     const u8 *msg = (const u8 *)ScriptReadWord(ctx);
 
@@ -1287,13 +1285,13 @@ bool8 ScrCmd_loadhelp(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_unloadhelp(struct ScriptContext *ctx)
+bool8 ScrCmd_unloadhelp(struct ScriptContext * ctx)
 {
     DestroyHelpMessageWindow_();
     return FALSE;
 }
 
-bool8 ScrCmd_messageautoscroll(struct ScriptContext *ctx)
+bool8 ScrCmd_messageautoscroll(struct ScriptContext * ctx)
 {
     const u8 *msg = (const u8 *)ScriptReadWord(ctx);
 
@@ -1303,13 +1301,13 @@ bool8 ScrCmd_messageautoscroll(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_waitmessage(struct ScriptContext *ctx)
+bool8 ScrCmd_waitmessage(struct ScriptContext * ctx)
 {
     SetupNativeScript(ctx, IsFieldMessageBoxHidden);
     return TRUE;
 }
 
-bool8 ScrCmd_closemessage(struct ScriptContext *ctx)
+bool8 ScrCmd_closemessage(struct ScriptContext * ctx)
 {
     HideFieldMessageBox();
     return FALSE;
@@ -1403,7 +1401,7 @@ static u8 sub_806B96C(struct ScriptContext * ctx)
     return 0;
 }
 
-bool8 ScrCmd_waitbuttonpress(struct ScriptContext *ctx)
+bool8 ScrCmd_waitbuttonpress(struct ScriptContext * ctx)
 {
     gUnknown_3005070 = ctx;
 
@@ -1413,7 +1411,7 @@ bool8 ScrCmd_waitbuttonpress(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_yesnobox(struct ScriptContext *ctx)
+bool8 ScrCmd_yesnobox(struct ScriptContext * ctx)
 {
     u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1429,7 +1427,7 @@ bool8 ScrCmd_yesnobox(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_multichoice(struct ScriptContext *ctx)
+bool8 ScrCmd_multichoice(struct ScriptContext * ctx)
 {
     u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1447,7 +1445,7 @@ bool8 ScrCmd_multichoice(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_multichoicedefault(struct ScriptContext *ctx)
+bool8 ScrCmd_multichoicedefault(struct ScriptContext * ctx)
 {
     u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1466,7 +1464,7 @@ bool8 ScrCmd_multichoicedefault(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_drawbox(struct ScriptContext *ctx)
+bool8 ScrCmd_drawbox(struct ScriptContext * ctx)
 {
     /*u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1477,7 +1475,7 @@ bool8 ScrCmd_drawbox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_multichoicegrid(struct ScriptContext *ctx)
+bool8 ScrCmd_multichoicegrid(struct ScriptContext * ctx)
 {
     u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1496,7 +1494,7 @@ bool8 ScrCmd_multichoicegrid(struct ScriptContext *ctx)
     }
 }
 
-bool8 ScrCmd_erasebox(struct ScriptContext *ctx)
+bool8 ScrCmd_erasebox(struct ScriptContext * ctx)
 {
     u8 left = ScriptReadByte(ctx);
     u8 top = ScriptReadByte(ctx);
@@ -1507,7 +1505,7 @@ bool8 ScrCmd_erasebox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_drawboxtext(struct ScriptContext *ctx)
+bool8 ScrCmd_drawboxtext(struct ScriptContext * ctx)
 {
 //    u8 left = ScriptReadByte(ctx);
 //    u8 top = ScriptReadByte(ctx);
@@ -1522,7 +1520,7 @@ bool8 ScrCmd_drawboxtext(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showmonpic(struct ScriptContext *ctx)
+bool8 ScrCmd_showmonpic(struct ScriptContext * ctx)
 {
     u16 species = VarGet(ScriptReadHalfword(ctx));
     u8 x = ScriptReadByte(ctx);
@@ -1533,7 +1531,7 @@ bool8 ScrCmd_showmonpic(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_hidemonpic(struct ScriptContext *ctx)
+bool8 ScrCmd_hidemonpic(struct ScriptContext * ctx)
 {
     bool8 (*func)(void) = ScriptMenu_GetPicboxWaitFunc();
 
@@ -1543,7 +1541,7 @@ bool8 ScrCmd_hidemonpic(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_showcontestwinner(struct ScriptContext *ctx)
+bool8 ScrCmd_showcontestwinner(struct ScriptContext * ctx)
 {
     u8 v1 = ScriptReadByte(ctx);
 
@@ -1558,7 +1556,7 @@ bool8 ScrCmd_showcontestwinner(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_braillemessage(struct ScriptContext *ctx)
+bool8 ScrCmd_braillemessage(struct ScriptContext * ctx)
 {
     u8 *ptr = (u8 *)ScriptReadWord(ctx);
     if (ptr == NULL)
@@ -1570,7 +1568,7 @@ bool8 ScrCmd_braillemessage(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_getbraillestringwidth(struct ScriptContext *ctx)
+bool8 ScrCmd_getbraillestringwidth(struct ScriptContext * ctx)
 {
     u8 *ptr = (u8 *)ScriptReadWord(ctx);
     if (ptr == NULL)
@@ -1580,7 +1578,7 @@ bool8 ScrCmd_getbraillestringwidth(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_vmessage(struct ScriptContext *ctx)
+bool8 ScrCmd_vmessage(struct ScriptContext * ctx)
 {
     u32 v1 = ScriptReadWord(ctx);
 
@@ -1588,14 +1586,14 @@ bool8 ScrCmd_vmessage(struct ScriptContext *ctx)
     return FALSE;
 }
 
-u8 * const sScriptStringVars[] =
+u8 *const sScriptStringVars[] =
 {
     gStringVar1,
     gStringVar2,
     gStringVar3,
 };
 
-bool8 ScrCmd_bufferspeciesname(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferspeciesname(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 species = VarGet(ScriptReadHalfword(ctx));
@@ -1604,7 +1602,7 @@ bool8 ScrCmd_bufferspeciesname(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferleadmonspeciesname(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferleadmonspeciesname(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
 
@@ -1615,7 +1613,7 @@ bool8 ScrCmd_bufferleadmonspeciesname(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferpartymonnick(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferpartymonnick(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 partyIndex = VarGet(ScriptReadHalfword(ctx));
@@ -1625,7 +1623,7 @@ bool8 ScrCmd_bufferpartymonnick(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferitemname(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferitemname(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
@@ -1637,7 +1635,7 @@ bool8 ScrCmd_bufferitemname(struct ScriptContext *ctx)
 const u8 gUnknown_83A72A0[] = _("S");
 const u8 gUnknown_83A72A2[] = _("IES");
 
-bool8 ScrCmd_bufferitemnameplural(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferitemnameplural(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 itemId = VarGet(ScriptReadHalfword(ctx));
@@ -1660,7 +1658,7 @@ bool8 ScrCmd_bufferitemnameplural(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferdecorationname(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferdecorationname(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 decorId = VarGet(ScriptReadHalfword(ctx));
@@ -1669,7 +1667,7 @@ bool8 ScrCmd_bufferdecorationname(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_buffermovename(struct ScriptContext *ctx)
+bool8 ScrCmd_buffermovename(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 moveId = VarGet(ScriptReadHalfword(ctx));
@@ -1678,7 +1676,7 @@ bool8 ScrCmd_buffermovename(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_buffernumberstring(struct ScriptContext *ctx)
+bool8 ScrCmd_buffernumberstring(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 v1 = VarGet(ScriptReadHalfword(ctx));
@@ -1688,7 +1686,7 @@ bool8 ScrCmd_buffernumberstring(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferstdstring(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferstdstring(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 index = VarGet(ScriptReadHalfword(ctx));
@@ -1698,7 +1696,7 @@ bool8 ScrCmd_bufferstdstring(struct ScriptContext *ctx)
 }
 
 /*
-bool8 ScrCmd_buffercontesttype(struct ScriptContext *ctx)
+bool8 ScrCmd_buffercontesttype(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 index = VarGet(ScriptReadHalfword(ctx));
@@ -1708,7 +1706,7 @@ bool8 ScrCmd_buffercontesttype(struct ScriptContext *ctx)
 }
 */
 
-bool8 ScrCmd_bufferstring(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferstring(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     const u8 *text = (u8 *)ScriptReadWord(ctx);
@@ -1717,7 +1715,7 @@ bool8 ScrCmd_bufferstring(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_vloadword(struct ScriptContext *ctx)
+bool8 ScrCmd_vloadword(struct ScriptContext * ctx)
 {
     const u8 *ptr = (u8 *)(ScriptReadWord(ctx) - gVScriptOffset);
 
@@ -1725,7 +1723,7 @@ bool8 ScrCmd_vloadword(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_vbufferstring(struct ScriptContext *ctx)
+bool8 ScrCmd_vbufferstring(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u32 addr = ScriptReadWord(ctx);
@@ -1736,7 +1734,7 @@ bool8 ScrCmd_vbufferstring(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_bufferboxname(struct ScriptContext *ctx)
+bool8 ScrCmd_bufferboxname(struct ScriptContext * ctx)
 {
     u8 stringVarIndex = ScriptReadByte(ctx);
     u16 boxId = VarGet(ScriptReadHalfword(ctx));
@@ -1745,7 +1743,7 @@ bool8 ScrCmd_bufferboxname(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_givemon(struct ScriptContext *ctx)
+bool8 ScrCmd_givemon(struct ScriptContext * ctx)
 {
     u16 species = VarGet(ScriptReadHalfword(ctx));
     u8 level = ScriptReadByte(ctx);
@@ -1758,7 +1756,7 @@ bool8 ScrCmd_givemon(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_giveegg(struct ScriptContext *ctx)
+bool8 ScrCmd_giveegg(struct ScriptContext * ctx)
 {
     u16 species = VarGet(ScriptReadHalfword(ctx));
 
@@ -1766,7 +1764,7 @@ bool8 ScrCmd_giveegg(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setmonmove(struct ScriptContext *ctx)
+bool8 ScrCmd_setmonmove(struct ScriptContext * ctx)
 {
     u8 partyIndex = ScriptReadByte(ctx);
     u8 slot = ScriptReadByte(ctx);
@@ -1776,7 +1774,7 @@ bool8 ScrCmd_setmonmove(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkpartymove(struct ScriptContext *ctx)
+bool8 ScrCmd_checkpartymove(struct ScriptContext * ctx)
 {
     u8 i;
     u16 moveId = ScriptReadHalfword(ctx);
@@ -1797,7 +1795,7 @@ bool8 ScrCmd_checkpartymove(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addmoney(struct ScriptContext *ctx)
+bool8 ScrCmd_addmoney(struct ScriptContext * ctx)
 {
     u32 amount = ScriptReadWord(ctx);
     u8 ignore = ScriptReadByte(ctx);
@@ -1807,7 +1805,7 @@ bool8 ScrCmd_addmoney(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_removemoney(struct ScriptContext *ctx)
+bool8 ScrCmd_removemoney(struct ScriptContext * ctx)
 {
     u32 amount = ScriptReadWord(ctx);
     u8 ignore = ScriptReadByte(ctx);
@@ -1817,7 +1815,7 @@ bool8 ScrCmd_removemoney(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkmoney(struct ScriptContext *ctx)
+bool8 ScrCmd_checkmoney(struct ScriptContext * ctx)
 {
     u32 amount = ScriptReadWord(ctx);
     u8 ignore = ScriptReadByte(ctx);
@@ -1827,7 +1825,7 @@ bool8 ScrCmd_checkmoney(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showmoneybox(struct ScriptContext *ctx)
+bool8 ScrCmd_showmoneybox(struct ScriptContext * ctx)
 {
     u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);
@@ -1838,7 +1836,7 @@ bool8 ScrCmd_showmoneybox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_hidemoneybox(struct ScriptContext *ctx)
+bool8 ScrCmd_hidemoneybox(struct ScriptContext * ctx)
 {
     /*u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);*/
@@ -1847,7 +1845,7 @@ bool8 ScrCmd_hidemoneybox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_updatemoneybox(struct ScriptContext *ctx)
+bool8 ScrCmd_updatemoneybox(struct ScriptContext * ctx)
 {
     u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);
@@ -1858,7 +1856,7 @@ bool8 ScrCmd_updatemoneybox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showcoinsbox(struct ScriptContext *ctx)
+bool8 ScrCmd_showcoinsbox(struct ScriptContext * ctx)
 {
     u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);
@@ -1868,7 +1866,7 @@ bool8 ScrCmd_showcoinsbox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_hidecoinsbox(struct ScriptContext *ctx)
+bool8 ScrCmd_hidecoinsbox(struct ScriptContext * ctx)
 {
     u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);
@@ -1877,7 +1875,7 @@ bool8 ScrCmd_hidecoinsbox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_updatecoinsbox(struct ScriptContext *ctx)
+bool8 ScrCmd_updatecoinsbox(struct ScriptContext * ctx)
 {
     u8 x = ScriptReadByte(ctx);
     u8 y = ScriptReadByte(ctx);
@@ -1886,31 +1884,31 @@ bool8 ScrCmd_updatecoinsbox(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_trainerbattle(struct ScriptContext *ctx)
+bool8 ScrCmd_trainerbattle(struct ScriptContext * ctx)
 {
     ctx->scriptPtr = BattleSetup_ConfigureTrainerBattle(ctx->scriptPtr);
     return FALSE;
 }
 
-bool8 ScrCmd_dotrainerbattle(struct ScriptContext *ctx)
+bool8 ScrCmd_dotrainerbattle(struct ScriptContext * ctx)
 {
-    BattleSetup_StartTrainerBattle();
+    StartTrainerBattle();
     return TRUE;
 }
 
-bool8 ScrCmd_gotopostbattlescript(struct ScriptContext *ctx)
+bool8 ScrCmd_gotopostbattlescript(struct ScriptContext * ctx)
 {
     ctx->scriptPtr = BattleSetup_GetScriptAddrAfterBattle();
     return FALSE;
 }
 
-bool8 ScrCmd_gotobeatenscript(struct ScriptContext *ctx)
+bool8 ScrCmd_gotobeatenscript(struct ScriptContext * ctx)
 {
     ctx->scriptPtr = BattleSetup_GetTrainerPostBattleScript();
     return FALSE;
 }
 
-bool8 ScrCmd_checktrainerflag(struct ScriptContext *ctx)
+bool8 ScrCmd_checktrainerflag(struct ScriptContext * ctx)
 {
     u16 index = VarGet(ScriptReadHalfword(ctx));
 
@@ -1918,7 +1916,7 @@ bool8 ScrCmd_checktrainerflag(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_settrainerflag(struct ScriptContext *ctx)
+bool8 ScrCmd_settrainerflag(struct ScriptContext * ctx)
 {
     u16 index = VarGet(ScriptReadHalfword(ctx));
 
@@ -1926,7 +1924,7 @@ bool8 ScrCmd_settrainerflag(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_cleartrainerflag(struct ScriptContext *ctx)
+bool8 ScrCmd_cleartrainerflag(struct ScriptContext * ctx)
 {
     u16 index = VarGet(ScriptReadHalfword(ctx));
 
@@ -1934,7 +1932,7 @@ bool8 ScrCmd_cleartrainerflag(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setwildbattle(struct ScriptContext *ctx)
+bool8 ScrCmd_setwildbattle(struct ScriptContext * ctx)
 {
     u16 species = ScriptReadHalfword(ctx);
     u8 level = ScriptReadByte(ctx);
@@ -1944,14 +1942,14 @@ bool8 ScrCmd_setwildbattle(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_dowildbattle(struct ScriptContext *ctx)
+bool8 ScrCmd_dowildbattle(struct ScriptContext * ctx)
 {
-    BattleSetup_StartScriptedWildBattle();
+    StartScriptedWildBattle();
     ScriptContext1_Stop();
     return TRUE;
 }
 
-bool8 ScrCmd_pokemart(struct ScriptContext *ctx)
+bool8 ScrCmd_pokemart(struct ScriptContext * ctx)
 {
     const void *ptr = (void *)ScriptReadWord(ctx);
 
@@ -1960,7 +1958,7 @@ bool8 ScrCmd_pokemart(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_pokemartdecoration(struct ScriptContext *ctx)
+bool8 ScrCmd_pokemartdecoration(struct ScriptContext * ctx)
 {
     const void *ptr = (void *)ScriptReadWord(ctx);
 
@@ -1969,7 +1967,7 @@ bool8 ScrCmd_pokemartdecoration(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_pokemartdecoration2(struct ScriptContext *ctx)
+bool8 ScrCmd_pokemartdecoration2(struct ScriptContext * ctx)
 {
     const void *ptr = (void *)ScriptReadWord(ctx);
 
@@ -1978,7 +1976,7 @@ bool8 ScrCmd_pokemartdecoration2(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_playslotmachine(struct ScriptContext *ctx)
+bool8 ScrCmd_playslotmachine(struct ScriptContext * ctx)
 {
     u8 slotMachineIndex = VarGet(ScriptReadHalfword(ctx));
 
@@ -1987,7 +1985,7 @@ bool8 ScrCmd_playslotmachine(struct ScriptContext *ctx)
     return TRUE;
 }
 
-bool8 ScrCmd_setberrytree(struct ScriptContext *ctx)
+bool8 ScrCmd_setberrytree(struct ScriptContext * ctx)
 {
 //    u8 treeId = ScriptReadByte(ctx);
 //    u8 berry = ScriptReadByte(ctx);
@@ -2000,7 +1998,7 @@ bool8 ScrCmd_setberrytree(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_getpricereduction(struct ScriptContext *ctx)
+bool8 ScrCmd_getpricereduction(struct ScriptContext * ctx)
 {
 //    u16 value = VarGet(ScriptReadHalfword(ctx));
 //
@@ -2008,7 +2006,7 @@ bool8 ScrCmd_getpricereduction(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_choosecontestmon(struct ScriptContext *ctx)
+bool8 ScrCmd_choosecontestmon(struct ScriptContext * ctx)
 {
 //    sub_81B9404();
     ScriptContext1_Stop();
@@ -2016,7 +2014,7 @@ bool8 ScrCmd_choosecontestmon(struct ScriptContext *ctx)
 }
 
 
-bool8 ScrCmd_startcontest(struct ScriptContext *ctx)
+bool8 ScrCmd_startcontest(struct ScriptContext * ctx)
 {
 //    sub_80F840C();
 //    ScriptContext1_Stop();
@@ -2024,7 +2022,7 @@ bool8 ScrCmd_startcontest(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showcontestresults(struct ScriptContext *ctx)
+bool8 ScrCmd_showcontestresults(struct ScriptContext * ctx)
 {
 //    sub_80F8484();
 //    ScriptContext1_Stop();
@@ -2032,7 +2030,7 @@ bool8 ScrCmd_showcontestresults(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_contestlinktransfer(struct ScriptContext *ctx)
+bool8 ScrCmd_contestlinktransfer(struct ScriptContext * ctx)
 {
 //    sub_80F84C4(gSpecialVar_ContestCategory);
 //    ScriptContext1_Stop();
@@ -2040,7 +2038,7 @@ bool8 ScrCmd_contestlinktransfer(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_dofieldeffect(struct ScriptContext *ctx)
+bool8 ScrCmd_dofieldeffect(struct ScriptContext * ctx)
 {
     u16 effectId = VarGet(ScriptReadHalfword(ctx));
 
@@ -2049,7 +2047,7 @@ bool8 ScrCmd_dofieldeffect(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setfieldeffectarg(struct ScriptContext *ctx)
+bool8 ScrCmd_setfieldeffectarg(struct ScriptContext * ctx)
 {
     u8 argNum = ScriptReadByte(ctx);
 
@@ -2065,14 +2063,14 @@ static bool8 WaitForFieldEffectFinish(void)
         return FALSE;
 }
 
-bool8 ScrCmd_waitfieldeffect(struct ScriptContext *ctx)
+bool8 ScrCmd_waitfieldeffect(struct ScriptContext * ctx)
 {
     sFieldEffectScriptId = VarGet(ScriptReadHalfword(ctx));
     SetupNativeScript(ctx, WaitForFieldEffectFinish);
     return TRUE;
 }
 
-bool8 ScrCmd_setrespawn(struct ScriptContext *ctx)
+bool8 ScrCmd_setrespawn(struct ScriptContext * ctx)
 {
     u16 healLocationId = VarGet(ScriptReadHalfword(ctx));
 
@@ -2080,13 +2078,13 @@ bool8 ScrCmd_setrespawn(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkplayergender(struct ScriptContext *ctx)
+bool8 ScrCmd_checkplayergender(struct ScriptContext * ctx)
 {
     gSpecialVar_Result = gSaveBlock2Ptr->playerGender;
     return FALSE;
 }
 
-bool8 ScrCmd_playmoncry(struct ScriptContext *ctx)
+bool8 ScrCmd_playmoncry(struct ScriptContext * ctx)
 {
     u16 species = VarGet(ScriptReadHalfword(ctx));
     u16 mode = VarGet(ScriptReadHalfword(ctx));
@@ -2095,13 +2093,13 @@ bool8 ScrCmd_playmoncry(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_waitmoncry(struct ScriptContext *ctx)
+bool8 ScrCmd_waitmoncry(struct ScriptContext * ctx)
 {
     SetupNativeScript(ctx, IsCryFinished);
     return TRUE;
 }
 
-bool8 ScrCmd_setmetatile(struct ScriptContext *ctx)
+bool8 ScrCmd_setmetatile(struct ScriptContext * ctx)
 {
     u16 x = VarGet(ScriptReadHalfword(ctx));
     u16 y = VarGet(ScriptReadHalfword(ctx));
@@ -2113,11 +2111,11 @@ bool8 ScrCmd_setmetatile(struct ScriptContext *ctx)
     if (!v8)
         MapGridSetMetatileIdAt(x, y, tileId);
     else
-        MapGridSetMetatileIdAt(x, y, tileId | 0xC00);
+        MapGridSetMetatileIdAt(x, y, tileId | METATILE_COLLISION_MASK);
     return FALSE;
 }
 
-bool8 ScrCmd_opendoor(struct ScriptContext *ctx)
+bool8 ScrCmd_opendoor(struct ScriptContext * ctx)
 {
     u16 x = VarGet(ScriptReadHalfword(ctx));
     u16 y = VarGet(ScriptReadHalfword(ctx));
@@ -2129,7 +2127,7 @@ bool8 ScrCmd_opendoor(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_closedoor(struct ScriptContext *ctx)
+bool8 ScrCmd_closedoor(struct ScriptContext * ctx)
 {
     u16 x = VarGet(ScriptReadHalfword(ctx));
     u16 y = VarGet(ScriptReadHalfword(ctx));
@@ -2148,13 +2146,13 @@ static bool8 IsDoorAnimationStopped(void)
         return FALSE;
 }
 
-bool8 ScrCmd_waitdooranim(struct ScriptContext *ctx)
+bool8 ScrCmd_waitdooranim(struct ScriptContext * ctx)
 {
     SetupNativeScript(ctx, IsDoorAnimationStopped);
     return TRUE;
 }
 
-bool8 ScrCmd_setdooropen(struct ScriptContext *ctx)
+bool8 ScrCmd_setdooropen(struct ScriptContext * ctx)
 {
     u16 x = VarGet(ScriptReadHalfword(ctx));
     u16 y = VarGet(ScriptReadHalfword(ctx));
@@ -2165,7 +2163,7 @@ bool8 ScrCmd_setdooropen(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setdoorclosed(struct ScriptContext *ctx)
+bool8 ScrCmd_setdoorclosed(struct ScriptContext * ctx)
 {
     u16 x = VarGet(ScriptReadHalfword(ctx));
     u16 y = VarGet(ScriptReadHalfword(ctx));
@@ -2176,7 +2174,7 @@ bool8 ScrCmd_setdoorclosed(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_addelevmenuitem(struct ScriptContext *ctx)
+bool8 ScrCmd_addelevmenuitem(struct ScriptContext * ctx)
 {
 //    u8 v3 = ScriptReadByte(ctx);
 //    u16 v5 = VarGet(ScriptReadHalfword(ctx));
@@ -2187,7 +2185,7 @@ bool8 ScrCmd_addelevmenuitem(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_showelevmenu(struct ScriptContext *ctx)
+bool8 ScrCmd_showelevmenu(struct ScriptContext * ctx)
 {
     /*ScriptShowElevatorMenu();
     ScriptContext1_Stop();
@@ -2195,14 +2193,14 @@ bool8 ScrCmd_showelevmenu(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkcoins(struct ScriptContext *ctx)
+bool8 ScrCmd_checkcoins(struct ScriptContext * ctx)
 {
     u16 *ptr = GetVarPointer(ScriptReadHalfword(ctx));
     *ptr = GetCoins();
     return FALSE;
 }
 
-bool8 ScrCmd_addcoins(struct ScriptContext *ctx)
+bool8 ScrCmd_addcoins(struct ScriptContext * ctx)
 {
     u16 coins = VarGet(ScriptReadHalfword(ctx));
 
@@ -2213,7 +2211,7 @@ bool8 ScrCmd_addcoins(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_removecoins(struct ScriptContext *ctx)
+bool8 ScrCmd_removecoins(struct ScriptContext * ctx)
 {
     u16 coins = VarGet(ScriptReadHalfword(ctx));
 
@@ -2224,20 +2222,20 @@ bool8 ScrCmd_removecoins(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_signmsg(struct ScriptContext *ctx)
+bool8 ScrCmd_signmsg(struct ScriptContext * ctx)
 {
     sub_8069A20();
     return FALSE;
 }
 
-bool8 ScrCmd_normalmsg(struct ScriptContext *ctx)
+bool8 ScrCmd_normalmsg(struct ScriptContext * ctx)
 {
     sub_8069A2C();
     return FALSE;
 }
 
 // This command will force the Pokémon to be obedient, you don't get to make it disobedient.
-bool8 ScrCmd_setmonobedient(struct ScriptContext *ctx)
+bool8 ScrCmd_setmonobedient(struct ScriptContext * ctx)
 {
     bool8 obedient = TRUE;
     u16 partyIndex = VarGet(ScriptReadHalfword(ctx));
@@ -2246,7 +2244,7 @@ bool8 ScrCmd_setmonobedient(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_checkmonobedience(struct ScriptContext *ctx)
+bool8 ScrCmd_checkmonobedience(struct ScriptContext * ctx)
 {
     u16 partyIndex = VarGet(ScriptReadHalfword(ctx));
 
@@ -2254,7 +2252,7 @@ bool8 ScrCmd_checkmonobedience(struct ScriptContext *ctx)
     return FALSE;
 }
 
-bool8 ScrCmd_setmonmetlocation(struct ScriptContext *ctx)
+bool8 ScrCmd_setmonmetlocation(struct ScriptContext * ctx)
 {
     u16 partyIndex = VarGet(ScriptReadHalfword(ctx));
     u8 location = ScriptReadByte(ctx);
diff --git a/src/script.c b/src/script.c
index 0a4b69bac..4b8565589 100644
--- a/src/script.c
+++ b/src/script.c
@@ -406,7 +406,7 @@ u8 *mapheader_get_first_match_from_tagged_ptr_list(u8 tag)
     }
 }
 
-void mapheader_run_script_with_tag_x1(void)
+void RunOnLoadMapScript(void)
 {
     mapheader_run_script_by_tag(1);
 }
@@ -506,7 +506,7 @@ u8 *GetRamScript(u8 objectId, u8 *script)
     }
 }
 
-bool32 sub_8069DFC(void)
+bool32 ValidateRamScript(void)
 {
     struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
     if (scriptData->magic != RAM_SCRIPT_MAGIC)
diff --git a/src/script_menu.c b/src/script_menu.c
index 72ff1dc9e..a4745ee10 100644
--- a/src/script_menu.c
+++ b/src/script_menu.c
@@ -944,7 +944,7 @@ static void Hask_MultichoiceGridMenu_HandleInput(u8 taskId)
     EnableBothScriptContexts();
 }
 
-bool8 ScrSpecial_CreatePCMenu(void)
+bool8 CreatePCMenu(void)
 {
     if (FuncIsActiveTask(Task_MultichoiceMenu_HandleInput) == TRUE)
         return FALSE;
@@ -1022,7 +1022,7 @@ static void Task_ScriptShowMonPic(u8 taskId)
     case 1:
         break;
     case 2:
-        sub_8083A5C(&gSprites[task->data[2]], task->data[2]);
+        FreeResourcesAndDestroySprite(&gSprites[task->data[2]], task->data[2]);
         task->data[0]++;
         break;
     case 3:
@@ -1040,7 +1040,7 @@ bool8 ScriptMenu_ShowPokemonPic(u16 species, u8 x, u8 y)
         return TRUE;
     if (FindTaskIdByFunc(Task_ScriptShowMonPic) != 0xFF)
         return FALSE;
-    spriteId = sub_8083970(species, 8 * x + 40, 8 * y + 40, FALSE);
+    spriteId = CreateMonSprite_PicBox(species, 8 * x + 40, 8 * y + 40, FALSE);
     taskId = CreateTask(Task_ScriptShowMonPic, 80);
     gTasks[taskId].data[5] = CreateWindowFromRect(x, y, 8, 8);
     gTasks[taskId].data[0] = 0;
@@ -1082,7 +1082,7 @@ void sub_809D424(void)
         case 0:
         case 1:
         case 2:
-            sub_8083A5C(&gSprites[task->data[2]], task->data[2]);
+            FreeResourcesAndDestroySprite(&gSprites[task->data[2]], task->data[2]);
             DestroyScriptMenuWindow(task->data[5]);
             DestroyTask(taskId);
             break;
@@ -1116,7 +1116,7 @@ void Task_WaitMuseumFossilPic(u8 taskId)
     }
 }
 
-bool8 Special_OpenMuseumFossilPic(void)
+bool8 OpenMuseumFossilPic(void)
 {
     u8 spriteId;
     u8 taskId;
@@ -1149,7 +1149,7 @@ bool8 Special_OpenMuseumFossilPic(void)
     return TRUE;
 }
 
-bool8 Special_CloseMuseumFossilPic(void)
+bool8 CloseMuseumFossilPic(void)
 {
     u8 taskId = FindTaskIdByFunc(Task_WaitMuseumFossilPic);
     if (taskId == 0xFF)
@@ -1183,7 +1183,7 @@ void QLPlaybackCB_DestroyScriptMenuMonPicSprites(void)
     {
         data = gTasks[taskId].data;
         if (data[0] < 2)
-            sub_8083A5C(&gSprites[data[2]], data[2]);
+            FreeResourcesAndDestroySprite(&gSprites[data[2]], data[2]);
     }
     taskId = FindTaskIdByFunc(Task_WaitMuseumFossilPic);
     if (taskId != 0xFF)
@@ -1197,7 +1197,7 @@ void QLPlaybackCB_DestroyScriptMenuMonPicSprites(void)
     }
 }
 
-void Special_DrawSeagallopDestinationMenu(void)
+void DrawSeagallopDestinationMenu(void)
 {
     // 8004 = Starting location
     // 8005 = Page (0: Verm, One, Two, Three, Four, Other, Exit; 1: Four, Five, Six, Seven, Other, Exit)
@@ -1249,7 +1249,7 @@ void Special_DrawSeagallopDestinationMenu(void)
     }
 }
 
-u16 Special_GetSelectedSeagallopDestination(void)
+u16 GetSelectedSeagallopDestination(void)
 {
     // 8004 = Starting location
     // 8005 = Page (0: Verm, One, Two, Three, Four, Other, Exit; 1: Four, Five, Six, Seven, Other, Exit)
diff --git a/src/script_movement.c b/src/script_movement.c
new file mode 100644
index 000000000..55c26ded8
--- /dev/null
+++ b/src/script_movement.c
@@ -0,0 +1,226 @@
+#include "global.h"
+#include "task.h"
+#include "util.h"
+#include "event_object_movement.h"
+#include "constants/event_objects.h"
+#include "constants/event_object_movement.h"
+
+static EWRAM_DATA const u8 (*sMovementScripts[OBJECT_EVENTS_COUNT]) = {};
+
+static void ScriptMovement_StartMoveObjects(u8 priority);
+static u8 GetMoveObjectsTaskId(void);
+static u8 ScriptMovement_TryAddNewMovement(u8 taskId, u8 objEventId, const u8 *movementScript);
+static u8 GetMovementScriptIdFromObjectEventId(u8 taskId, u8 objEventId);
+static bool8 IsMovementScriptFinished(u8 taskId, u8 moveScrId);
+static void ScriptMovement_MoveObjects(u8 taskId);
+static void ScriptMovement_AddNewMovement(u8 taskId, u8 moveScrId, u8 objEventId, const u8 *movementScript);
+static void ScriptMovement_UnfreezeActiveObjects(u8 taskId);
+static void ScriptMovement_TakeStep(u8 taskId, u8 moveScrId, u8 objEventId, const u8 *movementScript);
+
+bool8 ScriptMovement_StartObjectMovementScript(u8 localId, u8 mapNum, u8 mapGroup, const u8 *movementScript)
+{
+    u8 objEventId;
+    if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objEventId))
+        return TRUE;
+
+    if (!FuncIsActiveTask(ScriptMovement_MoveObjects))
+        ScriptMovement_StartMoveObjects(50);
+    return ScriptMovement_TryAddNewMovement(GetMoveObjectsTaskId(), objEventId, movementScript);
+}
+
+bool8 ScriptMovement_IsObjectMovementFinished(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    u8 objEventId;
+    u8 taskId;
+    u8 moveScrId;
+    if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objEventId))
+        return TRUE;
+    taskId = GetMoveObjectsTaskId();
+    moveScrId = GetMovementScriptIdFromObjectEventId(taskId, objEventId);
+    if (moveScrId == OBJECT_EVENTS_COUNT)
+        return TRUE;
+    return IsMovementScriptFinished(taskId, moveScrId);
+}
+
+void ScriptMovement_UnfreezeObjectEvents(void)
+{
+    u8 taskId = GetMoveObjectsTaskId();
+    if (taskId != TAIL_SENTINEL)
+    {
+        ScriptMovement_UnfreezeActiveObjects(taskId);
+        DestroyTask(taskId);
+    }
+}
+
+void ScriptMovement_StartMoveObjects(u8 priority)
+{
+    u8 i;
+    u8 taskId = CreateTask(ScriptMovement_MoveObjects, priority);
+    for (i = 1; i < NUM_TASK_DATA; i++)
+    {
+        gTasks[taskId].data[i] = -1;
+    }
+}
+
+u8 GetMoveObjectsTaskId(void)
+{
+    return FindTaskIdByFunc(ScriptMovement_MoveObjects);
+}
+
+bool8 ScriptMovement_TryAddNewMovement(u8 taskId, u8 objEventId, const u8 *movementScript)
+{
+    u8 moveScrId;
+
+    moveScrId = GetMovementScriptIdFromObjectEventId(taskId, objEventId);
+    if (moveScrId != OBJECT_EVENTS_COUNT)
+    {
+        if (IsMovementScriptFinished(taskId, moveScrId) == FALSE)
+        {
+            return TRUE;
+        }
+        else
+        {
+            ScriptMovement_AddNewMovement(taskId, moveScrId, objEventId, movementScript);
+            return FALSE;
+        }
+    }
+    moveScrId = GetMovementScriptIdFromObjectEventId(taskId, OBJ_EVENT_ID_PLAYER);
+    if (moveScrId == OBJECT_EVENTS_COUNT)
+    {
+        return TRUE;
+    }
+    else
+    {
+        ScriptMovement_AddNewMovement(taskId, moveScrId, objEventId, movementScript);
+        return FALSE;
+    }
+}
+
+u8 GetMovementScriptIdFromObjectEventId(u8 taskId, u8 objEventId)
+{
+    u8 i;
+    u8 *moveScriptId = (u8 *)&gTasks[taskId].data[1];
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++, moveScriptId++)
+    {
+        if (*moveScriptId == objEventId)
+            return i;
+    }
+    return OBJECT_EVENTS_COUNT;
+}
+
+void LoadObjectEventIdPtrFromMovementScript(u8 taskId, u8 moveScrId, u8 **pObjEventId)
+{
+    u8 i;
+
+    *pObjEventId = (u8 *)&gTasks[taskId].data[1];
+    for (i = 0; i < moveScrId; i++, (*pObjEventId)++)
+        ;
+}
+
+void SetObjectEventIdAtMovementScript(u8 taskId, u8 moveScrId, u8 objEventId)
+{
+    u8 *ptr;
+
+    LoadObjectEventIdPtrFromMovementScript(taskId, moveScrId, &ptr);
+    *ptr = objEventId;
+}
+
+void LoadObjectEventIdFromMovementScript(u8 taskId, u8 moveScrId, u8 *objEventId)
+{
+    u8 *ptr;
+
+    LoadObjectEventIdPtrFromMovementScript(taskId, moveScrId, &ptr);
+    *objEventId = *ptr;
+}
+
+
+static void ClearMovementScriptFinished(u8 taskId, u8 moveScrId)
+{
+    u16 mask = ~gBitTable[moveScrId];
+
+    gTasks[taskId].data[0] &= mask;
+}
+
+static void SetMovementScriptFinished(u8 taskId, u8 moveScrId)
+{
+    gTasks[taskId].data[0] |= gBitTable[moveScrId];
+}
+
+static bool8 IsMovementScriptFinished(u8 taskId, u8 moveScrId)
+{
+    u16 moveScriptFinished = (u16)gTasks[taskId].data[0] & gBitTable[moveScrId];
+
+    if (moveScriptFinished != 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static void SetMovementScript(u8 moveScrId, const u8 *movementScript)
+{
+    sMovementScripts[moveScrId] = movementScript;
+}
+
+static const u8 *GetMovementScript(u8 moveScrId)
+{
+    return sMovementScripts[moveScrId];
+}
+
+static void ScriptMovement_AddNewMovement(u8 taskId, u8 moveScrId, u8 objEventId, const u8 *movementScript)
+{
+    ClearMovementScriptFinished(taskId, moveScrId);
+    SetMovementScript(moveScrId, movementScript);
+    SetObjectEventIdAtMovementScript(taskId, moveScrId, objEventId);
+}
+
+static void ScriptMovement_UnfreezeActiveObjects(u8 taskId)
+{
+    u8 *pObjEventId;
+    u8 i;
+
+    pObjEventId = (u8 *)&gTasks[taskId].data[1];
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++, pObjEventId++)
+    {
+        if (*pObjEventId != 0xFF)
+            UnfreezeObjectEvent(&gObjectEvents[*pObjEventId]);
+    }
+}
+
+static void ScriptMovement_MoveObjects(u8 taskId)
+{
+    u8 i;
+    u8 objEventId;
+
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        LoadObjectEventIdFromMovementScript(taskId, i, &objEventId);
+        if (objEventId != 0xFF)
+            ScriptMovement_TakeStep(taskId, i, objEventId, GetMovementScript(i));
+    }
+}
+
+static void ScriptMovement_TakeStep(u8 taskId, u8 moveScrId, u8 objEventId, const u8 *movementScript)
+{
+    u8 nextMoveActionId;
+
+    if (IsMovementScriptFinished(taskId, moveScrId) == TRUE)
+        return;
+    if (ObjectEventIsHeldMovementActive(&gObjectEvents[objEventId])
+        && !ObjectEventClearHeldMovementIfFinished(&gObjectEvents[objEventId]))
+        return;
+
+    nextMoveActionId = *movementScript;
+    if (nextMoveActionId == MOVEMENT_ACTION_STEP_END)
+    {
+        SetMovementScriptFinished(taskId, moveScrId);
+        FreezeObjectEvent(&gObjectEvents[objEventId]);
+    }
+    else
+    {
+        if (!ObjectEventSetHeldMovement(&gObjectEvents[objEventId], nextMoveActionId))
+        {
+            movementScript++;
+            SetMovementScript(moveScrId, movementScript);
+        }
+    }
+}
diff --git a/src/script_pokemon_util.c b/src/script_pokemon_util.c
index e12b809c6..677759497 100644
--- a/src/script_pokemon_util.c
+++ b/src/script_pokemon_util.c
@@ -1,9 +1,7 @@
 #include "global.h"
-#include "battle.h"
 #include "berry.h"
 #include "daycare.h"
 #include "event_data.h"
-#include "event_object_movement.h"
 #include "load_save.h"
 #include "malloc.h"
 #include "overworld.h"
@@ -119,7 +117,7 @@ static bool8 CheckPartyMonHasHeldItem(u16 item)
     return FALSE;
 }
 
-bool8 GetNameOfEnigmaBerryInPlayerParty(void)
+bool8 DoesPartyHaveEnigmaBerry(void)
 {
     bool8 hasItem = CheckPartyMonHasHeldItem(ITEM_ENIGMA_BERRY);
     if (hasItem == TRUE)
diff --git a/src/sea_cottage_special_anim.c b/src/sea_cottage_special_anim.c
deleted file mode 100644
index 56d01ca29..000000000
--- a/src/sea_cottage_special_anim.c
+++ /dev/null
@@ -1,264 +0,0 @@
-#include "global.h"
-#include "event_data.h"
-#include "task.h"
-#include "menu.h"
-#include "field_player_avatar.h"
-#include "fieldmap.h"
-#include "event_object_movement.h"
-#include "field_camera.h"
-
-static EWRAM_DATA u8 gUnknown_2039984 = 0;
-
-static void sub_809C1D8(u8 taskId, const s16 *a1, u16 a2);
-static void sub_809C334(u8 taskId);
-static void sub_809C500(u8 taskId);
-static void sub_809C640(u8 taskId);
-
-static const u16 gUnknown_83DF0D4[] = {0x0308, 0x030a, 0x02d0};
-static const u16 gUnknown_83DF0DA[] = {0x0309, 0x030b, 0x02d1};
-static const u16 gUnknown_83DF0E0[] = {0x0310, 0x0312, 0x02d8};
-static const u16 gUnknown_83DF0E6[] = {0x0311, 0x0313, 0x02d9};
-static const u16 gUnknown_83DF0EC[] = {0x02e3, 0x0316, 0x0314};
-static const u16 gUnknown_83DF0F2[] = {0x02e4, 0x0317, 0x0315};
-static const u16 gUnknown_83DF0F8[] = {0x02eb, 0x031e, 0x031c};
-
-// Functions
-static void sub_809C1D8(u8 taskId, const s16 *a1, u16 a2)
-{
-    s16 r5, r3, r4;
-    s16 i, j;
-    
-    r5 = gTasks[taskId].data[4] - 1;
-    r3 = gTasks[taskId].data[5] - 1;
-    r4 = gTasks[taskId].data[1];
-    
-    if (gTasks[taskId].data[2] == 0)
-    {
-        for (i = 0; i < 3; i++)
-        {
-            for (j = 0; j < 3; j++)
-            {
-                s32 id = MapGridGetMetatileIdAt(r5 + j, r3 + i);
-                
-                if (a1[r4] == (s16)id)
-                {
-                    if (r4 != 2)
-                        MapGridSetMetatileIdAt(r5 + j, r3 + i, a2 | a1[r4 + 1]);
-                    else
-                        MapGridSetMetatileIdAt(r5 + j, r3 + i, a2 | a1[0]);
-                }
-            }
-        }
-    }
-    else
-    {
-        for (i = 0; i < 3; i++)
-        {
-            for (j = 0; j < 3; j++)
-            {
-                s32 id = MapGridGetMetatileIdAt(r5 + j, r3 + i);
-
-                if (a1[2 - r4] == (s16)id)
-                {
-                    if (r4 != 2)
-                        MapGridSetMetatileIdAt(r5 + j, r3 + i, a2 | a1[1 - r4]);
-                    else
-                        MapGridSetMetatileIdAt(r5 + j, r3 + i, a2 | a1[2]);
-                }
-            }
-        }
-    }
-}
-
-static void sub_809C334(u8 taskId)
-{
-    s16 *data = gTasks[taskId].data;
-    u16 v1;
-    
-    data[3] = 1;
-    switch (data[0])
-    {
-    case 0:
-        sub_809C1D8(taskId, gUnknown_83DF0D4, 0);
-        break;
-    case 1:
-        sub_809C1D8(taskId, gUnknown_83DF0DA, 0);
-        break;
-    case 2:
-        sub_809C1D8(taskId, gUnknown_83DF0E0, 0xC00);
-        break;
-    case 3:
-        sub_809C1D8(taskId, gUnknown_83DF0E6, 0);
-        break;
-    case 4:
-        sub_809C1D8(taskId, gUnknown_83DF0EC, 0xC00);
-        break;
-    case 5:
-        sub_809C1D8(taskId, gUnknown_83DF0F2, 0);
-        break;
-    case 6:
-        sub_809C1D8(taskId, gUnknown_83DF0F8, 0);
-    default:
-        break;
-    }
-    
-    data[0] = (data[0] + 1) & 7;
-    v1 = data[0] & 7;
-    if (v1 == 0)
-    {
-        DrawWholeMapView();
-        data[1] = (data[1] + 1) % 3;
-        data[3] = v1;
-    }
-}
-
-static u8 sub_809C3FC(u16 a0)
-{
-    u8 taskId;
-    s16 *data;
-
-    taskId = CreateTask(sub_809C334, 0);
-    data = gTasks[taskId].data;
-    PlayerGetDestCoords(&data[4], &data[5]);
-    data[0] = 0;
-    data[1] = 0;
-    data[2] = a0;
-    sub_809C334(taskId);
-    return taskId;
-}
-
-void sub_809C448(u8 a0)
-{
-    u8 taskId;
-    
-    taskId = sub_809C3FC(a0);
-    gUnknown_2039984 = taskId;
-}
-
-void sub_809C460(void)
-{
-    DestroyTask(gUnknown_2039984);
-}
-
-bool8 sub_809C474(void)
-{    
-    if (gTasks[gUnknown_2039984].data[3] == 0)
-    {
-        if (gTasks[gUnknown_2039984].data[1] != 2)
-            return TRUE;
-        return FALSE;
-    }
-    else
-    {
-        return TRUE;
-    }
-}
-
-// special 0x1b5 - creates a tile animaiton one block left two-four up the player
-void sub_809C4A8(void)
-{
-    u8 taskId;
-    s16 *data;
-    
-    taskId = CreateTask(sub_809C500, 0);
-    gTasks[taskId].data[0] = 0;
-    gTasks[taskId].data[1] = 0;
-    data = gTasks[taskId].data;
-    PlayerGetDestCoords(&data[2], &data[3]);
-    if (gSpecialVar_0x8004 == 0)
-    {
-        gTasks[taskId].data[2] += 6;
-        gTasks[taskId].data[3] -= 5;
-    }
-    else
-    {
-        gTasks[taskId].data[2]--;
-        gTasks[taskId].data[3] -= 5;
-    }    
-}
-
-static void sub_809C500(u8 taskId)
-{
-    s16 *data = gTasks[taskId].data;
-    
-    if (data[0] == 0)
-    {
-        if ((data[1] & 1) == 0)
-        {
-            MapGridSetMetatileIdAt(data[2], data[3], 0xEB5);
-            MapGridSetMetatileIdAt(data[2], data[3] + 2, 0xEB7);
-        }
-        else
-        {
-            MapGridSetMetatileIdAt(data[2], data[3], 0xEB6);
-            MapGridSetMetatileIdAt(data[2], data[3] + 2, 0xEB8);
-        }
-        CurrentMapDrawMetatileAt(data[2], data[3]);
-        CurrentMapDrawMetatileAt(data[2], data[3] + 2);
-    }
-    
-    data[0]++;
-    if (data[0] != 0x10)
-        return;
-    
-    data[0] = 0;
-    data[1]++;
-    if (data[1] != 0xD)
-        return;
-    
-    MapGridSetMetatileIdAt(data[2], data[3], 0xE8A);
-    MapGridSetMetatileIdAt(data[2], data[3] + 2, 0xE96);
-    CurrentMapDrawMetatileAt(data[2], data[3]);
-    CurrentMapDrawMetatileAt(data[2], data[3] + 2);
-    DestroyTask(taskId);
-}
-
-// special 0x1B7 - creates a tile animation two-six blocks right from the top-left corner of the screen
-void sub_809C5FC(void)
-{
-    u8 taskId;
-    s16 *data;
-    
-    taskId = CreateTask(sub_809C640, 0);
-    gTasks[taskId].data[0] = 0;
-    gTasks[taskId].data[1] = 0;
-    data = gTasks[taskId].data;
-    PlayerGetDestCoords(&data[2], &data[3]);
-    gTasks[taskId].data[2] += 4;
-    gTasks[taskId].data[3] -= 5;
-}
-
-static void sub_809C640(u8 taskId)
-{
-    s16 *data = gTasks[taskId].data;
-    
-    if (data[0] == 0)
-    {
-        if (data[1] != 0)
-        {
-            MapGridSetMetatileIdAt(data[2], data[3], 0xE85);
-            MapGridSetMetatileIdAt(data[2], data[3] + 1, 0xEB4);
-            CurrentMapDrawMetatileAt(data[2], data[3]);
-            CurrentMapDrawMetatileAt(data[2], data[3] + 1);
-            if (data[1] == 4)
-            {
-                DestroyTask(taskId);
-                return;
-            }
-            
-            data[2]--;
-        }
-        MapGridSetMetatileIdAt(data[2], data[3], 0xEB9);
-        MapGridSetMetatileIdAt(data[2], data[3] + 1, 0xEBA);
-        CurrentMapDrawMetatileAt(data[2], data[3]);
-        CurrentMapDrawMetatileAt(data[2], data[3] + 1);
-    }
-    
-    data[0]++;
-    if (data[0] == 4)
-    {
-        data[0] = 0;
-        data[1]++;
-    }
-}
-
diff --git a/src/seagallop.c b/src/seagallop.c
index aa0c48da1..1e2234b9c 100644
--- a/src/seagallop.c
+++ b/src/seagallop.c
@@ -16,7 +16,7 @@
 #include "field_weather.h"
 #include "constants/songs.h"
 #include "constants/maps.h"
-#include "seagallop.h"
+#include "constants/seagallop.h"
 
 #define TILESTAG_FERRY 3000
 #define TILESTAG_WAKE  4000
@@ -295,7 +295,7 @@ static void Task_Seagallop_1(u8 taskId)
     if (++task->data[1] == 140)
     {
         Overworld_FadeOutMapMusic();
-        sub_807DC18();
+        WarpFadeOutScreen();
         task->func = Task_Seagallop_2;
     }
 }
diff --git a/src/shop.c b/src/shop.c
index 97061f8c0..ddeaf6a68 100644
--- a/src/shop.c
+++ b/src/shop.c
@@ -10,7 +10,6 @@
 #include "window.h"
 #include "field_specials.h"
 #include "field_weather.h"
-#include "field_camera.h"
 #include "task.h"
 #include "text.h"
 #include "item.h"
@@ -19,7 +18,6 @@
 #include "sound.h"
 #include "string_util.h"
 #include "overworld.h"
-#include "window.h"
 #include "palette.h"
 #include "field_fadetransition.h"
 #include "scanline_effect.h"
@@ -38,6 +36,7 @@
 #include "constants/songs.h"
 #include "constants/items.h"
 #include "constants/game_stat.h"
+#include "constants/field_weather.h"
 
 #define tItemCount data[1]
 #define tItemId data[5]
@@ -294,14 +293,14 @@ static void Task_ShopMenu(u8 taskId)
 static void Task_HandleShopMenuBuy(u8 taskId)
 {
     SetWordTaskArg(taskId, 0xE, (u32)CB2_InitBuyMenu);
-    FadeScreen(1, 0);
+    FadeScreen(FADE_TO_BLACK, 0);
     gTasks[taskId].func = Task_GoToBuyOrSellMenu;
 }
 
 static void Task_HandleShopMenuSell(u8 taskId)
 {
     SetWordTaskArg(taskId, 0xE, (u32)CB2_GoToSellMenu);
-    FadeScreen(1, 0);
+    FadeScreen(FADE_TO_BLACK, 0);
     gTasks[taskId].func = Task_GoToBuyOrSellMenu;    
 }
 
@@ -338,7 +337,7 @@ static void Task_GoToBuyOrSellMenu(u8 taskId)
 
 static void MapPostLoadHook_ReturnToShopMenu(void)
 {
-    sub_807DC00();
+    FadeInFromBlack();
     CreateTask(Task_ReturnToShopMenu, 8);
 }
 
@@ -670,7 +669,7 @@ static void BuyMenuPrintCursorAtYPosition(u8 y, u8 a1)
     }
     else
     {
-        BuyMenuPrint(4, 2, gFameCheckerText_ListMenuCursor, 1, y, 0, 0, 0, a1);
+        BuyMenuPrint(4, 2, gText_SelectorArrow2, 1, y, 0, 0, 0, a1);
     }
 }
 
diff --git a/src/slot_machine.c b/src/slot_machine.c
index 651465ddb..d0422ab99 100644
--- a/src/slot_machine.c
+++ b/src/slot_machine.c
@@ -11,7 +11,6 @@
 #include "coins.h"
 #include "quest_log.h"
 #include "overworld.h"
-#include "slot_machine.h"
 #include "menu.h"
 #include "new_menu_helpers.h"
 #include "text_window.h"
diff --git a/src/sound.c b/src/sound.c
index ebd755838..99e9a162e 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -5,8 +5,8 @@
 #include "quest_log.h"
 #include "m4a.h"
 #include "main.h"
-#include "pokemon.h"
 #include "constants/songs.h"
+#include "constants/fanfares.h"
 #include "task.h"
 
 struct Fanfare
@@ -42,20 +42,20 @@ extern struct ToneData gCryTable[];
 extern struct ToneData gCryTable2[];
 
 static const struct Fanfare sFanfares[] = {
-    { MUS_FANFA1,      80 },
-    { MUS_FANFA4,     160 },
-    { MUS_FANFA5,     220 },
-    { MUS_ME_WAZA,    220 },
-    { MUS_ME_ASA,     160 },
-    { MUS_ME_BACHI,   340 },
-    { MUS_ME_WASURE,  180 },
-    { MUS_ME_KINOMI,  120 },
-    { MUS_ME_B_BIG,   250 },
-    { MUS_ME_B_SMALL, 150 },
-    { MUS_ME_ZANNEN,  160 },
-    { MUS_POKEFUE,    450 },
-    { MUS_FAN5,       170 },
-    { MUS_FAN2,       196 }
+    [FANFARE_00]        = { MUS_FANFA1,      80 },
+    [FANFARE_01]        = { MUS_FANFA4,     160 },
+    [FANFARE_02]        = { MUS_FANFA5,     220 },
+    [FANFARE_03]        = { MUS_ME_WAZA,    220 },
+    [FANFARE_04]        = { MUS_ME_ASA,     160 },
+    [FANFARE_05]        = { MUS_ME_BACHI,   340 },
+    [FANFARE_06]        = { MUS_ME_WASURE,  180 },
+    [FANFARE_07]        = { MUS_ME_KINOMI,  120 },
+    [FANFARE_08]        = { MUS_ME_B_BIG,   250 },
+    [FANFARE_09]        = { MUS_ME_B_SMALL, 150 },
+    [FANFARE_10]        = { MUS_ME_ZANNEN,  160 },
+    [FANFARE_POKEFLUTE] = { MUS_POKEFUE,    450 },
+    [FANFARE_KEY_ITEM]  = { MUS_FAN5,       170 },
+    [FANFARE_DEX_EVAL]  = { MUS_FAN2,       196 }
 };
 
 extern u16 SpeciesToCryId(u16);
diff --git a/src/special_field_anim.c b/src/special_field_anim.c
new file mode 100644
index 000000000..4193f0b5a
--- /dev/null
+++ b/src/special_field_anim.c
@@ -0,0 +1,341 @@
+#include "global.h"
+#include "event_data.h"
+#include "task.h"
+#include "field_player_avatar.h"
+#include "fieldmap.h"
+#include "field_camera.h"
+#include "constants/metatile_labels.h"
+
+static EWRAM_DATA u8 sEscalatorTaskId = 0;
+
+static void SetEscalatorMetatile(u8 taskId, const s16 *metatileIds, u16 metatileMasks);
+static void Task_DrawEscalator(u8 taskId);
+static void Task_DrawTeleporterHousing(u8 taskId);
+static void Task_DrawTeleporterCable(u8 taskId);
+
+#define ESCALATOR_STAGES     3
+#define LAST_ESCALATOR_STAGE (ESCALATOR_STAGES - 1)
+
+static const u16 sEscalatorMetatiles_BottomNextRail[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_BottomNextRail_Transition2, 
+    METATILE_PokemonCenter_Escalator_BottomNextRail_Transition1, 
+    METATILE_PokemonCenter_Escalator_BottomNextRail_Normal
+};
+
+static const u16 sEscalatorMetatiles_BottomRail[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_BottomRail_Transition2, 
+    METATILE_PokemonCenter_Escalator_BottomRail_Transition1, 
+    METATILE_PokemonCenter_Escalator_BottomRail_Normal
+};
+
+static const u16 sEscalatorMetatiles_BottomNext[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_BottomNext_Transition2, 
+    METATILE_PokemonCenter_Escalator_BottomNext_Transition1, 
+    METATILE_PokemonCenter_Escalator_BottomNext_Normal
+};
+
+static const u16 sEscalatorMetatiles_Bottom[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_Bottom_Transition2, 
+    METATILE_PokemonCenter_Escalator_Bottom_Transition1, 
+    METATILE_PokemonCenter_Escalator_Bottom_Normal
+};
+
+static const u16 sEscalatorMetatiles_TopNext[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_TopNext_Normal, 
+    METATILE_PokemonCenter_Escalator_TopNext_Transition1, 
+    METATILE_PokemonCenter_Escalator_TopNext_Transition2
+};
+
+static const u16 sEscalatorMetatiles_Top[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_Top_Normal, 
+    METATILE_PokemonCenter_Escalator_Top_Transition1, 
+    METATILE_PokemonCenter_Escalator_Top_Transition2
+};
+
+static const u16 sEscalatorMetatiles_TopNextRail[ESCALATOR_STAGES] = 
+{
+    METATILE_PokemonCenter_Escalator_TopNextRail_Normal, 
+    METATILE_PokemonCenter_Escalator_TopNextRail_Transition1, 
+    METATILE_PokemonCenter_Escalator_TopNextRail_Transition2
+};
+
+#define tState            data[0]
+#define tTransitionStage  data[1]
+#define tGoingUp          data[2]
+#define tDrawingEscalator data[3]
+#define tPlayerX          data[4]
+#define tPlayerY          data[5]
+
+static void SetEscalatorMetatile(u8 taskId, const s16 *metatileIds, u16 metatileMasks)
+{
+    s16 x, y, transitionStage;
+    s16 i, j;
+    
+    x = gTasks[taskId].tPlayerX - 1;
+    y = gTasks[taskId].tPlayerY - 1;
+    transitionStage = gTasks[taskId].tTransitionStage;
+    
+    // Check all the escalator sections and only progress the selected one to the next stage
+    if (!gTasks[taskId].tGoingUp)
+    {
+        for (i = 0; i < 3; i++)
+        {
+            for (j = 0; j < 3; j++)
+            {
+                s32 id = MapGridGetMetatileIdAt(x + j, y + i);
+                
+                if (metatileIds[transitionStage] == (s16)id)
+                {
+                    if (transitionStage != LAST_ESCALATOR_STAGE)
+                        MapGridSetMetatileIdAt(x + j, y + i, metatileMasks | metatileIds[transitionStage + 1]);
+                    else
+                        MapGridSetMetatileIdAt(x + j, y + i, metatileMasks | metatileIds[0]);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < 3; i++)
+        {
+            for (j = 0; j < 3; j++)
+            {
+                s32 id = MapGridGetMetatileIdAt(x + j, y + i);
+
+                if (metatileIds[LAST_ESCALATOR_STAGE - transitionStage] == (s16)id)
+                {
+                    if (transitionStage != LAST_ESCALATOR_STAGE)
+                        MapGridSetMetatileIdAt(x + j, y + i, metatileMasks | metatileIds[1 - transitionStage]);
+                    else
+                        MapGridSetMetatileIdAt(x + j, y + i, metatileMasks | metatileIds[LAST_ESCALATOR_STAGE]);
+                }
+            }
+        }
+    }
+}
+
+static void Task_DrawEscalator(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    u16 state;
+    
+    tDrawingEscalator = TRUE;
+
+    // Set tile for each section of the escalator in sequence for current transition stage
+    switch (tState)
+    {
+    case 0:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_BottomNextRail, 0);
+        break;
+    case 1:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_BottomRail, 0);
+        break;
+    case 2:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_BottomNext, METATILE_COLLISION_MASK);
+        break;
+    case 3:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_Bottom, 0);
+        break;
+    case 4:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_TopNext, METATILE_COLLISION_MASK);
+        break;
+    case 5:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_Top, 0);
+        break;
+    case 6:
+        SetEscalatorMetatile(taskId, sEscalatorMetatiles_TopNextRail, 0);
+    default:
+        break;
+    }
+    
+    tState = (tState + 1) & 7;
+    state = tState & 7;
+
+    // If all sections of the escalator have been set, draw map and progress to next stage
+    if (state == 0)
+    {
+        DrawWholeMapView();
+        tTransitionStage = (tTransitionStage + 1) % ESCALATOR_STAGES;
+        tDrawingEscalator = FALSE;
+    }
+}
+
+static u8 CreateEscalatorTask(bool16 goingUp)
+{
+    u8 taskId;
+    s16 *data;
+
+    taskId = CreateTask(Task_DrawEscalator, 0);
+    data = gTasks[taskId].data;
+    PlayerGetDestCoords(&tPlayerX, &tPlayerY);
+    tState = 0;
+    tTransitionStage = 0;
+    tGoingUp = goingUp;
+    Task_DrawEscalator(taskId);
+    return taskId;
+}
+
+void StartEscalator(bool8 goingUp)
+{
+    u8 taskId;
+    
+    taskId = CreateEscalatorTask(goingUp);
+    sEscalatorTaskId = taskId;
+}
+
+void StopEscalator(void)
+{
+    DestroyTask(sEscalatorTaskId);
+}
+
+bool8 IsEscalatorMoving(void)
+{    
+    if (gTasks[sEscalatorTaskId].tDrawingEscalator == FALSE)
+    {
+        if (gTasks[sEscalatorTaskId].tTransitionStage != LAST_ESCALATOR_STAGE)
+            return TRUE;
+        return FALSE;
+    }
+    else
+    {
+        return TRUE;
+    }
+}
+
+#undef tState
+#undef tTransitionStage
+#undef tGoingUp
+#undef tDrawingEscalator
+#undef tPlayerX
+#undef tPlayerY
+
+#define tTimer data[0]
+#define tState data[1]
+#define tX     data[2]
+#define tY     data[3]
+
+void AnimateTeleporterHousing(void)
+{
+    u8 taskId;
+    s16 *data;
+    
+    taskId = CreateTask(Task_DrawTeleporterHousing, 0);
+    gTasks[taskId].tTimer = 0;
+    gTasks[taskId].tState = 0;
+    data = gTasks[taskId].data;
+    PlayerGetDestCoords(&tX, &tY);
+
+    // Set the coords of whichever teleporter is being animated
+    // 0 for the right teleporter, 1 for the left teleporter
+    if (gSpecialVar_0x8004 == 0)
+    {
+        gTasks[taskId].tX += 6;
+        gTasks[taskId].tY -= 5;
+    }
+    else
+    {
+        gTasks[taskId].tX -= 1;
+        gTasks[taskId].tY -= 5;
+    }    
+}
+
+static void Task_DrawTeleporterHousing(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    
+    if (tTimer == 0)
+    {
+        // Alternate the teleporter light / brightness of the teleporter door
+        if ((tState & 1) == 0)
+        {
+            MapGridSetMetatileIdAt(tX, tY, METATILE_SeaCottage_Teleporter_Light_Yellow | METATILE_COLLISION_MASK);
+            MapGridSetMetatileIdAt(tX, tY + 2, METATILE_SeaCottage_Teleporter_Door_HalfGlowing | METATILE_COLLISION_MASK);
+        }
+        else
+        {
+            MapGridSetMetatileIdAt(tX, tY, METATILE_SeaCottage_Teleporter_Light_Red | METATILE_COLLISION_MASK);
+            MapGridSetMetatileIdAt(tX, tY + 2, METATILE_SeaCottage_Teleporter_Door_FullGlowing | METATILE_COLLISION_MASK);
+        }
+        CurrentMapDrawMetatileAt(tX, tY);
+        CurrentMapDrawMetatileAt(tX, tY + 2);
+    }
+    
+    tTimer++;
+    if (tTimer != 16)
+        return;
+    
+    tTimer = 0;
+    tState++;
+    if (tState != 13)
+        return;
+    
+    MapGridSetMetatileIdAt(tX, tY, METATILE_SeaCottage_Teleporter_Light_Green | METATILE_COLLISION_MASK);
+    MapGridSetMetatileIdAt(tX, tY + 2, METATILE_SeaCottage_Teleporter_Door | METATILE_COLLISION_MASK);
+    CurrentMapDrawMetatileAt(tX, tY);
+    CurrentMapDrawMetatileAt(tX, tY + 2);
+    DestroyTask(taskId);
+}
+
+void AnimateTeleporterCable(void)
+{
+    u8 taskId;
+    s16 *data;
+    
+    taskId = CreateTask(Task_DrawTeleporterCable, 0);
+    gTasks[taskId].tTimer = 0;
+    gTasks[taskId].tState = 0;
+    data = gTasks[taskId].data;
+    PlayerGetDestCoords(&tX, &tY);
+    gTasks[taskId].tX += 4;
+    gTasks[taskId].tY -= 5;
+}
+
+static void Task_DrawTeleporterCable(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    
+    if (tTimer == 0)
+    {
+        if (tState != 0)
+        {
+            // Set default cable tiles to clear the ball
+            MapGridSetMetatileIdAt(tX, tY, METATILE_SeaCottage_Teleporter_Cable_Top | METATILE_COLLISION_MASK);
+            MapGridSetMetatileIdAt(tX, tY + 1, METATILE_SeaCottage_Teleporter_Cable_Bottom | METATILE_COLLISION_MASK);
+            CurrentMapDrawMetatileAt(tX, tY);
+            CurrentMapDrawMetatileAt(tX, tY + 1);
+
+            // End after drawing 4 times (length of the cable)
+            if (tState == 4)
+            {
+                DestroyTask(taskId);
+                return;
+            }
+            
+            tX--;
+        }
+
+        // Draw the cable ball
+        MapGridSetMetatileIdAt(tX, tY, METATILE_SeaCottage_Teleporter_CableBall_Top | METATILE_COLLISION_MASK);
+        MapGridSetMetatileIdAt(tX, tY + 1, METATILE_SeaCottage_Teleporter_CableBall_Bottom | METATILE_COLLISION_MASK);
+        CurrentMapDrawMetatileAt(tX, tY);
+        CurrentMapDrawMetatileAt(tX, tY + 1);
+    }
+    
+    tTimer++;
+    if (tTimer == 4)
+    {
+        tTimer = 0;
+        tState++;
+    }
+}
+
+#undef tTimer
+#undef tState
+#undef tX
+#undef tY
diff --git a/src/sprite.c b/src/sprite.c
index c1fc89777..fd824494b 100644
--- a/src/sprite.c
+++ b/src/sprite.c
@@ -94,17 +94,17 @@ typedef void (*AffineAnimCmdFunc)(u8 matrixNum, struct Sprite *);
 #define DUMMY_OAM_DATA        \
 {                             \
     160, /* Y (off-screen) */ \
-    0,                        \
-    0,                        \
-    0,                        \
-    0,                        \
-    0,                        \
+    ST_OAM_AFFINE_OFF,        \
+    ST_OAM_OBJ_NORMAL,        \
+    FALSE,                    \
+    ST_OAM_4BPP,              \
+    ST_OAM_SQUARE,            \
     304, /* X */              \
     0,                        \
-    0,                        \
-    0,                        \
+    ST_OAM_SIZE_0,            \
+    0x000,                    \
     3, /* lowest priority */  \
-    0,                        \
+    0x0,                      \
     0                         \
 }
 
@@ -250,47 +250,47 @@ static const AffineAnimCmdFunc sAffineAnimCmdFuncs[] =
     AffineAnimCmd_frame,
 };
 
-static const s32 sUnknown_082EC6F4[3][4][2] =
+static const s32 sOamDimensionsCopy[3][4][2] =
 {
-    {
-        {8, 8},
-        {0x10, 0x10},
-        {0x20, 0x20},
-        {0x40, 0x40},
+    [ST_OAM_SQUARE] = {
+        [ST_OAM_SIZE_0] = { 8,  8}, // SPRITE_SIZE_8x8
+        [ST_OAM_SIZE_1] = {16, 16}, // SPRITE_SIZE_16x16
+        [ST_OAM_SIZE_2] = {32, 32}, // SPRITE_SIZE_32x32
+        [ST_OAM_SIZE_3] = {64, 64}, // SPRITE_SIZE_64x64
     },
-    {
-        {0x10, 8},
-        {0x20, 8},
-        {0x20, 0x10},
-        {0x40, 0x20},
+    [ST_OAM_H_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = {16,  8}, // SPRITE_SIZE_16x8
+        [ST_OAM_SIZE_1] = {32,  8}, // SPRITE_SIZE_32x8
+        [ST_OAM_SIZE_2] = {32, 16}, // SPRITE_SIZE_32x16
+        [ST_OAM_SIZE_3] = {64, 32}, // SPRITE_SIZE_64x32
     },
-    {
-        {8, 0x10},
-        {8, 0x20},
-        {0x10, 0x20},
-        {0x20, 0x40},
+    [ST_OAM_V_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = { 8, 16}, // SPRITE_SIZE_8x16
+        [ST_OAM_SIZE_1] = { 8, 32}, // SPRITE_SIZE_8x32
+        [ST_OAM_SIZE_2] = {16, 32}, // SPRITE_SIZE_16x32
+        [ST_OAM_SIZE_3] = {32, 64}, // SPRITE_SIZE_32x64
     },
 };
 
 static const struct OamDimensions sOamDimensions[3][4] =
 {
-    {   // square
-        {  8,  8 },
-        { 16, 16 },
-        { 32, 32 },
-        { 64, 64 },
+    [ST_OAM_SQUARE] = {
+        [ST_OAM_SIZE_0] = { 8,  8}, // SPRITE_SIZE_8x8
+        [ST_OAM_SIZE_1] = {16, 16}, // SPRITE_SIZE_16x16
+        [ST_OAM_SIZE_2] = {32, 32}, // SPRITE_SIZE_32x32
+        [ST_OAM_SIZE_3] = {64, 64}, // SPRITE_SIZE_64x64
     },
-    {   // horizontal rectangle
-        { 16,  8 },
-        { 32,  8 },
-        { 32, 16 },
-        { 64, 32 },
+    [ST_OAM_H_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = {16,  8}, // SPRITE_SIZE_16x8
+        [ST_OAM_SIZE_1] = {32,  8}, // SPRITE_SIZE_32x8
+        [ST_OAM_SIZE_2] = {32, 16}, // SPRITE_SIZE_32x16
+        [ST_OAM_SIZE_3] = {64, 32}, // SPRITE_SIZE_64x32
     },
-    {   // vertical rectangle
-        {  8, 16 },
-        {  8, 32 },
-        { 16, 32 },
-        { 32, 64 },
+    [ST_OAM_V_RECTANGLE] = {
+        [ST_OAM_SIZE_0] = { 8, 16}, // SPRITE_SIZE_8x16
+        [ST_OAM_SIZE_1] = { 8, 32}, // SPRITE_SIZE_8x32
+        [ST_OAM_SIZE_2] = {16, 32}, // SPRITE_SIZE_16x32
+        [ST_OAM_SIZE_3] = {32, 64}, // SPRITE_SIZE_32x64
     },
 };
 
@@ -1222,43 +1222,43 @@ u8 GetSpriteMatrixNum(struct Sprite *sprite)
     return matrixNum;
 }
 
-void sub_8007FFC(struct Sprite* sprite, s16 a2, s16 a3)
+void obj_pos2_update_enable(struct Sprite* sprite, s16 xmod, s16 ymod)
 {
-    sprite->data[6] = a2;
-    sprite->data[7] = a3;
+    sprite->data[6] = xmod;
+    sprite->data[7] = ymod;
     sprite->flags_f = 1;
 }
 
-s32 sub_800800C(s32 a0, s32 a1, s32 a2)
+static s32 affine_get_new_pos2(s32 baseDim, s32 xformed, s32 modifier)
 {
-    s32 subResult, var1;
+    s32 subResult, shiftResult;
 
-    subResult = a1 - a0;
+    subResult = xformed - baseDim;
     if (subResult < 0)
-        var1 = -(subResult) >> 9;
+        shiftResult = -(subResult) >> 9;
     else
-        var1 = -(subResult >> 9);
-    return a2 - ((u32)(a2 * a1) / (u32)(a0) + var1);
+        shiftResult = -(subResult >> 9);
+    return modifier - ((u32)(modifier * xformed) / (u32)(baseDim) + shiftResult);
 }
 
-void obj_update_pos2(struct Sprite *sprite, s32 a1, s32 a2)
+static void obj_update_pos2(struct Sprite *sprite, s32 xmod, s32 ymod)
 {
-    s32 var0, var1, var2;
+    s32 dim, baseDim, xFormed;
 
     u32 matrixNum = sprite->oam.matrixNum;
-    if (a1 != 0x800)
+    if (xmod != 0x800)
     {
-        var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][0];
-        var1 = var0 << 8;
-        var2 = (var0 << 16) / gOamMatrices[matrixNum].a;
-        sprite->pos2.x = sub_800800C(var1, var2, a1);
+        dim = sOamDimensionsCopy[sprite->oam.shape][sprite->oam.size][0];
+        baseDim = dim << 8;
+        xFormed = (dim << 16) / gOamMatrices[matrixNum].a;
+        sprite->pos2.x = affine_get_new_pos2(baseDim, xFormed, xmod);
     }
-    if (a2 != 0x800)
+    if (ymod != 0x800)
     {
-        var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][1];
-        var1 = var0 << 8;
-        var2 = (var0 << 16) / gOamMatrices[matrixNum].d;
-        sprite->pos2.y = sub_800800C(var1, var2, a2);
+        dim = sOamDimensionsCopy[sprite->oam.shape][sprite->oam.size][1];
+        baseDim = dim << 8;
+        xFormed = (dim << 16) / gOamMatrices[matrixNum].d;
+        sprite->pos2.y = affine_get_new_pos2(baseDim, xFormed, ymod);
     }
 }
 
diff --git a/src/ss_anne.c b/src/ss_anne.c
index 401f4e235..df04d8c66 100644
--- a/src/ss_anne.c
+++ b/src/ss_anne.c
@@ -79,7 +79,7 @@ static const struct SpriteTemplate sSmokeSpriteTemplate = {
     SmokeSpriteCallback
 };
 
-void Special_SSAnneDepartureCutscene(void)
+void DoSSAnneDepartureCutscene(void)
 {
     u8 taskId;
 
diff --git a/src/start_menu.c b/src/start_menu.c
index b159f0375..867e469e0 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -23,7 +23,7 @@
 #include "field_fadetransition.h"
 #include "field_player_avatar.h"
 #include "new_menu_helpers.h"
-#include "event_object_80688E4.h"
+#include "event_object_movement.h"
 #include "event_object_lock.h"
 #include "script.h"
 #include "sound.h"
@@ -39,6 +39,7 @@
 #include "help_system.h"
 #include "constants/songs.h"
 #include "constants/flags.h"
+#include "constants/field_weather.h"
 
 enum StartMenuOption
 {
@@ -446,7 +447,7 @@ static void StartMenu_FadeScreenIfLeavingOverworld(void)
      && sStartMenuCallback != StartMenuSafariZoneRetireCallback)
     {
         StopPokemonLeagueLightingEffectTask();
-        FadeScreen(1, 0);
+        FadeScreen(FADE_TO_BLACK, 0);
     }
 }
 
@@ -562,8 +563,8 @@ static bool8 StartMenuLinkPlayerCallback(void)
 
 static bool8 StartCB_Save1(void)
 {
-    HelpSystem_BackupSomeVariable();
-    HelpSystem_SetSomeVariable2(12);
+    BackupHelpContext();
+    SetHelpContext(HELPCONTEXT_SAVE);
     StartMenu_PrepareForSave();
     sStartMenuCallback = StartCB_Save2;
     return FALSE;
@@ -579,19 +580,19 @@ static bool8 StartCB_Save2(void)
         ClearDialogWindowAndFrameToTransparent(0, TRUE);
         sub_80696C0();
         ScriptContext2_Disable();
-        HelpSystem_RestoreSomeVariable();
+        RestoreHelpContext();
         return TRUE;
     case SAVECB_RETURN_CANCEL:
         ClearDialogWindowAndFrameToTransparent(0, FALSE);
         DrawStartMenuInOneGo();
-        HelpSystem_RestoreSomeVariable();
+        RestoreHelpContext();
         sStartMenuCallback = StartCB_HandleInput;
         break;
     case SAVECB_RETURN_ERROR:
         ClearDialogWindowAndFrameToTransparent(0, TRUE);
         sub_80696C0();
         ScriptContext2_Disable();
-        HelpSystem_RestoreSomeVariable();
+        RestoreHelpContext();
         return TRUE;
     }
     return FALSE;
@@ -614,8 +615,8 @@ static u8 RunSaveDialogCB(void)
 
 void Field_AskSaveTheGame(void)
 {
-    HelpSystem_BackupSomeVariable();
-    HelpSystem_SetSomeVariable2(12);
+    BackupHelpContext();
+    SetHelpContext(HELPCONTEXT_SAVE);
     StartMenu_PrepareForSave();
     CreateTask(task50_save_game, 80);
 }
@@ -645,7 +646,7 @@ static void task50_save_game(u8 taskId)
     }
     DestroyTask(taskId);
     EnableBothScriptContexts();
-    HelpSystem_RestoreSomeVariable();
+    RestoreHelpContext();
 }
 
 static void CloseSaveMessageWindow(void)
diff --git a/src/strings.c b/src/strings.c
new file mode 100644
index 000000000..f5040838a
--- /dev/null
+++ b/src/strings.c
@@ -0,0 +1,1335 @@
+#include "global.h"
+#include "strings.h"
+
+const u8 gExpandedPlaceholder_Empty[] = _("");
+const u8 gExpandedPlaceholder_Kun[] = _("");
+const u8 gExpandedPlaceholder_Chan[] = _("");
+const u8 gExpandedPlaceholder_Sapphire[] = _("SAPPHIRE");
+const u8 gExpandedPlaceholder_Ruby[] = _("RUBY");
+const u8 gExpandedPlaceholder_Aqua[] = _("AQUA");
+const u8 gExpandedPlaceholder_Magma[] = _("MAGMA");
+const u8 gExpandedPlaceholder_Archie[] = _("ARCHIE");
+const u8 gExpandedPlaceholder_Maxie[] = _("MAXIE");
+const u8 gExpandedPlaceholder_Kyogre[] = _("KYOGRE");
+const u8 gExpandedPlaceholder_Groudon[] = _("GROUDON");
+const u8 gExpandedPlaceholder_Red[] = _("RED");
+const u8 gExpandedPlaceholder_Green[] = _("GREEN");
+const u8 gText_EggNickname[] = _("EGG");
+const u8 gStartMenuText_Pokemon[] = _("POKéMON");
+const u8 gText_NewGame[] = _("NEW GAME");
+const u8 gText_Continue[] = _("CONTINUE");
+const u8 gTextJP_Options[] = _("せっていを かえる");
+const u8 gUnusedText_MysteryGift[] = _("MYSTERY GIFT");
+const u8 gText_MysteryGift[] = _("MYSTERY GIFT");
+const u8 gText_WirelessAdapterIsNotConnected[] = _("The Wireless Adapter is not\nconnected.");
+const u8 gText_MysteryGiftCantBeUsedWhileWirelessAdapterIsAttached[] = _("MYSTERY GIFT can't be used while\nthe Wireless Adapter is attached.");
+const u8 gUnknown_8415B0E[] = _("がいぶデ-タにより レポ-トを こうしんします\nしばらく おまちください");
+const u8 gUnknown_8415B33[] = _("レポ-トが こうしんされました!");
+const u8 gUnknown_8415B44[] = _("レポ-トが こうしんされました!\pこれいじょう\nレポ-トが かききれないので\lバックアップカ-トリッジを\lこうかんしてください!\pくわしくは\nにんてんどう サ-ビスセンタ- まで\lおといあわせ ください");
+const u8 gUnknown_8415BAA[] = _("レポ-トの こうしんは\nしっぱいしました!\pバックアップカ-トリッジを\nこうかんしてください!\pくわしくは\nにんてんどう サ-ビスセンタ- まで\lおといあわせ ください");
+const u8 gText_SaveFileCorruptedPrevWillBeLoaded[] = _("The save file is corrupted.\pThe previous save file will be\nloaded.");
+const u8 gText_SaveFileHasBeenDeleted[] = _("The save file has been\ndeleted...");
+const u8 gText_1MSubCircuitBoardNotInstalled[] = _("The 1M sub-circuit board is\nnot installed.");
+const u8 gTextJP_InternalBatteryHasRunDry[] = _("でんちぎれの ために\nとけいが うごかなくなりました\pとけいに かんけいする できごとは おきませんが\nゲ-ムを つづけて あそぶことは できます");
+const u8 gUnknown_8415CD9[] = _("しゅじんこう");
+const u8 gUnknown_8415CE0[] = _("ポケモンずかん");
+const u8 gText_MainMenuTime[] = _("TIME");
+const u8 gUnknown_8415CED[] = _("もっているバッジ");
+const u8 gUnknown_8415CF6[] = _("Aボタン");
+const u8 gUnknown_8415CFB[] = _("Bボタン");
+const u8 gUnknown_8415D00[] = _("Rボタン");
+const u8 gUnknown_8415D05[] = _("Lボタン");
+const u8 gUnknown_8415D0A[] = _("スタ-トボタン");
+const u8 gUnknown_8415D12[] = _("セレクトボタン");
+const u8 gUnknown_8415D1A[] = _("じゅうじボタン");
+const u8 gUnknown_8415D22[] = _("Lボタン Rボタン");
+const u8 gText_Controls[] = _("CONTROLS");
+ALIGNED(4) const u8 gUnknown_8415D38[] = _("{DPAD_UPDOWN}えらぶ {A_BUTTON}けってい");
+ALIGNED(4) const u8 gText_ABUTTONNext[] = _("{A_BUTTON}NEXT");
+ALIGNED(4) const u8 gText_ABUTTONNext_BBUTTONBack[] = _("{A_BUTTON}NEXT {B_BUTTON}BACK");
+ALIGNED(4) const u8 gText_UPDOWNPick_ABUTTONNext_BBUTTONBack[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}NEXT {B_BUTTON}CANCEL");
+ALIGNED(4) const u8 gText_UPDOWNPick_ABUTTONBBUTTONCancel[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}{B_BUTTON}CANCEL");
+ALIGNED(4) const u8 gText_ABUTTONExit[] = _("{A_BUTTON}EXIT");
+const u8 gText_Boy[] = _("BOY");
+const u8 gText_Girl[] = _("GIRL");
+const u8 gUnknown_8415D9C[] = _("POKéDEX   TABLE OF CONTENTS");
+const u8 gUnknown_8415DB8[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}OK");
+const u8 gUnknown_8415DC4[] = _("Seen:");
+const u8 gUnknown_8415DCA[] = _("Owned:");
+const u8 gUnknown_8415DD1[] = _("KANTO");
+const u8 gUnknown_8415DD7[] = _("NATIONAL");
+const u8 gUnknown_8415DE0[] = _("{COLOR WHITE2}{SHADOW LIGHT_BLUE}POKéMON HABITATS");
+const u8 gText_DexCategory_GrasslandPkmn[] = _("Grassland POKéMON");
+const u8 gText_DexCategory_ForestPkmn[] = _("Forest POKéMON");
+const u8 gText_DexCategory_WatersEdgePkmn[] = _("Water's-edge POKéMON");
+const u8 gText_DexCategory_SeaPkmn[] = _("Sea POKéMON");
+const u8 gText_DexCategory_CavePkmn[] = _("Cave POKéMON");
+const u8 gText_DexCategory_MountainPkmn[] = _("Mountain POKéMON");
+const u8 gText_DexCategory_RoughTerrainPkmn[] = _("Rough-terrain POKéMON");
+const u8 gText_DexCategory_UrbanPkmn[] = _("Urban POKéMON");
+const u8 gText_DexCategory_RarePkmn[] = _("Rare POKéMON");
+const u8 gUnknown_8415E88[] = _("{COLOR WHITE2}{SHADOW LIGHT_BLUE}SEARCH");
+const u8 gUnknown_8415E95[] = _("NUMERICAL MODE");
+const u8 gUnknown_8415EA4[] = _("A TO Z MODE");
+const u8 gUnknown_8415EB0[] = _("{COLOR WHITE2}{SHADOW LIGHT_BLUE}OTHER");
+const u8 gUnknown_8415EBC[] = _("ずかんの つかいかた");
+const u8 gUnknown_8415EC7[] = _("CLOSE POKéDEX");
+const u8 gUnknown_8415ED5[] = _("TYPE MODE");
+const u8 gUnknown_8415EDF[] = _("LIGHTEST MODE");
+const u8 gUnknown_8415EED[] = _("SMALLEST MODE");
+const u8 gUnknown_8415EFB[] = _("{COLOR WHITE2}{SHADOW LIGHT_BLUE}POKéMON LIST");
+const u8 gUnknown_8415F0E[] = _("NUMERICAL MODE: KANTO");
+const u8 gUnknown_8415F24[] = _("NUMERICAL MODE: NATIONAL");
+const u8 gUnknown_8415F3D[] = _("POKéMON LIST");
+const u8 gUnknown_8415F4A[] = _("SEARCH");
+const u8 gText_PickOKExit[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}OK {B_BUTTON}CANCEL");
+const u8 gUnknown_8415F66[] = _("-----");
+const u8 gUnknown_8415F6C[] = _("{DPAD_LEFTRIGHT}PICK{PLUS}FLIP PAGE {A_BUTTON}CHECK {B_BUTTON}CANCEL");
+const u8 gUnknown_8415F8F[] = _(" POKéMON");
+const u8 gUnknown_8415F98[] = _("HT");
+const u8 gUnknown_8415F9B[] = _("WT");
+const u8 gUnknown_8415F9E[] = _("”");
+const u8 gUnknown_8415FA0[] = _("lbs.");
+const u8 gUnknown_8415FA5[] = _("ポケモンデ-タ");
+const u8 gUnknown_8415FAD[] = _("{START_BUTTON}CRY");
+const u8 gUnknown_8415FB3[] = _("{A_BUTTON}NEXT DATA {B_BUTTON}CANCEL");
+const u8 gUnknown_8415FC8[] = _("{A_BUTTON}NEXT");
+const u8 gUnknown_8415FCF[] = _("{A_BUTTON}CANCEL {B_BUTTON}PREVIOUS DATA");
+const u8 gUnknown_8415FE8[] = _("AREA");
+const u8 gUnknown_8415FED[] = _("SIZE");
+const u8 gUnknown_8415FF2[] = _("AREA UNKNOWN");
+const u8 gUnknown_8415FFF[] = _("{NO}");
+const u8 gUnknown_8416002[] = _("PAGE");
+ALIGNED(4) const u8 gText_WelcomeToHOF[] = _("Welcome to the HALL OF FAME!");
+ALIGNED(4) const u8 gUnknown_8416028[] = _("みつけた ポケモン {STR_VAR_1}!\nつかまえた ポケモン {STR_VAR_2}!\pオダマキはかせの\nポケモンずかん ひょうか!\pオダマキ“どれどれ\p");
+ALIGNED(4) const u8 gUnknown_8416068[] = _("ここまでの レポ-トを かきしるしています!\nでんげんを きらないでください");
+ALIGNED(4) const u8 gText_HOFCorrupted[] = _("The HALL OF FAME data is\ncorrupted.");
+const u8 gText_HOFNumber[] = _("HALL OF FAME No. {STR_VAR_1}");
+const u8 gText_LeagueChamp[] = _("LEAGUE CHAMPION!\nCONGRATULATIONS!");
+ALIGNED(4) const u8 gText_Number[] = _("No. ");
+ALIGNED(4) const u8 gText_Level[] = _("Lv. ");
+ALIGNED(4) const u8 gText_Name[] = _("NAME");
+ALIGNED(4) const u8 gText_IDNumber[] = _("IDNo.");
+const u8 gUnknown_841610A[] = _("{HIGHLIGHT WHITE2}{COLOR DARK_GREY}オダマキはかせが ピンチだ!\nポケモンを だして たすけてあげよう!");
+const u8 gUnknown_8416133[] = _("{HIGHLIGHT WHITE2}{COLOR DARK_GREY}このポケモンにしますか?");
+const u8 gUnknown_8416146[] = _("ポケモン");
+const u8 gText_SaveError_PleaseExchangeBackupMemory[] = _("Save error.\pPlease exchange the\nbackup memory.");
+const u8 gSaveStatName_Player[] = _("PLAYER");
+const u8 gSaveStatName_Badges[] = _("BADGES");
+const u8 gSaveStatName_Pokedex[] = _("POKéDEX");
+const u8 gSaveStatName_Time[] = _("TIME");
+const u8 gUnknown_8416195[] = _("どこへ とびますか?");
+const u8 gOtherText_Use[] = _("USE");
+const u8 gOtherText_Toss[] = _("TOSS");
+const u8 gOtherText_Register[] = _("REGISTER");
+const u8 gOtherText_Give[] = _("GIVE");
+const u8 gUnknown_84161B7[] = _("けってい");
+const u8 gOtherText_Walk[] = _("WALK");
+const u8 gFameCheckerText_Cancel[] = _("CANCEL");
+const u8 gOtherText_Exit[] = _("EXIT");
+const u8 gString_Dummy[] = _("");
+const u8 gUnknown_84161CE[] = _("キャンセル");
+const u8 gText_Item[] = _("ITEM");
+const u8 gText_Mail[] = _("MAIL");
+const u8 gText_Take[] = _("TAKE");
+const u8 gText_Store[] = _("STORE");
+const u8 gOtherText_Check[] = _("CHECK");
+const u8 gUnknown_84161EF[] = _("NONE");
+const u8 gOtherText_Open[] = _("OPEN");
+const u8 gOtherText_Deselect[] = _("DESELECT");
+const u8 gUnknown_8416202[] = _("???");
+const u8 gUnknown_8416206[] = _("?????");
+const u8 gText_Slash[] = _("/");
+const u8 gUnknown_841620E[] = _("-");
+const u8 gUnknown_8416210[] = _("--");
+const u8 gText_ThreeHyphens[] = _("---");
+const u8 gText_SevenHyphens[] = _("-------");
+const u8 gText_MaleSymbol[] = _("♂");
+const u8 gText_FemaleSymbol[] = _("♀");
+const u8 gText_Lv[] = _("{LV_2}");
+const u8 gOtherText_UnkF9_08_Clear_01[] = _("{NO}{CLEAR 0x01}");
+const u8 gUnknown_841622C[] = _("{PLUS}");
+const u8 gUnknown_841622F[] = _("{ESCAPE 0x03}");
+const u8 gUnknown_8416233[] = _("{ID}{NO}");
+const u8 gUnknown_8416238[] = _("{PP}");
+const u8 gText_SelectorArrow2[] = _("▶");
+const u8 gUnknown_841623D[] = _("YES\nNO");
+const u8 gText_GoBackToThePreviousMenu[] = _("Go back to the\nprevious menu.");
+const u8 gText_WhatWouldYouLikeToDo[] = _("What would you like to do?");
+const u8 gStartMenuText_Pokedex[] = _("POKéDEX");
+const u8 gStartMenuText_Bag[] = _("BAG");
+const u8 gUnknown_8416289[] = _("ポケナビ");
+const u8 gStartMenuText_Player[] = _("{PLAYER}");
+const u8 gStartMenuText_Save[] = _("SAVE");
+const u8 gStartMenuText_Option[] = _("OPTION");
+const u8 gStartMenuText_Exit[] = _("EXIT");
+const u8 gStartMenuText_Retire[] = _("RETIRE");
+const u8 gUnknown_84162A9[] = _("{STR_VAR_1}/{STR_VAR_2}\nBALLS  {STR_VAR_3}");
+const u8 gText_TimesStrVar1[] = _("×{STR_VAR_1}");
+const u8 gUnknown_84162BD[] = _(" BERRY");
+const u8 gText_Coins[] = _("{STR_VAR_1} COINS");
+const u8 gText_Items2[] = _("ITEMS");
+const u8 gText_PokeBalls2[] = _("POKé BALLS");
+const u8 gText_KeyItems2[] = _("KEY ITEMS");
+const u8 gText_DepositItem[] = _("DEPOSIT ITEM");
+const u8 gText_CloseBag[] = _("CLOSE BAG");
+const u8 gText_Var1IsSelected[] = _("{STR_VAR_1} is\nselected.");
+const u8 gText_CantWriteMailHere[] = _("You can't write\nMAIL here.");
+const u8 gText_ThereIsNoPokemon[] = _("There is no\nPOKéMON.");
+const u8 gOtherText_WhereShouldTheStrVar1BePlaced[] = _("Where should the {STR_VAR_1}\nbe placed?");
+const u8 gText_ItemCantBeHeld[] = _("The {STR_VAR_1} can't be held.");
+const u8 gText_TheStrVar1CantBeHeldHere[] = _("The {STR_VAR_1} can't be held\nhere.");
+const u8 gText_DepositHowManyStrVars1[] = _("Deposit how many\n{STR_VAR_1}(s)?");
+const u8 gText_DepositedStrVar2StrVar1s[] = _("Deposited {STR_VAR_2}\n{STR_VAR_1}(s).");
+const u8 gText_NoRoomToStoreItems[] = _("There's no room to\nstore items.");
+const u8 gText_TossOutHowManyStrVar1s[] = _("Toss out how many\n{STR_VAR_1}(s)?");
+const u8 gText_ThrewAwayStrVar2StrVar1s[] = _("Threw away {STR_VAR_2}\n{STR_VAR_1}(s).");
+const u8 gText_ThrowAwayStrVar2OfThisItemQM[] = _("Throw away {STR_VAR_2} of\nthis item?");
+const u8 gUnknown_8416425[] = _("OAK: {PLAYER}!\nThis isn't the time to use that!{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416451[] = _("You can't dismount your BIKE here.{PAUSE_UNTIL_PRESS}");
+const u8 gText_ItemfinderResponding[] = _("Huh?\nThe ITEMFINDER's responding!\pThere's an item buried around here!{PAUSE_UNTIL_PRESS}");
+const u8 gText_ItemfinderShakingWildly[] = _("Oh!\nThe ITEMFINDER's shaking wildly!\pThere's an item buried underfoot!\p‥ ‥ ‥ ‥ ‥ ‥{PAUSE_UNTIL_PRESS}");
+const u8 gText_NopeTheresNoResponse[] = _("‥ ‥ ‥ ‥Nope!\nThere's no response.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416537[] = _("Your COINS:\n{STR_VAR_1}{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416548[] = _("わざマシンを きどうした!");
+const u8 gUnknown_8416556[] = _("ひでんマシンを きどうした!");
+const u8 gUnknown_8416565[] = _("なかには {STR_VAR_1}が\nきろくされていた!\p{STR_VAR_1}を\nポケモンに おぼえさせますか?");
+const u8 gUnknown_841658C[] = _("{PLAYER} used the\n{STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_841659E[] = _("But the effects of a REPEL\nlingered from earlier.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_84165D2[] = _("{PLAYER} used the\n{STR_VAR_2}.\pWild POKéMON will be lured.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416600[] = _("{PLAYER} used the\n{STR_VAR_2}.\pWild POKéMON will be repelled.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416631[] = _("The BOX is full.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416644[] = _("POWDER QTY: {STR_VAR_1}{PAUSE_UNTIL_PRESS}");
+const u8 gOtherText_Powder[] = _("POWDER");
+const u8 gUnknown_841665C[] = _("Played the POKé FLUTE.\pNow, that's a catchy tune!{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416690[] = _("Played the POKé FLUTE.");
+const u8 gUnknown_84166A7[] = _("The POKé FLUTE awakened sleeping\nPOKéMON.{PAUSE_UNTIL_PRESS}");
+const u8 gText_TMCase[] = _("TM CASE");
+const u8 gText_Close[] = _("CLOSE");
+const u8 gText_TMCaseWillBePutAway[] = _("The TM CASE will be\nput away.");
+const u8 gText_FontSize0[] = _("{SIZE 0}");
+const u8 gText_FontSize2[] = _("{SIZE 2}");
+const u8 gUnknown_8416707[] = _("  ");
+const u8 gText_BerryPouch[] = _("BERRY POUCH");
+const u8 gText_TheBerryPouchWillBePutAway[] = _("The BERRY POUCH will be\nput away.");
+const u8 gText_ShopBuy[] = _("BUY");
+const u8 gText_ShopSell[] = _("SELL");
+const u8 gText_ShopQuit[] = _("SEE YA!");
+const u8 gText_InBagVar1[] = _("IN BAG:{SMALL} {STR_VAR_1}");
+const u8 gText_QuitShopping[] = _("Quit shopping.");
+const u8 gText_Var1CertainlyHowMany[] = _("{STR_VAR_1}? Certainly.\nHow many would you like?");
+const u8 gText_Var1AndYouWantedVar2[] = _("{STR_VAR_1}, and you want {STR_VAR_2}.\nThat will be ¥{STR_VAR_3}. Okay?");
+const u8 gUnknown_84167BB[] = _("{STR_VAR_1} だね!\n{STR_VAR_2}¥ だけど かうかい?");
+const u8 gUnknown_84167D0[] = _("{STR_VAR_1} ですね!\n{STR_VAR_2}¥ だけど かいますか?");
+const u8 gText_HereYouGoThankYou[] = _("Here you are!\nThank you!");
+const u8 gUnknown_8416800[] = _("どうも ありがとう!\nじたくの パソコンに おくって おきますね!");
+const u8 gUnknown_8416822[] = _("どうも ありがとう!\nじたくの パソコンに おくって おくね!");
+const u8 gText_YouDontHaveMoney[] = _("You don't have enough money.{PAUSE_UNTIL_PRESS}");
+const u8 gText_NoMoreRoomForThis[] = _("You have no more room for this\nitem.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416888[] = _("{STR_VAR_1}を\nいれる ばしょが いっぱいです{PAUSE_UNTIL_PRESS}");
+const u8 gText_CanIHelpWithAnythingElse[] = _("Is there anything else I can do?");
+const u8 gUnknown_84168BF[] = _("その ほかに\nなにか ちからに なれることは?");
+const u8 gUnknown_84168D7[] = _("プレミアボ-ル 1コ\nおまけ しておきますね!{PAUSE_UNTIL_PRESS}");
+const u8 gText_OhNoICantBuyThat[] = _("{STR_VAR_1}? Oh, no.\nI can't buy that.{PAUSE_UNTIL_PRESS}");
+const u8 gText_HowManyWouldYouLikeToSell[] = _("{STR_VAR_1}?\nHow many would you like to sell?");
+const u8 gText_ICanPayThisMuch_WouldThatBeOkay[] = _("I can pay ¥{STR_VAR_3}.\nWould that be okay?");
+const u8 gText_TurnedOverItemsWorthYen[] = _("Turned over the {STR_VAR_1}シSス\nworth ¥{STR_VAR_3}.");
+const u8 gText_PokedollarVar1[] = _("¥{STR_VAR_1}");
+const u8 gText_Shift[] = _("SHIFT");
+const u8 gText_SendOut[] = _("SEND OUT");
+const u8 gText_Switch2[] = _("SWITCH");
+const u8 gText_Summary5[] = _("SUMMARY");
+const u8 gUnknown_841699C[] = _("つかえるわざ");
+const u8 gText_Enter[] = _("ENTER");
+const u8 gText_NoEntry[] = _("NO ENTRY");
+const u8 gText_Take2[] = _("TAKE");
+const u8 gText_Read2[] = _("READ");
+const u8 gText_Trade4[] = _("TRADE");
+const u8 gText_HP3[] = _("HP");
+const u8 gText_SpAtk3[] = _("SP. ATK");
+const u8 gText_SpDef3[] = _("SP. DEF");
+const u8 gMenuText_Confirm[] = _("OK");
+const u8 gUnknown_84169D8[] = _("");
+const u8 gText_PauseUntilPress[] = _("{PAUSE_UNTIL_PRESS}");
+const u8 gText_WontHaveEffect[] = _("It won't have any effect.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_84169F8[] = _("This can't be used on\nthat POKéMON.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnCantSwitchOut[] = _("{STR_VAR_1} can't be switched\nout!{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnAlreadyInBattle[] = _("{STR_VAR_1} is already\nin battle!{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnAlreadySelected[] = _("{STR_VAR_1} has already been\nselected.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnHasNoEnergy[] = _("{STR_VAR_1} has no energy\nleft to battle!{PAUSE_UNTIL_PRESS}");
+const u8 gText_CantSwitchWithAlly[] = _("You can't switch {STR_VAR_1}'s\nPOKéMON with one of yours!{PAUSE_UNTIL_PRESS}");
+const u8 gText_EggCantBattle[] = _("An EGG can't battle!{PAUSE_UNTIL_PRESS}");
+const u8 gText_CantUseUntilNewBadge[] = _("This can't be used until a new\nBADGE is obtained.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416B16[] = _("No more than three POKéMON\nmay enter.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416B3E[] = _("No more than two POKéMON\nmay enter.{PAUSE_UNTIL_PRESS}");
+const u8 gText_SendMailToPC[] = _("Send the removed MAIL to\nyour PC?");
+const u8 gText_MailSentToPC[] = _("The MAIL was sent to your PC.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PCMailboxFull[] = _("Your PC's MAILBOX is full.{PAUSE_UNTIL_PRESS}");
+const u8 gText_MailMessageWillBeLost[] = _("If the MAIL is removed, the\nmessage will be lost. Okay?");
+const u8 gText_RemoveMailBeforeItem[] = _("MAIL must be removed before\nholding an item.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnWasGivenItem[] = _("{STR_VAR_1} was given the\n{STR_VAR_2} to hold.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnAlreadyHoldingItemSwitch[] = _("{STR_VAR_1} is already holding\none {STR_VAR_2}.\pWould you like to switch the\ntwo items?");
+const u8 gText_PkmnNotHolding[] = _("{STR_VAR_1} isn't holding\nanything.{PAUSE_UNTIL_PRESS}");
+const u8 gText_ReceivedItemFromPkmn[] = _("Received the {STR_VAR_2}\nfrom {STR_VAR_1}.{PAUSE_UNTIL_PRESS}");
+const u8 gText_MailTakenFromPkmn[] = _("MAIL was taken from the\nPOKéMON.{PAUSE_UNTIL_PRESS}");
+const u8 gText_SwitchedPkmnItem[] = _("The {STR_VAR_2} was taken and\nreplaced with the {STR_VAR_1}.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnHoldingItemCantHoldMail[] = _("This POKéMON is holding an\nitem. It cannot hold MAIL.{PAUSE_UNTIL_PRESS}");
+const u8 gText_MailTransferredFromMailbox[] = _("MAIL was transferred from\nthe MAILBOX.{PAUSE_UNTIL_PRESS}");
+const u8 gText_BagFullCouldNotRemoveItem[] = _("The {STR_VAR_1} is full. The POKéMON's\nitem could not be removed.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnLearnedMove3[] = _("{STR_VAR_1} learned\n{STR_VAR_2}!");
+const u8 gText_PkmnCantLearnMove[] = _("{STR_VAR_1} and {STR_VAR_2}\nare not compatible.\p{STR_VAR_2} can't be\nlearned.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnNeedsToReplaceMove[] = _("{STR_VAR_1} wants to learn the\nmove {STR_VAR_2}.\pHowever, {STR_VAR_1} already\nknows four moves.\pShould a move be deleted and\nreplaced with {STR_VAR_2}?");
+const u8 gText_StopLearningMove2[] = _("Stop trying to teach\n{STR_VAR_2}?");
+const u8 gText_MoveNotLearned[] = _("{STR_VAR_1} did not learn the\nmove {STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
+const u8 gText_WhichMoveToForget[] = _("Which move should be forgotten?{PAUSE_UNTIL_PRESS}");
+const u8 gText_12PoofForgotMove[] = _("1, {PAUSE 0x0F}2, and{PAUSE 0x0F}‥ {PAUSE 0x0F}‥ {PAUSE 0x0F}‥ {PAUSE 0x0F}{PLAY_SE SE_KON}Poof!\p{STR_VAR_1} forgot how to\nuse {STR_VAR_2}.\pAnd...{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnAlreadyKnows[] = _("{STR_VAR_1} already knows\n{STR_VAR_2}.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnHPRestoredByVar2[] = _("{STR_VAR_1}'s HP was restored\nby {STR_VAR_2} point(s).{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnCuredOfPoison[] = _("{STR_VAR_1} was cured of its\npoisoning.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnCuredOfParalysis[] = _("{STR_VAR_1} was cured of\nparalysis.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnWokeUp2[] = _("{STR_VAR_1} woke up.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnBurnHealed[] = _("{STR_VAR_1}'s burn was healed.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnThawedOut[] = _("{STR_VAR_1} was thawed out.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PPWasRestored[] = _("PP was restored.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8416FDA[] = _("{STR_VAR_1}は\nげんきを とりもどした!{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnBecameHealthy[] = _("{STR_VAR_1} became healthy.{PAUSE_UNTIL_PRESS}");
+const u8 gText_MovesPPIncreased[] = _("{STR_VAR_1}'s PP increased.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnElevatedToLvVar2[] = _("{STR_VAR_1} was elevated to\nLv. {STR_VAR_2}.");
+const u8 gText_PkmnBaseVar2StatIncreased[] = _("{STR_VAR_1}'s base {STR_VAR_2}\nstat was raised.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnSnappedOutOfConfusion[] = _("{STR_VAR_1} snapped out of its\nconfusion.{PAUSE_UNTIL_PRESS}");
+const u8 gText_PkmnGotOverInfatuation[] = _("{STR_VAR_1} got over its\ninfatuation.{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_8417094[] = _("That's your only\nPOKéMON for battle.");
+ALIGNED(4) const u8 gText_PkmnCantBeTradedNow[] = _("That POKéMON can't be traded\nnow.");
+ALIGNED(4) const u8 gText_EggCantBeTradedNow[] = _("An EGG can't be traded now.");
+ALIGNED(4) const u8 gText_OtherTrainersPkmnCantBeTraded[] = _("The other TRAINER's POKéMON\ncan't be traded now.");
+ALIGNED(4) const u8 gText_OtherTrainerCantAcceptPkmn[] = _("The other TRAINER can't accept\nthat POKéMON now.");
+ALIGNED(4) const u8 gText_CantTradeWithTrainer[] = _("You can't trade with that\nTRAINER now.");
+ALIGNED(4) const u8 gText_NotPkmnOtherTrainerWants[] = _("That isn't the type of POKéMON\nthat the other TRAINER wants.");
+ALIGNED(4) const u8 gText_ThatIsntAnEgg[] = _("That isn't an EGG.");
+const u8 gText_ChoosePokemon[] = _("Choose a POKéMON.");
+const u8 gText_MoveToWhere[] = _("Move to where?");
+const u8 gText_TeachWhichPokemon[] = _("Teach which POKéMON?");
+const u8 gText_UseOnWhichPokemon[] = _("Use on which POKéMON?");
+const u8 gText_GiveToWhichPokemon[] = _("Give to which POKéMON?");
+const u8 gText_DoWhatWithPokemon[] = _("Do what with this {PKMN}?");
+const u8 gText_NothingToCut[] = _("There's nothing to CUT.");
+const u8 gText_CantSurfHere[] = _("No SURFING here!");
+const u8 gText_AlreadySurfing[] = _("You're already SURFING.");
+const u8 gText_CantUseHere[] = _("Can't use that here.");
+const u8 gText_RestoreWhichMove[] = _("Restore which move?");
+const u8 gText_BoostPp[] = _("Boost PP of which?");
+const u8 gText_DoWhatWithItem[] = _("Do what with an item?");
+const u8 gText_NoPokemonForBattle[] = _("No battling this way!");
+const u8 gText_ChoosePokemon2[] = _("Choose a POKéMON.");
+const u8 gText_NotEnoughHp[] = _("Not enough HP‥");
+const u8 gText_ThreePkmnAreNeeded[] = _("Three {PKMN} are needed.");
+const u8 gText_PokemonCantBeSame[] = _("{PKMN} can't be the same.");
+const u8 gText_NoIdenticalHoldItems[] = _("No same hold items!");
+const u8 gText_CurrentIsTooFast[] = _("The current is much too fast!");
+const u8 gText_DoWhatWithMail[] = _("Do what with the MAIL?");
+const u8 gText_ChoosePokemonCancel[] = _("Choose POKéMON or CANCEL.");
+const u8 gText_ChoosePokemonConfirm[] = _("Choose POKéMON and confirm.");
+const u8 gText_TwoPokemonAreNeeded[] = _("Two POKéMON are needed.");
+const u8 gText_EnjoyCycling[] = _("Let's enjoy cycling!");
+const u8 gText_InUseAlready_PM[] = _("This is in use already.");
+const u8 gText_NoUse[] = _("No use.");
+const u8 gText_Able[] = _("ABLE");
+const u8 gText_First_PM[] = _("FIRST");
+const u8 gText_Second_PM[] = _("SECOND");
+const u8 gText_Third_PM[] = _("THIRD");
+const u8 gText_Able2[] = _("ABLE");
+const u8 gText_NotAble[] = _("NOT ABLE");
+const u8 gText_Able3[] = _("ABLE!");
+const u8 gText_NotAble2[] = _("NOT ABLE!");
+const u8 gText_Learned[] = _("LEARNED");
+const u8 gUnknown_8417457[] = _("OAK: It's important to get to know\nyour POKéMON thoroughly.\p");
+const u8 gUnknown_8417494[] = _("This is a list of your POKéMON,\n{PLAYER}.\pOpen this to check the skills\nand moves of your POKéMON.\pYou also choose POKéMON here if\nyou want to use an item on one.{PAUSE_UNTIL_PRESS}");
+const u8 gText_CutATreeOrGrass[] = _("Cut a tree or grass.");
+const u8 gText_FlyToAKnownTown[] = _("Fly to a known town.");
+const u8 gText_TravelOnWater[] = _("Travel on water.");
+const u8 gText_MoveHeavyBoulders[] = _("Move heavy boulders.");
+const u8 gText_LightUpDarkness[] = _("Light up darkness.");
+const u8 gText_ShatterACrackedRock[] = _("Shatter a cracked rock.");
+const u8 gText_ClimbAWaterfall[] = _("Climb a waterfall.");
+const u8 gUnknown_84175C1[] = _("すいちゅうに もぐる");
+const u8 gText_EscapeFromHere[] = _("Escape from here.");
+const u8 gText_LureWildPokemon[] = _("Lure wild POKéMON.");
+const u8 gText_ShareHp[] = _("Share HP.");
+const u8 gText_ReturnToAHealingSpot[] = _("Return to a healing spot.");
+const u8 gText_EscapeFromHereAndReturnTo[] = _("Want to escape from here and return\nto {STR_VAR_1}?");
+const u8 gText_ReturnToHealingSpot[] = _("Want to return to the healing spot\nused last in {STR_VAR_1}?");
+const u8 gText_Attack3[] = _("ATTACK");
+const u8 gText_Defense3[] = _("DEFENSE");
+const u8 gUnknown_8417683[] = _("とくこう");
+const u8 gUnknown_8417688[] = _("とくぼう");
+const u8 gText_Speed2[] = _("SPEED");
+const u8 gUnknown_8417693[] = _("HP");
+const u8 gText_PkmnCantParticipate[] = _("That POKéMON can't participate.{PAUSE_UNTIL_PRESS}");
+const u8 gText_CancelParticipation[] = _("Cancel participation?");
+const u8 gUnknown_84176CE[] = _("");
+const u8 gUnknown_84176CF[] = _("Cancel the battle?");
+const u8 gText_TurnOff[] = _("TURN OFF");
+const u8 gUnknown_84176EB[] = _("もようがえ");
+const u8 gText_ItemStorage[] = _("ITEM STORAGE");
+const u8 gText_Mailbox[] = _("MAILBOX");
+const u8 gText_DepositItem2[] = _("DEPOSIT ITEM");
+const u8 gText_WithdrawItem2[] = _("WITHDRAW ITEM");
+const u8 gUnknown_8417721[] = _("どうぐを すてる");
+const u8 gText_StoreItemsInThePC[] = _("Store items in the PC.");
+const u8 gText_TakeOutItemsFromThePC[] = _("Take out items from the PC.");
+const u8 gUnknown_841775D[] = _("パソコンに あずけている\nどうぐを すてます");
+const u8 gText_ThereAreNoItems[] = _("There are no items.{PAUSE_UNTIL_PRESS}");
+const u8 gText_NoMoreRoomInBag[] = _("There is no more\nroom in the BAG.");
+const u8 gText_WithdrawHowMany[] = _("Withdraw how many\n{STR_VAR_1}(s)?");
+const u8 gText_WithdrewQuantItem[] = _("Withdrew {STR_VAR_2}\n{STR_VAR_1}(s).");
+const u8 gOtherText_Read[] = _("READ");
+const u8 gOtherText_MoveToBag[] = _("MOVE TO BAG");
+const u8 gOtherText_Give2[] = _("GIVE");
+const u8 gText_TheresNoMailHere[] = _("There's no MAIL here.{PAUSE_UNTIL_PRESS}");
+const u8 gText_WhatWouldYouLikeToDoWithPlayersMail[] = _("What would you like to do with\n{STR_VAR_1}'s MAIL?");
+const u8 gText_MessageWillBeLost[] = _("The message will be lost.\nIs that okay?");
+const u8 gText_BagIsFull[] = _("The BAG is full.{PAUSE_UNTIL_PRESS}");
+const u8 gText_MailReturnedToBagMessageErased[] = _("The MAIL was returned to the BAG\nwith its message erased.{PAUSE_UNTIL_PRESS}");
+const u8 gText_WithdrawItem[] = _("WITHDRAW\nITEM");
+const u8 gText_Withdraw[] = _("WITHDRAW");
+const u8 gText_ReturnToPC[] = _("Return to the PC.");
+const u8 gText_LtSurge[] = _("LT. SURGE");
+const u8 gText_Koga[] = _("KOGA");
+const u8 gUnknown_84178DF[] = _("さんか する");
+const u8 gText_Info[] = _("INFO");
+const u8 gText_Eggs[] = _("EGGS");
+const u8 gText_HallOfFame[] = _("HALL OF FAME");
+const u8 gText_Victories[] = _("VICTORIES");
+const u8 gText_Quit[] = _("QUIT");
+const u8 gText_Psn[] = _("PSN");
+const u8 gText_Par[] = _("PAR");
+const u8 gText_Slp[] = _("SLP");
+const u8 gText_Brn[] = _("BRN");
+const u8 gText_Frz[] = _("FRZ");
+const u8 gUnknown_8417920[] = _("TOXIC");
+const u8 gUnknown_8417926[] = _("OK");
+const u8 gOtherText_Quit[] = _("QUIT");
+const u8 gUnknown_841792E[] = _("みました");
+const u8 gUnknown_8417933[] = _("これから");
+const u8 gText_Yes[] = _("YES");
+const u8 gText_No[] = _("NO");
+const u8 gUnknown_841793F[] = _("せつめい");
+const u8 gText_SingleBattle[] = _("SINGLE BATTLE");
+const u8 gText_DoubleBattle[] = _("DOUBLE BATTLE");
+const u8 gText_MultiBattle[] = _("MULTI BATTLE");
+const u8 gText_MakeAChallenge[] = _("Make a challenge.");
+const u8 gText_Info_2[] = _("INFO");
+const u8 gText_FreshWater_200[] = _("FRESH WATER{CLEAR_TO 0x57}{SMALL}¥200");
+const u8 gText_SodaPop_300[] = _("SODA POP{CLEAR_TO 0x57}{SMALL}¥300");
+const u8 gText_Lemonade_350[] = _("LEMONADE{CLEAR_TO 0x57}{SMALL}¥350");
+const u8 gText_50Coins_1000[] = _("{SMALL} 50 COINS{CLEAR_TO 0x45}¥1,000");
+const u8 gText_500Coins_10000[] = _("{SMALL}500 COINS{CLEAR_TO 0x40}¥10,000");
+const u8 gText_Excellent[] = _("Excellent");
+const u8 gText_NotSoBad[] = _("Not so bad");
+const u8 gText_RedShard[] = _("RED SHARD");
+const u8 gText_YellowShard[] = _("YELLOW SHARD");
+const u8 gText_BlueShard[] = _("BLUE SHARD");
+const u8 gText_GreenShard[] = _("GREEN SHARD");
+const u8 gUnknown_8417A30[] = _("バトルタワ-");
+const u8 gText_Right[] = _("Right");
+const u8 gText_Left[] = _("Left");
+const u8 gText_Tm13_4000Coins[] = _("TM13{CLEAR_TO 0x48}{SMALL}4,000 COINS");
+const u8 gText_Tm23_3500Coins[] = _("TM23{CLEAR_TO 0x48}{SMALL}3,500 COINS");
+const u8 gText_Tm24_4000Coins[] = _("TM24{CLEAR_TO 0x48}{SMALL}4,000 COINS");
+const u8 gText_Tm30_4500Coins[] = _("TM30{CLEAR_TO 0x48}{SMALL}4,500 COINS");
+const u8 gText_Tm35_4000Coins[] = _("TM35{CLEAR_TO 0x48}{SMALL}4,000 COINS");
+const u8 gText_1F_2[] = _("1F");
+const u8 gText_2F_2[] = _("2F");
+const u8 gText_3F_2[] = _("3F");
+const u8 gText_4F_2[] = _("4F");
+const u8 gText_5F_2[] = _("5F");
+const u8 gText_Cool[] = _("COOL");
+const u8 gText_Beauty[] = _("BEAUTY");
+const u8 gText_Cute[] = _("CUTE");
+const u8 gText_Smart[] = _("SMART");
+const u8 gText_Tough[] = _("TOUGH");
+const u8 gText_Normal[] = _("NORMAL");
+const u8 gText_Black[] = _("BLACK");
+const u8 gText_Pink[] = _("PINK");
+const u8 gText_Sepia[] = _("SEPIA");
+const u8 gText_Cool_2[] = _("COOL");
+const u8 gText_Beauty_2[] = _("BEAUTY");
+const u8 gText_Cute_2[] = _("CUTE");
+const u8 gText_Smart_2[] = _("SMART");
+const u8 gText_Tough_2[] = _("TOUGH");
+const u8 gText_Items[] = _("ITEMS");
+const u8 gText_KeyItems[] = _("KEY ITEMS");
+const u8 gText_PokeBalls[] = _("POKé BALLS");
+const u8 gText_TMsAndHMs[] = _("TMs & HMs");
+const u8 gText_Berries[] = _("BERRIES");
+const u8 gText_Boulderbadge[] = _("BOULDERBADGE");
+const u8 gText_Cascadebadge[] = _("CASCADEBADGE");
+const u8 gText_Thunderbadge[] = _("THUNDERBADGE");
+const u8 gText_Rainbowbadge[] = _("RAINBOWBADGE");
+const u8 gText_Soulbadge[] = _("SOULBADGE");
+const u8 gText_Marshbadge[] = _("MARSHBADGE");
+const u8 gText_Volcanobadge[] = _("VOLCANOBADGE");
+const u8 gText_Earthbadge[] = _("EARTHBADGE");
+const u8 gText_SomeoneSPc[] = _("SOMEONE'S PC");
+const u8 gText_BillSPc[] = _("BILL'S PC");
+const u8 gText_SPc[] = _("{PLAYER}'s PC");
+const u8 gText_HallOfFame_2[] = _("HALL OF FAME");
+const u8 gText_LogOff[] = _("LOG OFF");
+const u8 gText_ProfOakSPc[] = _("PROF. OAK's PC");
+const u8 gText_Eevee[] = _("EEVEE");
+const u8 gText_Flareon[] = _("FLAREON");
+const u8 gText_Jolteon[] = _("JOLTEON");
+const u8 gText_Vaporeon[] = _("VAPOREON");
+const u8 gText_QuitLooking[] = _("Quit looking.");
+const u8 gText_FreshWater[] = _("FRESH WATER");
+const u8 gText_SodaPop[] = _("SODA POP");
+const u8 gText_Lemonade[] = _("LEMONADE");
+const u8 gText_Coins_2[] = _("COINS");
+const u8 gText_Bicycle_1000000[] = _("BICYCLE{CLEAR_TO 0x49}{SMALL}¥1,000,000");
+const u8 gText_NoThanks[] = _("NO THANKS");
+const u8 gText_Abra_180Coins[] = _("ABRA{CLEAR_TO 0x55}{SMALL} 180 COINS");
+const u8 gText_Clefairy_500Coins[] = _("CLEFAIRY{CLEAR_TO 0x55}{SMALL} 500 COINS");
+const u8 gText_Dratini_2800Coins[] = _("DRATINI{CLEAR_TO 0x4B}{SMALL} 2,800 COINS");
+const u8 gText_Scyther_5500Coins[] = _("SCYTHER{CLEAR_TO 0x4B}{SMALL} 5,500 COINS");
+const u8 gText_Porygon_9999Coins[] = _("PORYGON{CLEAR_TO 0x4B}{SMALL} 9,999 COINS");
+const u8 gText_Abra_120Coins[] = _("ABRA{CLEAR_TO 0x55}{SMALL} 120 COINS");
+const u8 gText_Clefairy_750Coins[] = _("CLEFAIRY{CLEAR_TO 0x55}{SMALL} 750 COINS");
+const u8 gText_Pinsir_2500Coins[] = _("PINSIR{CLEAR_TO 0x4B}{SMALL} 2,500 COINS");
+const u8 gText_Dratini_4600Coins[] = _("DRATINI{CLEAR_TO 0x4B}{SMALL} 4,600 COINS");
+const u8 gText_Porygon_6500Coins[] = _("PORYGON{CLEAR_TO 0x4B}{SMALL} 6,500 COINS");
+const u8 gText_NoThanks_2[] = _("NO THANKS");
+const u8 gText_HelixFossil[] = _("HELIX FOSSIL");
+const u8 gText_DomeFossil[] = _("DOME FOSSIL");
+const u8 gText_OldAmber[] = _("OLD AMBER");
+const u8 gText_TradeCenter[] = _("TRADE CENTER");
+const u8 gText_Colosseum[] = _("COLOSSEUM");
+const u8 gText_GameLinkCable[] = _("Game Link cable");
+const u8 gText_Wireless[] = _("Wireless");
+const u8 gText_ItemsPocket[] = _("ITEMS POCKET");
+const u8 gText_KeyItemsPocket[] = _("KEY ITEMS POCKET");
+const u8 gText_PokeBallsPocket[] = _("POKé BALLS POCKET");
+const u8 gText_TmCase[] = _("TM CASE");
+const u8 gText_BerryPouch_2[] = _("BERRY POUCH");
+const u8 gText_Other[] = _("OTHER");
+const u8 gText_OneIsland[] = _("ONE ISLAND");
+const u8 gText_TwoIsland[] = _("TWO ISLAND");
+const u8 gText_ThreeIsland[] = _("THREE ISLAND");
+const u8 gText_FourIsland[] = _("FOUR ISLAND");
+const u8 gText_FiveIsland[] = _("FIVE ISLAND");
+const u8 gText_SixIsland[] = _("SIX ISLAND");
+const u8 gText_SevenIsland[] = _("SEVEN ISLAND");
+const u8 gText_Vermilion[] = _("VERMILION");
+const u8 gText_Colosseum_2[] = _("COLOSSEUM");
+const u8 gText_BerryCrush[] = _("BERRY CRUSH");
+const u8 gText_Dummy_8417E66[] = _("");
+const u8 gText_Dummy_8417E67[] = _("");
+const u8 gUnknown_8417E68[] = _("せつめいを きく");
+const u8 gText_Dummy_8417E71[] = _("");
+const u8 gText_PokemonJump[] = _("POKéMON JUMP");
+const u8 gText_DodrioBerryPicking[] = _("DODRIO BERRY-PICKING");
+const u8 gText_2Tinymushrooms[] = _("2 TINYMUSHROOMS");
+const u8 gText_1BigMushroom[] = _("1 BIG MUSHROOM");
+const u8 gText_SeviiIslands[] = _("SEVII ISLANDS");
+const u8 gText_NavelRock[] = _("NAVEL ROCK");
+const u8 gText_BirthIsland[] = _("BIRTH ISLAND");
+const u8 gText_MiracleSeed_1000Coins[] = _("MIRACLE SEED{CLEAR_TO 0x50}{SMALL}1,000 COINS");
+const u8 gText_Charcoal_1000Coins[] = _("CHARCOAL{CLEAR_TO 0x50}{SMALL}1,000 COINS");
+const u8 gText_MysticWater_1000Coins[] = _("MYSTIC WATER{CLEAR_TO 0x50}{SMALL}1,000 COINS");
+const u8 gText_YellowFlute_1600Coins[] = _("YELLOW FLUTE{CLEAR_TO 0x50}{SMALL}1,600 COINS");
+const u8 gText_SmokeBall_800Coins[] = _("SMOKE BALL{CLEAR_TO 0x5A}{SMALL}800 COINS");
+const u8 gText_Dummy_8417F67[] = _("");
+const u8 gText_Dummy_8417F68[] = _("");
+const u8 gText_BecomeLeader[] = _("BECOME LEADER");
+const u8 gText_JoinGroup[] = _("JOIN GROUP");
+const u8 gOtherText_Single[] = _("SINGLE");
+const u8 gOtherText_Double[] = _("DOUBLE");
+const u8 gOtherText_Knockout[] = _("KNOCKOUT");
+const u8 gOtherText_Mixed[] = _("MIXED");
+const u8 gUnknown_8417F9F[] = _("99かい いじょう");
+const u8 gUnknown_8417FA9[] = _("1ぷん いじょう");
+const u8 gUnknown_8417FB2[] = _("びょう");
+const u8 gUnknown_8417FB6[] = _("かい");
+const u8 gText_DecimalPoint[] = _(".");
+const u8 gText_BigGuy[] = _("Big guy");
+const u8 gText_BigGirl[] = _("Big girl");
+const u8 gText_Daughter[] = _("son");
+const u8 gText_Son[] = _("daughter");
+const u8 gText_BoulderBadge[] = _("BOULDERBADGE");
+const u8 gText_CascadeBadge[] = _("CASCADEBADGE");
+const u8 gText_ThunderBadge[] = _("THUNDERBADGE");
+const u8 gText_RainbowBadge[] = _("RAINBOWBADGE");
+const u8 gText_SoulBadge[] = _("SOULBADGE");
+const u8 gText_MarshBadge[] = _("MARSHBADGE");
+const u8 gText_VolcanoBadge[] = _("VOLCANOBADGE");
+const u8 gText_EarthBadge[] = _("EARTHBADGE");
+const u8 gText_1F[] = _("1F");
+const u8 gText_2F[] = _("2F");
+const u8 gText_3F[] = _("3F");
+const u8 gText_4F[] = _("4F");
+const u8 gText_5F[] = _("5F");
+const u8 gText_6F[] = _("6F");
+const u8 gText_7F[] = _("7F");
+const u8 gText_8F[] = _("8F");
+const u8 gText_9F[] = _("9F");
+const u8 gText_10F[] = _("10F");
+const u8 gText_11F[] = _("11F");
+const u8 gText_B1F[] = _("B1F");
+const u8 gText_B2F[] = _("B2F");
+const u8 gText_B3F[] = _("B3F");
+const u8 gText_B4F[] = _("B4F");
+const u8 gText_Rooftop[] = _("ROOFTOP");
+const u8 gText_NowOn[] = _("Now on:");
+const u8 gText_LinkedGamePlay[] = _("LINKED GAME PLAY");
+const u8 gText_DirectCorner[] = _("DIRECT CORNER");
+const u8 gText_UnionRoom[] = _("UNION ROOM");
+const u8 gText_Energypowder_50[] = _("ENERGYPOWDER{CLEAR_TO 0x74}{SMALL}50");
+const u8 gText_EnergyRoot_80[] = _("ENERGY ROOT{CLEAR_TO 0x74}{SMALL}80");
+const u8 gText_HealPowder_50[] = _("HEAL POWDER{CLEAR_TO 0x74}{SMALL}50");
+const u8 gText_RevivalHerb_300[] = _("REVIVAL HERB{CLEAR_TO 0x6F}{SMALL}300");
+const u8 gText_Protein_1000[] = _("PROTEIN{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_Iron_1000[] = _("IRON{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_Carbos_1000[] = _("CARBOS{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_Calcium_1000[] = _("CALCIUM{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_Zinc_1000[] = _("ZINC{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_HpUp_1000[] = _("HP UP{CLEAR_TO 0x65}{SMALL}1,000");
+const u8 gText_PpUp_3000[] = _("PP UP{CLEAR_TO 0x65}{SMALL}3,000");
+const u8 gString_BattleRecords_PlayersBattleResults[] = _("{PLAYER}'s BATTLE RESULTS");
+const u8 gString_BattleRecords_TotalRecord[] = _("TOTAL RECORD W:{STR_VAR_1} L:{STR_VAR_2} D:{STR_VAR_3}");
+const u8 gString_BattleRecords_ColumnHeaders[] = _("WIN{CLEAR_TO 0x30}LOSE{CLEAR_TO 0x60}DRAW");
+const u8 gString_BattleRecords_7Dashes[] = _("-------");
+const u8 gString_BattleRecords_4Dashes[] = _("----");
+const u8 gFameCheckerText_FameCheckerWillBeClosed[] = _("The FAME CHECKER will be closed.");
+const u8 gFameCheckerText_ClearTextbox[] = _("\n                              ");
+const u8 gUnknown_8418204[] = _("やめる");
+const u8 gUnknown_8418208[] = _("Exit from the BOX.");
+const u8 gUnknown_841821B[] = _("What do you want to do?");
+const u8 gUnknown_8418233[] = _("Please pick a theme.");
+const u8 gUnknown_8418248[] = _("Pick the wallpaper.");
+const u8 gUnknown_841825C[] = _("{DYNAMIC 0x00} is selected.");
+const u8 gUnknown_841826C[] = _("Jump to which BOX?");
+const u8 gUnknown_841827F[] = _("Deposit in which BOX?");
+const u8 gUnknown_8418295[] = _("{DYNAMIC 0x00} was deposited.");
+const u8 gUnknown_84182A7[] = _("The BOX is full.");
+const u8 gUnknown_84182B8[] = _("Release this POKéMON?");
+const u8 gUnknown_84182CE[] = _("{DYNAMIC 0x00} was released.");
+const u8 gUnknown_84182DF[] = _("Bye-bye, {DYNAMIC 0x00}!");
+const u8 gUnknown_84182EC[] = _("Mark your POKéMON.");
+const u8 gUnknown_84182FF[] = _("That's your last POKéMON!");
+const u8 gUnknown_8418319[] = _("Your party's full!");
+const u8 gUnknown_841832C[] = _("You're holding a POKéMON!");
+const u8 gUnknown_8418346[] = _("Which one will you take?");
+const u8 gUnknown_841835F[] = _("You can't release an EGG.");
+const u8 gUnknown_8418379[] = _("Continue BOX operations?");
+const u8 gUnknown_8418392[] = _("{DYNAMIC 0x00} came back!");
+const u8 gUnknown_84183A0[] = _("Was it worried about you?");
+const u8 gUnknown_84183BA[] = _("‥ ‥ ‥ ‥ ‥!");
+const u8 gUnknown_84183C5[] = _("Please remove the MAIL.");
+const u8 gUnknown_84183DD[] = _("GIVE to a POKéMON?");
+const u8 gUnknown_84183F0[] = _("Placed item in the BAG.");
+const u8 gUnknown_8418408[] = _("The BAG is full.");
+const u8 gUnknown_8418419[] = _("Put this item in the BAG?");
+const u8 gUnknown_8418433[] = _("{DYNAMIC 0x00} is now held.");
+const u8 gUnknown_8418443[] = _("Changed to {DYNAMIC 0x00}.");
+const u8 gUnknown_8418452[] = _("MAIL can't be stored!");
+const u8 gUnknown_8418468[] = _("CANCEL");
+const u8 gUnknown_841846F[] = _("STORE");
+const u8 gUnknown_8418475[] = _("WITHDRAW");
+const u8 gUnknown_841847E[] = _("SHIFT");
+const u8 gUnknown_8418484[] = _("MOVE");
+const u8 gUnknown_8418489[] = _("PLACE");
+const u8 gUnknown_841848F[] = _("SUMMARY");
+const u8 gUnknown_8418497[] = _("RELEASE");
+const u8 gUnknown_841849F[] = _("MARK");
+const u8 gUnknown_84184A4[] = _("NAME");
+const u8 gUnknown_84184A9[] = _("JUMP");
+const u8 gUnknown_84184AE[] = _("WALLPAPER");
+const u8 gUnknown_84184B8[] = _("TAKE");
+const u8 gUnknown_84184BD[] = _("GIVE");
+const u8 gUnknown_84184C2[] = _("SWITCH");
+const u8 gUnknown_84184C9[] = _("BAG");
+const u8 gUnknown_84184CD[] = _("INFO");
+const u8 gUnknown_84184D2[] = _("SCENERY 1");
+const u8 gUnknown_84184DC[] = _("SCENERY 2");
+const u8 gUnknown_84184E6[] = _("SCENERY 3");
+const u8 gUnknown_84184F0[] = _("ETCETERA");
+const u8 gUnknown_84184F9[] = _("FOREST");
+const u8 gUnknown_8418500[] = _("CITY");
+const u8 gUnknown_8418505[] = _("DESERT");
+const u8 gUnknown_841850C[] = _("SAVANNA");
+const u8 gUnknown_8418514[] = _("CRAG");
+const u8 gUnknown_8418519[] = _("VOLCANO");
+const u8 gUnknown_8418521[] = _("SNOW");
+const u8 gUnknown_8418526[] = _("CAVE");
+const u8 gUnknown_841852B[] = _("BEACH");
+const u8 gUnknown_8418531[] = _("SEAFLOOR");
+const u8 gUnknown_841853A[] = _("RIVER");
+const u8 gUnknown_8418540[] = _("SKY");
+const u8 gUnknown_8418544[] = _("STARS");
+const u8 gUnknown_841854A[] = _("POKéCENTER");
+const u8 gUnknown_8418555[] = _("TILES");
+const u8 gUnknown_841855B[] = _("SIMPLE");
+const u8 gUnknown_8418562[] = _("なにを しますか?");
+const u8 gUnknown_841856C[] = _("WITHDRAW POKéMON");
+const u8 gUnknown_841857D[] = _("DEPOSIT POKéMON");
+const u8 gUnknown_841858D[] = _("MOVE POKéMON");
+const u8 gUnknown_841859A[] = _("MOVE ITEMS");
+const u8 gUnknown_84185A5[] = _("SEE YA!");
+const u8 gUnknown_84185AD[] = _("You can withdraw a POKéMON if you\nhave any in a BOX.");
+const u8 gUnknown_84185E2[] = _("You can deposit your party\nPOKéMON in any BOX.");
+const u8 gUnknown_8418611[] = _("You can move POKéMON that are\nstored in any BOX.");
+const u8 gUnknown_8418642[] = _("You can move items held by any\nPOKéMON in a BOX or your party.");
+const u8 gUnknown_8418681[] = _("See you later!");
+const u8 gUnknown_8418690[] = _("Can't deposit the last POKéMON!");
+const u8 gUnknown_84186B0[] = _("Can't take any more POKéMON.");
+const u8 gUnknown_84186CD[] = _("BOX");
+const u8 gUnknown_84186D1[] = _("Combine four words or phrases");
+const u8 gUnknown_84186EF[] = _("and make your profile.");
+const u8 gUnknown_8418706[] = _("Make a message of six phrases.");
+const u8 gUnknown_8418725[] = _("Max two 12-letter phrases/line.");
+const u8 gUnknown_8418745[] = _("Find words that describe your");
+const u8 gUnknown_8418763[] = _("feelings right now.");
+const u8 gUnknown_8418777[] = _("4つの ことばで");
+const u8 gUnknown_8418780[] = _("Combine nine words or phrases");
+const u8 gUnknown_841879E[] = _("and make a message.");
+const u8 gUnknown_84187B2[] = _("Change just one word or phrase");
+const u8 gUnknown_84187D1[] = _("and improve the BARD's song.");
+const u8 gUnknown_84187EE[] = _("and fill out the questionnaire.");
+const u8 gUnknown_841880E[] = _("Your profile");
+const u8 gUnknown_841881B[] = _("Your feeling at the battle's start");
+const u8 gUnknown_841883E[] = _("What you say if you win a battle");
+const u8 gUnknown_841885F[] = _("What you say if you lose a battle");
+const u8 gUnknown_8418881[] = _("The answer");
+const u8 gUnknown_841888C[] = _("The MAIL message");
+const u8 gUnknown_841889D[] = _("はがきに のせる あいさつは");
+const u8 gUnknown_84188AC[] = _("The new song");
+const u8 gUnknown_84188B9[] = _("Combine two words or phrases");
+const u8 gUnknown_84188D6[] = _("and make a trendy saying.");
+const u8 gUnknown_84188F0[] = _("The trendy saying");
+const u8 gUnknown_8418902[] = _("is as shown. Okay?");
+const u8 gUnknown_8418915[] = _("2つの ことばを くみあわせて");
+const u8 gUnknown_8418925[] = _("いい ことばを おしえてあげよう!");
+const u8 gUnknown_8418937[] = _("All the text being edited will");
+const u8 gUnknown_8418956[] = _("be deleted. Is that okay?");
+const u8 gUnknown_8418970[] = _("なにか ことばを いれてください!");
+const u8 gUnknown_8418982[] = _("ことばを ぜんぶ けすことは できません!");
+const u8 gUnknown_8418998[] = _("かえられる ことばは 1つ までです!");
+const u8 gUnknown_84189AC[] = _("うたを もとに もどします!");
+const u8 gUnknown_84189BB[] = _("それは もう はやっています!");
+const u8 gUnknown_84189CB[] = _("2つの ことばを くみあわせてください!");
+const u8 gUnknown_84189E0[] = _("Quit editing?");
+const u8 gUnknown_84189EE[] = _("Stop giving the POKéMON MAIL?");
+const u8 gUnknown_8418A0C[] = _("へんしゅうした ことばは ほぞん");
+const u8 gUnknown_8418A1D[] = _("されませんが いいですか?");
+const u8 gUnknown_8418A2B[] = _("PROFILE");
+const u8 gUnknown_8418A33[] = _("At the battle's start:");
+const u8 gUnknown_8418A4A[] = _("Upon winning a battle:");
+const u8 gUnknown_8418A61[] = _("Upon losing a battle:");
+const u8 gUnknown_8418A77[] = _("The BARD's Song");
+const u8 gUnknown_8418A87[] = _("What's hip and happening?");
+const u8 gUnknown_8418AA1[] = _("Interview");
+const u8 gUnknown_8418AAB[] = _("いい ことば");
+const u8 gUnknown_8418AB2[] = _("QUESTIONNAIRE");
+const u8 gUnknown_8418AC0[] = _(" きれい だよね-");
+const u8 gUnknown_8418ACA[] = _(" かわいい よね-");
+const u8 gUnknown_8418AD4[] = _(" のんびり だよね-");
+const u8 gUnknown_8418ADF[] = _(" ぽっかぽか だよね-");
+const u8 gUnknown_8418AEB[] = _(" あこがれる よね-");
+const u8 gUnknown_8418AF6[] = _(" ドキドキ するよね-");
+const u8 gUnknown_8418B02[] = _(" おもしろい よね-");
+const u8 gUnknown_8418B0D[] = _(" ふしぎ だよね-");
+const u8 gUnknown_8418B17[] = _("って");
+const u8 gUnknown_8418B1A[] = _("\nそう おもわない?");
+const u8 gUnknown_8418B25[] = _("たびに でたいな-\nどこか いい ところ しらない?");
+const u8 gUnknown_8418B40[] = _("120しょくの クレヨン かったんだ-\nいいでしょう?");
+const u8 gUnknown_8418B5C[] = _("しゃぼんだまに のって とべるように\nならないかな-");
+const u8 gUnknown_8418B77[] = _("すなはまに かいた もじは\nすぐに きえちゃうのが かなしいよね-");
+const u8 gUnknown_8418B99[] = _("うみの そこって どうなってるのかな-\nいちどで いいから みて みたいな-");
+const u8 gUnknown_8418BC0[] = _("ゆうやけを みると\nウチに かえりたく ならない?");
+const u8 gUnknown_8418BDA[] = _("みどりの しばで ねころがると\nきもちいいよね-");
+const u8 gUnknown_8418BF3[] = _("ひみつきち って いいよね!\nなんか わくわく してこない?");
+const u8 gUnknown_8418C12[] = _("ポケモン リ-グ");
+const u8 gText_PokemonCenter[] = _("POKéMON CENTER");
+const u8 gUnknown_8418C2A[] = _("に ポロックを あげますか?");
+const u8 gUnknown_8418C39[] = _("かっこよさ");
+const u8 gUnknown_8418C3F[] = _("うつくしさ");
+const u8 gUnknown_8418C45[] = _("かわいさ");
+const u8 gUnknown_8418C4A[] = _("かしこさ");
+const u8 gUnknown_8418C4F[] = _("たくましさ");
+const u8 gUnknown_8418C55[] = _("に みがきが かかった!");
+const u8 gUnknown_8418C62[] = _("なにも かわらなかった!");
+const u8 gUnknown_8418C6F[] = _("もう これいじょう たべない みたい‥");
+const u8 gText_SaveFailedScreen_CheckingBackupMemory[] = _("Save failed.\nChecking the backup memory‥\nPlease wait.\n“Time required:\nabout 1 minute”");
+const u8 gText_SaveFailedScreen_BackupMemoryDamaged[] = _("The backup memory is damaged or\nthe game's battery has run dry.\nThe game can be played, but its\nprogress cannot be saved.\n“Please press the A Button.”");
+const u8 gUnknown_8418D70[] = _("{COLOR RED}“このまま ぼうけんをつづけることは できません\nタイトルに もどります”");
+const u8 gUnknown_8418D99[] = _("けんさが しゅうりょうしました!\nもういちど レポ-トを かきこみます\nしばらくおまちください");
+const u8 gUnknown_8418DC9[] = _("レポ-トの かきこみは しゅうりょうしました\n{COLOR RED}“このまま ぼうけんをつづけることは できません\nタイトルに もどります”");
+const u8 gText_SaveFailedScreen_SaveCompleted[] = _("Save completed.\n“Please press the A Button.”");
+const u8 gUnknown_8418E36[] = _("れんらくせん");
+const u8 gUnknown_8418E3D[] = _("ひみつきち");
+const u8 gUnknown_8418E43[] = _("アジト");
+const u8 gText_YourName[] = _("YOUR NAME?");
+const u8 gText_BoxName[] = _("BOX NAME?");
+const u8 gText_PkmnsNickname[] = _("'s nickname?");
+const u8 gText_RivalsName[] = _("RIVAL's NAME?");
+const u8 gText_MoveOkBack[] = _("{DPAD_ANY}MOVE {A_BUTTON}OK {B_BUTTON}BACK");
+const u8 gText_AlphabetUpperLower[] = _("");
+const u8 gText_RegionMap_Space[] = _(" ");
+const u8 gText_RegionMap_AButtonGuide[] = _("{A_BUTTON}GUIDE");
+const u8 gText_RegionMap_AButtonCancel[] = _("{A_BUTTON}CANCEL");
+const u8 gText_RegionMap_AButtonCancel2[] = _("{A_BUTTON}CANCEL");
+const u8 gText_RegionMap_AButtonSwitch[] = _("{A_BUTTON}SWITCH");
+const u8 gText_RegionMap_AButtonOK[] = _("{A_BUTTON}OK");
+const u8 gText_RegionMap_DPadMove[] = _("{DPAD_ANY}MOVE");
+const u8 gText_RegionMap_UpDownPick[] = _("{DPAD_UPDOWN}PICK");
+const u8 gText_RegionMap_NoData[] = _("No data");
+const u8 gText_RegionMap_AreaDesc_ViridianForest[] = _("A deep and sprawling forest that\nextends around VIRIDIAN CITY.\nA natural maze, many people\nbecome lost inside.");
+const u8 gText_RegionMap_AreaDesc_MtMoon[] = _("A mystical mountain that is known\nfor its frequent meteor falls.\nThe shards of stars that fall\nhere are known as MOON STONES.");
+const u8 gText_RegionMap_AreaDesc_DiglettsCave[] = _("A seemingly plain tunnel that was\ndug by wild DIGLETT.\nIt is famous for connecting\nROUTES 2 and 11.");
+const u8 gText_RegionMap_AreaDesc_VictoryRoad[] = _("A tunnel situated on ROUTE 23.\nIt earned its name because it\nmust be traveled by all TRAINERS\naiming for the top.");
+const u8 gText_RegionMap_AreaDesc_PokemonMansion[] = _("A decrepit, burned-down mansion\non CINNABAR ISLAND.\nIt got its name because a famous\nPOKéMON researcher lived there.");
+const u8 gText_RegionMap_AreaDesc_SafariZone[] = _("An amusement park outside FUCHSIA\nCITY where many rare POKéMON can\nbe observed in the wild.\nCatch them in a popular game!");
+const u8 gText_RegionMap_AreaDesc_RockTunnel[] = _("A naturally formed underground\ntunnel. Because it has not been\ndeveloped, it is inky dark inside.\nA light is needed to get through.");
+const u8 gText_RegionMap_AreaDesc_SeafoamIslands[] = _("A pair of islands that is situated\non ROUTE 20.\nThe two islands are shaped the\nsame, as if they were twins.");
+const u8 gText_RegionMap_AreaDesc_PokemonTower[] = _("A tower that houses the graves of\ncountless POKéMON.\nMany people visit it daily to pay\ntheir respects to the fallen.");
+const u8 gText_RegionMap_AreaDesc_CeruleanCave[] = _("A mysterious cave that is filled\nwith terribly tough POKéMON.\nIt is so dangerous, the POKéMON\nLEAGUE is in charge of it.");
+const u8 gText_RegionMap_AreaDesc_PowerPlant[] = _("A power plant that was abandoned\nyears ago, though some of the\nmachines still work. It is infested\nwith electric POKéMON.");
+const u8 gText_RegionMap_AreaDesc_MtEmber[] = _("Supposedly an inactive volcano.\nHowever, there are persistent\nreports that the peak blazes\nwith fire at night.");
+const u8 gText_RegionMap_AreaDesc_BerryForest[] = _("A forest on a small islet off the\ncoast of THREE ISLAND. BERRIES\ngrow wildly in profusion, quickly\nreplenishing those that fall off.");
+const u8 gText_RegionMap_AreaDesc_IcefallCave[] = _("A cave which is covered by water\nand ice on FOUR ISLAND.\nIt seems like the end of the cave\nis connected to the ocean.");
+const u8 gText_RegionMap_AreaDesc_LostCave[] = _("A bewildering cave off the coast\nof RESORT GORGEOUS.\nSome curious thrill seekers have\nnever emerged from it.");
+const u8 gText_RegionMap_AreaDesc_TanobyRuins[] = _("An ancient ruin that is rumored to\nbe home to a peculiar POKéMON.\nHowever, so far, the POKéMON\nremains an unconfirmed rumor.");
+const u8 gText_RegionMap_AreaDesc_AlteringCave[] = _("This island has been known by this\nname since the distant past.\nNo one today knows where it got\nthis name, however.");
+const u8 gText_RegionMap_AreaDesc_PatternBush[] = _("A lush and bush-like area. \nIn it are patterns where no grass\ngrows. Some study it in the belief\nthat a secret is concealed.");
+const u8 gText_RegionMap_AreaDesc_DottedHole[] = _("A mysterious, just-discovered\nruin from an ancient time.\nIt got its name from the six dots\non its door.");
+const u8 gUnknown_8419782[] = _("{DYNAMIC 0x00} nature.\nMet in a trade.");
+const u8 gUnknown_841979D[] = _("{DYNAMIC 0x00} nature.\nMet in a trade.");
+const u8 gUnknown_84197B8[] = _("{DYNAMIC 0x00} nature.\nMet in a fateful encounter when\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_84197ED[] = _("{DYNAMIC 0x00} nature.\nMet in a fateful encounter when\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_8419822[] = _("{DYNAMIC 0x00} nature.\nMet in {DYNAMIC 0x02} at {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_8419841[] = _("{DYNAMIC 0x00} nature.\nMet in {DYNAMIC 0x02} at {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_8419860[] = _("{DYNAMIC 0x00} nature.\nApparently met in {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_841988A[] = _("{DYNAMIC 0x00} nature.\nApparently met in {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_84198B4[] = _("{DYNAMIC 0x00} nature.\nHatched: {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_84198D5[] = _("{DYNAMIC 0x00} nature.\nHatched: {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}.");
+const u8 gUnknown_84198F6[] = _("{DYNAMIC 0x00}なせいかく {LV_2}{DYNAMIC 0x01}のとき\n{DYNAMIC 0x02}で かえった ようだ");
+const u8 gUnknown_8419913[] = _("{DYNAMIC 0x00}せいかく {LV_2}{DYNAMIC 0x01}のとき\n{DYNAMIC 0x02}で かえった ようだ");
+const u8 gUnknown_841992F[] = _("{DYNAMIC 0x00} nature. Met in a fateful\nencounter (hatched: {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}).");
+const u8 gUnknown_841996D[] = _("{DYNAMIC 0x00} nature. Met in a fateful\nencounter (hatched: {DYNAMIC 0x02}\nat {LV_2} {DYNAMIC 0x01}).");
+const u8 gUnknown_84199AB[] = _("{DYNAMIC 0x00} nature. Apparently met in\na fateful encounter (hatched:\n{DYNAMIC 0x02} at {LV_2} {DYNAMIC 0x01}).");
+const u8 gUnknown_84199F4[] = _("{DYNAMIC 0x00} nature. Apparently met in\na fateful encounter シhatched:\n{DYNAMIC 0x02} at {LV_2} {DYNAMIC 0x01}ス.");
+const u8 gUnknown_8419A3D[] = _("An odd POKéMON EGG found by the\nDAY-CARE couple.");
+const u8 gUnknown_8419A6E[] = _("An odd POKéMON EGG obtained from\nthe traveling man.");
+const u8 gUnknown_8419AA2[] = _("A wondrously peculiar POKéMON EGG\nobtained at a nice place.");
+const u8 gUnknown_8419ADE[] = _("An odd POKéMON EGG obtained from\nan old woman at the SPA.");
+const u8 gUnknown_8419B18[] = _("A peculiar POKéMON EGG obtained\nin a trade.");
+const u8 gUnknown_8419B44[] = _("It looks like this\nEGG will take a\nlong time to hatch.");
+const u8 gUnknown_8419B7B[] = _("What will hatch\nfrom this? It will\ntake some time.");
+const u8 gUnknown_8419BAE[] = _("It occasionally\nmoves. It should\nhatch soon.");
+const u8 gUnknown_8419BDB[] = _("It's making sounds.\nIt's almost ready\nto hatch!");
+const u8 gUnknown_8419C0B[] = _("a trade");
+const u8 gUnknown_8419C13[] = _("Somewhere");
+const u8 gUnknown_8419C1D[] = _("POKéMON INFO");
+const u8 gUnknown_8419C2A[] = _("POKéMON SKILLS");
+const u8 gUnknown_8419C39[] = _("KNOWN MOVES");
+const u8 gUnknown_8419C45[] = _("No data");
+const u8 gUnknown_8419C4D[] = _("EXP. POINTS");
+const u8 gUnknown_8419C59[] = _("NEXT LV.");
+const u8 gUnknown_8419C62[] = _("{DPAD_RIGHT}PAGE {A_BUTTON}CANCEL");
+const u8 gUnknown_8419C72[] = _("{A_BUTTON}CANCEL");
+const u8 gUnknown_8419C7B[] = _("{DPAD_LEFTRIGHT}PAGE");
+const u8 gUnknown_8419C82[] = _("{DPAD_LEFT}PAGE {A_BUTTON}DETAIL");
+const u8 gUnknown_8419C92[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}SWITCH");
+const u8 gUnknown_8419CA2[] = _("{DPAD_UPDOWN}PICK");
+const u8 gUnknown_8419CA9[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}DELETE");
+const u8 gUnknown_8419CB9[] = _("HM moves can't be\nforgotten now.");
+const u8 gText_TrainerCardName[] = _("NAME: ");
+const u8 gText_TrainerCardIDNo[] = _("IDNo.");
+const u8 gText_TrainerCardMoney[] = _("MONEY");
+const u8 gText_TrainerCardYen[] = _("¥");
+const u8 gText_TrainerCardPokedex[] = _("POKéDEX");
+const u8 gText_TrainerCardNull[] = _("");
+const u8 gText_Colon2[] = _(":");
+const u8 gUnknown_8419CFA[] = _("てん");
+const u8 gText_TrainerCardTime[] = _("TIME");
+const u8 gUnknown_8419D02[] = _("ゲ-ムポイント");
+const u8 gText_Var1sTrainerCard[] = _("'s TRAINER CARD");
+const u8 gText_HallOfFameDebut[] = _("HALL OF FAME DEBUT  ");
+const u8 gText_LinkBattles[] = _("LINK BATTLES");
+const u8 gText_LinkCableBattles[] = _("LINK CABLE BATTLES");
+const u8 gText_WinLossRatio[] = _("W:{CLEAR_TO 0x30}L:");
+const u8 gText_PokemonTrades[] = _("POKéMON TRADES");
+const u8 gText_UnionRoomTradesBattles[] = _("UNION TRADES & BATTLES");
+const u8 gText_BerryCrushes[] = _("BERRY CRUSH");
+const u8 gText_WaitingTrainerFinishReading[] = _("Waiting for the other TRAINER to\nfinish reading your TRAINER CARD.");
+const u8 gText_MenuOption[] = _("OPTION");
+const u8 gText_TextSpeed[] = _("TEXT SPEED");
+const u8 gText_BattleScene[] = _("BATTLE SCENE");
+const u8 gText_BattleStyle[] = _("BATTLE STYLE");
+const u8 gText_Sound[] = _("SOUND");
+const u8 gText_ButtonMode[] = _("BUTTON MODE");
+const u8 gText_Frame[] = _("FRAME");
+const u8 gText_OptionMenuCancel[] = _("CANCEL");
+const u8 gText_TextSpeedSlow[] = _("SLOW");
+const u8 gText_TextSpeedMid[] = _("MID");
+const u8 gText_TextSpeedFast[] = _("FAST");
+const u8 gText_BattleSceneOn[] = _("ON");
+const u8 gText_BattleSceneOff[] = _("OFF");
+const u8 gText_BattleStyleShift[] = _("SHIFT");
+const u8 gText_BattleStyleSet[] = _("SET");
+const u8 gText_SoundMono[] = _("MONO");
+const u8 gText_SoundStereo[] = _("STEREO");
+const u8 gTextJP_Type[] = _("タイプ");
+const u8 gText_ButtonTypeHelp[] = _("HELP");
+const u8 gText_ButtonTypeLEqualsA[] = _("L=A");
+const u8 gText_ButtonTypeLR[] = _("LR");
+const u8 gText_FrameType[] = _("TYPE");
+const u8 gText_PickSwitchCancel[] = _("{DPAD_UPDOWN}PICK {DPAD_LEFTRIGHT}SWITCH {A_BUTTON}{B_BUTTON}CANCEL");
+const u8 gUnknown_8419E72[] = _("RTCを リセットします\nAで けってい Bで キャンセル");
+const u8 gUnknown_8419E90[] = _("げんざいの ゲ-ムない じかん");
+const u8 gUnknown_8419EA0[] = _("ぜんかいの ゲ-ムない じかん");
+const u8 gUnknown_8419EB0[] = _("じかんを さいせってい してください");
+const u8 gUnknown_8419EC3[] = _("じかんを さいせってい しました!\nレポ-トを かいています おまちください");
+const u8 gUnknown_8419EEA[] = _("レポ-トを かきこみました!");
+const u8 gUnknown_8419EF9[] = _("レポ-トの かきこみに\nしっぱい しました‥");
+const u8 gUnknown_8419F10[] = _("レポ-トが ないので\nじかんの せっていは できません!");
+const u8 gUnknown_8419F2D[] = _("ゲ-ムない じかんの しゅうせい システムが\nつかえる ように なりました!");
+const u8 gText_SavingDontTurnOffThePower2[] = _("SAVING…\nDON'T TURN OFF THE POWER.");
+
+// Start menu option descriptions
+const u8 gStartMenuDesc_Pokedex[] = _("A device that records POKéMON secrets\nupon meeting or catching them.");
+const u8 gStartMenuDesc_Pokemon[] = _("Check and organize POKéMON that are\ntraveling with you in your party.");
+const u8 gStartMenuDesc_Bag[] = _("Equipped with pockets for storing items\nyou bought, received, or found.");
+const u8 gStartMenuDesc_Player[] = _("Check your money and other game data.");
+const u8 gStartMenuDesc_Save[] = _("Save your game with a complete record\nof your progress to take a break.");
+const u8 gStartMenuDesc_Option[] = _("Adjust various game settings such as text\nspeed, game rules, etc.");
+const u8 gStartMenuDesc_Exit[] = _("Close this MENU window.");
+const u8 gStartMenuDesc_Retire[] = _("Retire from the SAFARI GAME and return to\nthe registration counter.");
+
+#include "data/text/quest_log.h"
+
+const u8 gUnknown_841B285[] = _(" was used on\n");
+const u8 gUnknown_841B293[] = _(".");
+const u8 gUnknown_841B295[] = _("'s level rose to\n");
+const u8 gUnknown_841B2A7[] = _(".");
+const u8 gUnknown_841B2A9[] = _("{SMALL}MAX.{SIZE 0x02} HP");
+const u8 gUnknown_841B2B7[] = _("ATTACK");
+const u8 gUnknown_841B2BE[] = _("DEFENSE");
+const u8 gUnknown_841B2C6[] = _("SPEED");
+const u8 gUnknown_841B2CC[] = _("SP. ATK");
+const u8 gUnknown_841B2D4[] = _("SP. DEF");
+const u8 gUnknown_841B2DC[] = _("{SMALL}{PLUS}{SIZE 0x02}");
+const u8 gUnknown_841B2E5[] = _("{SMALL}-{SIZE 0x02}");
+const u8 gUnknown_841B2ED[] = _("1, ");
+const u8 gUnknown_841B2F1[] = _("2, and ‥ ‥ ‥ ");
+const u8 gUnknown_841B2FF[] = _("Poof!\p");
+const u8 gUnknown_841B306[] = _("{DYNAMIC 0x00} forgot\n{DYNAMIC 0x01}.\p");
+const u8 gUnknown_841B315[] = _("And‥\p");
+const u8 gUnknown_841B31B[] = _("Machine set!\p");
+const u8 gUnknown_841B329[] = _("Huh?");
+const u8 gUnknown_841B32E[] = _("{DYNAMIC 0x00} learned\n{DYNAMIC 0x01}!");
+const u8 gText_Upper[] = _("UPPER");
+const u8 gText_Lower[] = _("lower");
+const u8 gText_Others[] = _("OTHERS");
+const u8 gText_Symbols[] = _("SYMBOLS");
+const u8 gText_Register2[] = _("REGISTER");
+const u8 gText_Exit[] = _("EXIT");
+const u8 gText_QuitChatting[] = _("Quit chatting?");
+const u8 gText_RegisterTextWhere[] = _("Register text where?");
+const u8 gText_RegisterTextHere[] = _("Register text here?");
+const u8 gText_InputText[] = _("Input text.");
+const u8 gText_F700JoinedChat[] = _("{DYNAMIC 0x00} joined the chat!");
+const u8 gText_F700LeftChat[] = _("{DYNAMIC 0x00} left the chat.");
+const u8 gUnknown_841B3D0[] = _("{DYNAMIC 0x00}の{DYNAMIC 0x01}ひきめ:");
+const u8 gUnknown_841B3DA[] = _("{DYNAMIC 0x00}の{DYNAMIC 0x01}ひきめは いません");
+const u8 gText_ExitingTheChat[] = _("Exiting the chat‥");
+const u8 gText_LeaderHasLeftEndingChat[] = _("The LEADER, {DYNAMIC 0x00}, has\nleft, ending the chat.");
+const u8 gText_RegisteredTextChanged_OKtoSave[] = _("The registered text has been changed.\nIs it okay to save the game?");
+const u8 gText_RegisteredTextChanged_AlreadySavedFile[] = _("There is already a saved file.\nIs it okay to overwrite it?");
+const u8 gText_RegisteredTextChanged_SavingDontTurnOff[] = _("SAVING‥\nDON'T TURN OFF THE POWER.");
+const u8 gText_RegisteredTextChanged_SavedTheGame[] = _("{DYNAMIC 0x00} saved the game.");
+const u8 gText_IfLeaderLeavesChatWillEnd[] = _("If the LEADER leaves, the chat\nwill end. Is that okay?");
+const u8 gText_Hello[] = _("HELLO");
+const u8 gText_Pokemon2[] = _("POKéMON");
+const u8 gText_Trade[] = _("TRADE");
+const u8 gText_Battle[] = _("BATTLE");
+const u8 gText_Lets[] = _("LET'S");
+const u8 gText_Ok[] = _("OK!");
+const u8 gText_Sorry[] = _("SORRY");
+const u8 gText_YaySmileEmoji[] = _("YAY{EXTRA 0xF9}");
+const u8 gText_ThankYou[] = _("THANK YOU");
+const u8 gText_ByeBye[] = _("BYE-BYE!");
+const u8 gUnknown_841B554[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p");
+const u8 gUnknown_841B5B6[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p");
+const u8 gUnknown_841B60E[] = _("PLAYER: {DYNAMIC 0x00}");
+const u8 gUnknown_841B619[] = _("This document is issued in\nrecognition of your magnificent\nachievement - the completion of\nthe {DYNAMIC 0x01} POKéDEX.");
+const u8 gUnknown_841B684[] = _("GAME FREAK");
+const u8 gUnknown_841B68F[] = _("NATIONAL");
+const u8 gUnknown_841B698[] = _("KANTO");
+const u8 gUnknown_841B69E[] = _("Clear all save data areas?");
+const u8 gUnknown_841B6B9[] = _("Clearing data‥\nPlease wait.");
+const u8 gText_Player[] = _("PLAYER");
+const u8 gText_Time[] = _("TIME");
+const u8 gText_Colon[] = _(":");
+const u8 gText_Pokedex[] = _("POKéDEX");
+const u8 gTextJPDummy_Hiki[] = _("");
+const u8 gText_Badges[] = _("BADGES");
+const u8 gTextJPDummy_Ko[] = _("");
+const u8 gText_Register[] = _("REGISTER");
+const u8 gText_HatchedFromEgg[] = _("{STR_VAR_1} hatched from the EGG!");
+const u8 gText_NickHatchPrompt[] = _("Would you like to nickname the newly\nhatched {STR_VAR_1}?");
+const u8 gString_OutOfCoins[] = _("You've run out of COINS.\nGame over!");
+const u8 gString_QuitPlaying[] = _("Quit playing?");
+const u8 gString_SlotMachineControls[] = _("{DPAD_LEFTRIGHT}COMBOS {DPAD_DOWN}WAGER {A_BUTTON}STOP {B_BUTTON}EXIT");
+const u8 gUnknown_841B798[] = _("おしえテレビ");
+const u8 gUnknown_841B79F[] = _("おしまい");
+
+#include "data/text/teachy_tv.h"
+
+const u8 gString_Bill[] = _("BILL");
+const u8 gString_Someone[] = _("SOMEONE");
+const u8 gString_Help[] = _("HELP");
+const u8 gString_HelpSystem_ClearTo8[] = _("{CLEAR_TO 8}");
+const u8 gText_SpacePoints2[] = _(" points");
+const u8 gText_SpaceTimes3[] = _(" time(s)");
+const u8 gText_PkmnJumpRecords[] = _("POKéMON JUMP RECORDS");
+const u8 gText_JumpsInARow[] = _("Jumps in a row:");
+const u8 gText_BestScore2[] = _("Best score:");
+const u8 gText_ExcellentsInARow[] = _("EXCELLENTS in a row:");
+const u8 gText_AwesomeWonF701F700[] = _("Awesome score! You've\nwon {DYNAMIC 01} {DYNAMIC 00}!");
+const u8 gText_FilledStorageSpace2[] = _("There's no room left now.");
+const u8 gText_CantHoldMore[] = _("You can't hold any more!");
+const u8 gText_WantToPlayAgain2[] = _("Want to play again?");
+const u8 gText_SomeoneDroppedOut2[] = _("Somebody dropped out.\nThe link will be canceled.");
+const u8 gText_SavingDontTurnOffPower[] = _("SAVING…\nDON'T TURN OFF THE POWER.");
+const u8 gText_CommunicationStandby4[] = _("Communication standby…");
+const u8 gText_SavingDontTurnOffPower2[] = _("SAVING...\nDON'T TURN OFF THE POWER."); // Unused
+const u8 gText_BerryPickingRecords[] = _("DODRIO BERRY-PICKING RECORDS");
+const u8 gText_BerriesPicked[] = _("BERRIES picked:");
+const u8 gText_BestScore[] = _("Best score:");
+const u8 gText_BerriesInRowFivePlayers[] = _("BERRIES picked in a row with\nfive players:");
+const u8 gText_BerryPickingResults[] = _("Announcing BERRY-PICKING results!");
+const u8 gText_10P30P50P50P[] = _("10P     30P     50P     {EXTRA 0xDD}50P");
+const u8 gText_AnnouncingRankings[] = _("Announcing rankings!");
+const u8 gText_AnnouncingPrizes[] = _("Announcing prizes!");
+const u8 gText_1Colon[] = _("1:");
+const u8 gText_2Colon[] = _("2:");
+const u8 gText_3Colon[] = _("3:");
+const u8 gText_4Colon[] = _("4:");
+const u8 gText_5Colon[] = _("5:");
+const u8 gText_FirstPlacePrize[] = _("The first-place winner gets\nthis {DYNAMIC 00}!");
+const u8 gText_CantHoldAnyMore[] = _("You can't hold any more...");
+const u8 gText_FilledStorageSpace[] = _("It filled its storage space.");
+const u8 gText_WantToPlayAgain[] = _("Want to play again?");
+const u8 gText_SomeoneDroppedOut[] = _("Somebody dropped out.\nThe link will be canceled.");
+const u8 gText_SpacePoints[] = _(" points");
+const u8 gText_CommunicationStandby3[] = _("Communication standby…");
+ALIGNED(4) const u8 gUnknown_841CE3C[] = _("Are you ready to BERRY-CRUSH?\nPlease pick a BERRY for use.\p");
+ALIGNED(4) const u8 gUnknown_841CE78[] = _("Please wait while each member\nchooses a BERRY.");
+ALIGNED(4) const u8 gUnknown_841CEA8[] = _("{PAUSE_MUSIC}{PLAY_BGM MUS_FANFA1}You ended up with {STR_VAR_1} units of\nsilky-smooth BERRY POWDER.{RESUME_MUSIC}\pYour total amount of BERRY POWDER\nis {STR_VAR_2}.\p");
+ALIGNED(4) const u8 gUnknown_841CF14[] = _("Recording your game results in the\nsave file.\nPlease wait.");
+ALIGNED(4) const u8 gUnknown_841CF50[] = _("Want to play BERRY CRUSH again?");
+ALIGNED(4) const u8 gUnknown_841CF70[] = _("You have no BERRIES.\nThe game will be canceled.");
+ALIGNED(4) const u8 gUnknown_841CFA0[] = _("A member dropped out.\nThe game will be canceled.");
+ALIGNED(4) const u8 gUnknown_841CFD4[] = _("Time's up.\pGood BERRY POWDER could not be\nmade…\p");
+ALIGNED(4) const u8 gUnknown_841D008[] = _("Communication standby…");
+ALIGNED(4) const u8 gText_1_ClrLtGryShdwBlk_Dynamic0[] = _("1. {COLOR LIGHT_GRAY}{SHADOW BLACK}{DYNAMIC 0x00}");
+const u8 gText_1_Dynamic0[] = _("1. {DYNAMIC 0x00}");
+ALIGNED(4) const u8 gText_SpaceTimes[] = _(" times");
+ALIGNED(4) const u8 gText_XDotY[] = _("{STR_VAR_1}.{STR_VAR_2}");
+ALIGNED(4) const u8 gText_StrVar1Berry[] = _("{STR_VAR_1} BERRY");
+ALIGNED(4) const u8 gText_TimeColon[] = _("Time:");
+ALIGNED(4) const u8 gText_PressingSpeed[] = _("Pressing Speed:");
+const u8 gText_Silkiness[] = _("Silkiness:");
+ALIGNED(4) const u8 gText_StrVar1[] = _("{STR_VAR_1}");
+ALIGNED(4) const u8 gText_SpaceMin[] = _("min.");
+ALIGNED(4) const u8 gText_XDotY2[] = _("{STR_VAR_1}.{STR_VAR_2}");
+ALIGNED(4) const u8 gText_SpaceSec[] = _("sec.");
+ALIGNED(4) const u8 gText_XDotY3[] = _("{STR_VAR_1}.{STR_VAR_2}");
+ALIGNED(4) const u8 gText_TimesPerSec[] = _("Times/sec.");
+ALIGNED(4) const u8 gText_Var1Percent[] = _("{STR_VAR_1}%");
+ALIGNED(4) const u8 gText_PressesRankings[] = _("No. of Presses Rankings");
+ALIGNED(4) const u8 gText_CrushingResults[] = _("Crushing Results");
+ALIGNED(4) const u8 gText_NeatnessRankings[] = _("Neatness Rankings");
+ALIGNED(4) const u8 gText_CooperativeRankings[] = _("Cooperative Rankings");
+ALIGNED(4) const u8 gText_PressingPowerRankings[] = _("Pressing-Power Rankings");
+const u8 gText_BerryCrush2[] = _("BERRY CRUSH");
+const u8 gText_PressingSpeedRankings[] = _("Pressing-Speed Rankings");
+const u8 gText_Var1Players[] = _("{STR_VAR_1} PLAYERS");
+ALIGNED(4) const u8 gText_Ghost[] = _("GHOST");
+const u8 gUnknown_841D14E[] = _("A POKéMON's on the hook!{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_841D169[] = _("Not even a nibble‥{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_841D17E[] = _("It got away‥{PAUSE_UNTIL_PRESS}");
+const u8 gUnknown_841D18D[] = _("ROOFTOP");
+ALIGNED(4) const u8 gString_PokemonFireRed_Staff[] = _("Pokémon FireRed Version\nStaff");
+ALIGNED(4) const u8 gString_PokemonLeafGreen_Staff[] = _("Pokémon LeafGreen Version\nStaff");
+ALIGNED(4) const u8 gCreditsString_Director[] = _("\n\nDirector\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Junichi_Masuda[] = _("\n\n\nJunichi Masuda\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Art_Director_Battle_Director[] = _("\nArt Director\n\nBattle Director\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Ken_Sugimori_Shigeki_Morimoto[] = _("\n\nKen Sugimori\n\nShigeki Morimoto\n\n");
+ALIGNED(4) const u8 gCreditsString_Program_Leader_Planning_Leader_Graphic_Design_Leader[] = _("Program Leader\n\nPlanning Leader\n\nGraphic Design Leader\n\n");
+ALIGNED(4) const u8 gCreditsString_Tetsuya_Watanabe_Koji_Nishino_Takao_Unno[] = _("\nTetsuya Watanabe\n\nKoji Nishino\n\nTakao Unno\n");
+ALIGNED(4) const u8 gCreditsString_Programmers[] = _("Programmers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hiroyuki_Nakamura_Masao_Taya_Satoshi_Nohara_Miyuki_Iwasawa_Daisuke_Goto[] = _("\nHiroyuki Nakamura\nMasao Taya\nSatoshi Nohara\nMiyuki Iwasawa\nDaisuke Goto\n");
+ALIGNED(4) const u8 gCreditsString_System_Programmers[] = _("System Programmers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Tetsuya_Watanabe_Akito_Mori_Hisashi_Sogabe_Sousuke_Tamada[] = _("\nTetsuya Watanabe\nAkito Mori\nHisashi Sogabe\nSousuke Tamada\n\n");
+ALIGNED(4) const u8 gCreditsString_Graphic_Designers[] = _("Graphic Designers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Takao_Unno_Asuka_Iwashita_Kanako_Eo_Hiroki_Fuchino[] = _("\nTakao Unno\nAsuka Iwashita\nKanako Eo\nHiroki Fuchino\n\n");
+ALIGNED(4) const u8 gCreditsString_Graphic_Designers_2[] = _("\nGraphic Designers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Ken_Sugimori_Hironobu_Yoshida[] = _("\n\nKen Sugimori\nHironobu Yoshida\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Music_Composition[] = _("\nMusic Composition\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Go_Ichinose_Junichi_Masuda[] = _("\n\nGo Ichinose\nJunichi Masuda\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Sound_Effects[] = _("\n\nSound Effects\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Go_Ichinose[] = _("\n\n\nGo Ichinose\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Game_Designers[] = _("\nGame Designers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Junichi_Masuda_Koji_Nishino_Tetsuji_Ohta[] = _("\n\nJunichi Masuda\nKoji Nishino\nTetsuji Ohta\n\n");
+ALIGNED(4) const u8 gCreditsString_Game_Designers_2[] = _("\nGame Designers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hitomi_Sato_Shigeru_Ohmori_Tadashi_Takahashi[] = _("\n\nHitomi Sato\nShigeru Ohmori\nTadashi Takahashi\n\n");
+ALIGNED(4) const u8 gCreditsString_Game_Scenario[] = _("\nGame Scenario\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hitomi_Sato_Satoshi_Tajiri[] = _("\n\nHitomi Sato\nSatoshi Tajiri\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Script_Designer_Map_Designer[] = _("\nScript Designer\n\nMap Designer\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Satoshi_Nohara_Shigeru_Ohmori[] = _("\n\nSatoshi Nohara\n\nShigeru Ohmori\n\n");
+ALIGNED(4) const u8 gCreditsString_Parametric_Designers[] = _("\nParametric Designers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Koji_Nishino_Tetsuji_Ohta_Shigeki_Morimoto[] = _("\n\nKoji Nishino\nTetsuji Ohta\nShigeki Morimoto\n\n");
+ALIGNED(4) const u8 gCreditsString_POKeDEX_Text[] = _("\n\nPOKéDEX Text\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Kenji_Matsushima[] = _("\n\n\nKenji Matsushima\n\n\n");
+ALIGNED(4) const u8 gCreditsString_POKeMON_Designers[] = _("POKéMON Designers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Ken_Sugimori_Motofumi_Fujiwara_Shigeki_Morimoto_Hironobu_Yoshida[] = _("\nKen Sugimori\nMotofumi Fujiwara\nShigeki Morimoto\nHironobu Yoshida\n\n");
+ALIGNED(4) const u8 gCreditsString_POKeMON_Designers_2[] = _("POKéMON Designers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Satoshi_Ohta_Asuka_Iwashita_Takao_Unno_Kanako_Eo_Aimi_Tomita[] = _("\nSatoshi Ohta\nAsuka Iwashita\nTakao Unno\nKanako Eo\nAimi Tomita\n");
+ALIGNED(4) const u8 gCreditsString_POKeMON_Designers_3[] = _("POKéMON Designers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Atsuko_Nishida_Muneo_Saito_Rena_Yoshikawa_Jun_Okutani[] = _("\nAtsuko Nishida\nMuneo Saito\nRena Yoshikawa\nJun Okutani\n\n");
+ALIGNED(4) const u8 gCreditsString_Supporting_Programmers[] = _("Supporting Programmers\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Teruyuki_Yoshioka_Takao_Nakano_Satoshi_Mitsuhara_Daisuke_Hoshino[] = _("\nTeruyuki Yoshioka\nTakao Nakano\n\nSatoshi Mitsuhara\nDaisuke Hoshino\n");
+ALIGNED(4) const u8 gCreditsString_NCL_Product_Testing[] = _("\n\nNCL Product Testing\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_NCL_Super_Mario_Club[] = _("\n\n\nNCL Super Mario Club\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Special_Thanks[] = _("Special Thanks\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hiro_Nakamura_Hiroyuki_Uesugi_Teruki_Murakawa_Kazuya_Suyama[] = _("\nHiro Nakamura\nHiroyuki Uesugi\nTeruki Murakawa\n\nKazuya Suyama\n");
+ALIGNED(4) const u8 gCreditsString_Special_Thanks_2[] = _("Special Thanks\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Kenji_Tominaga_Kenjiro_Ito_Tomotaka_Komura_Michiko_Takizawa[] = _("\nKenji Tominaga\n\nKenjiro Ito\nTomotaka Komura\nMichiko Takizawa\n");
+ALIGNED(4) const u8 gCreditsString_Special_Thanks_3[] = _("Special Thanks\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Makiko_Takada_Mikiko_Ohashi_Shusaku_Egami_Takanao_Kondo_Rui_Kawaguchi[] = _("\nMakiko Takada\nMikiko Ohashi\nShusaku Egami\nTakanao Kondo\nRui Kawaguchi\n");
+ALIGNED(4) const u8 gCreditsString_Braille_Code_Check[] = _("\n\nBraille Code Check\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Japan_Braille_Library[] = _("\n\n\nJapan Braille Library\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Information_Supervisors[] = _("Information Supervisors\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hiroki_Enomoto_Kazuyuki_Terada_Yuri_Sakurai_Yumi_Funasaka_Naoko_Yanase[] = _("\nHiroki Enomoto\nKazuyuki Terada\nYuri Sakurai\nYumi Funasaka\nNaoko Yanase\n");
+ALIGNED(4) const u8 gCreditsString_Coordinators[] = _("Coordinators\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Azusa_Tajima_Akira_Kinashi_Kazuki_Yoshihara_Retsuji_Nomoto[] = _("\nAzusa Tajima\nAkira Kinashi\nKazuki Yoshihara\n\nRetsuji Nomoto\n");
+ALIGNED(4) const u8 gCreditsString_Task_Managers[] = _("\nTask Managers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hitoshi_Yamagami_Gakuji_Nomoto[] = _("\n\nHitoshi Yamagami\nGakuji Nomoto\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Producers[] = _("\nProducers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hiroyuki_Jinnai_Takehiro_Izushi_Hiroaki_Tsuru[] = _("\n\nHiroyuki Jinnai\nTakehiro Izushi\nHiroaki Tsuru\n\n");
+ALIGNED(4) const u8 gCreditsString_Executive_Director[] = _("\n\nExecutive Director\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Satoshi_Tajiri[] = _("\n\n\nSatoshi Tajiri\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Executive_Producer[] = _("\n\nExecutive Producer\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Satoru_Iwata[] = _("\n\n\nSatoru Iwata\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Executive_Producer_2[] = _("\n\nExecutive Producer\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Tsunekaz_Ishihara[] = _("\n\n\nTsunekaz Ishihara\n\n\n");
+ALIGNED(4) const u8 gCreditsString_English_Version_Coordinators[] = _("\nEnglish Version Coordinators\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Hiro_Nakamura_Seth_McMahill[] = _("\n\nHiro Nakamura\nSeth McMahill\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Translator_Text_Editor[] = _("\nTranslator\n\nText Editor\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Nob_Ogasawara_Teresa_Lillygren[] = _("\n\nNob Ogasawara\n\nTeresa Lillygren\n\n");
+ALIGNED(4) const u8 gCreditsString_Programmers_2[] = _("Programmers\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Teruki_Murakawa_Souichi_Yamamoto_Yuichiro_Ito_Akira_Kinashi[] = _("\nTeruki Murakawa\nSouichi Yamamoto\nYuichiro Ito\nAkira Kinashi\n\n");
+ALIGNED(4) const u8 gCreditsString_Environment_Tool_Programmers[] = _("\nEnvironment & Tool Programmers\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Teruki_Murakawa_Souichi_Yamamoto_Kimiko_Nakamichi[] = _("\n\nTeruki Murakawa\nSouichi Yamamoto\nKimiko Nakamichi\n\n");
+ALIGNED(4) const u8 gCreditsString_NOA_Product_Testing[] = _("NOA Product Testing\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Thomas_Hertzog_Kathy_Huguenard_Mika_Kurosawa[] = _("\nThomas Hertzog\nKathy Huguenard\nMika Kurosawa\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Braille_Code_Check_2[] = _("Braille Code Check\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_National_Federation_of_the_Blind_Patricia_A_Maurer_Japan_Braille_Library_European_Blind_Union[] = _("\nNational Federation\n{CLEAR_TO 0x13}of the Blind\nPatricia A. Maurer\nJapan Braille Library\nEuropean Blind Union\n");
+ALIGNED(4) const u8 gCreditsString_Braille_Code_Check_3[] = _("\nBraille Code Check\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_National_Information_Library_Service_Margaret_Campion[] = _("\n\nNational Information Library\n{CLEAR_TO 0x2D}Service\nMargaret Campion\n\n");
+ALIGNED(4) const u8 gCreditsString_Special_Thanks_4[] = _("Special Thanks\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Takehiro_Izushi_Motoyasu_Tojima_Hitoshi_Yamagami_Hiroyuki_Uesugi[] = _("\nTakehiro Izushi\nMotoyasu Tojima\nHitoshi Yamagami\nHiroyuki Uesugi\n\n");
+ALIGNED(4) const u8 gCreditsString_Special_Thanks_5[] = _("Special Thanks\n\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Nicola_Pratt_Barlow_Shellie_Dow_Anthony_Howitt_Naoko_Saeki_Kyoko_Onishi[] = _("\nNicola Pratt-Barlow\nShellie Dow\nAnthony Howitt\nNaoko Saeki\nKyoko Onishi\n");
+ALIGNED(4) const u8 gCreditsString_Braille_Code_Check_4[] = _("\nBraille Code Check\n\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_The_Royal_New_Zealand_Foundation_of_the_Blind_Greg_Moran[] = _("\n\nThe Royal New Zealand\nFoundation of the Blind\nGreg Moran\n\n");
+ALIGNED(4) const u8 gCreditsString_Graphic_Designer[] = _("\n\nGraphic Designer\n\n\n\n");
+ALIGNED(4) const u8 gCreditsString_Akira_Kinashi[] = _("\n\n\nAkira Kinashi\n\n\n");
+const u8 gJPText_MysteryGift[] = _("");
+const u8 gJPText_DecideStop[] = _("");
+const u8 gJPText_ReceiveMysteryGiftWithEReader[] = _("");
+const u8 gJPText_SelectConnectFromEReaderMenu[] = _("");
+const u8 gJPText_SelectConnectWithGBA[] = _("");
+const u8 gJPText_SelectConnectAndPressA[] = _("カ-ドeリ-ダ-{PLUS}の ‘つうしん'を\nえらんで Aボタンを おしてください");
+const u8 gJPText_LinkIsIncorrect[] = _("");
+const u8 gJPText_CardReadingHasBeenHalted[] = _("");
+const u8 gJPText_UnableConnectWithEReader[] = _("カ-ドeリ-ダ-{PLUS}と\nつうしん できません");
+const u8 gJPText_Connecting[] = _("");
+const u8 gJPText_ConnectionErrorCheckLink[] = _("");
+const u8 gJPText_ConnectionErrorTryAgain[] = _("");
+const u8 gJPText_AllowEReaderToLoadCard[] = _("");
+const u8 gJPText_ConnectionComplete[] = _("");
+const u8 gJPText_NewTrainerHasComeToSevii[] = _("");
+const u8 gJPText_PleaseWaitAMoment[] = _("");
+const u8 gJPText_WriteErrorUnableToSaveData[] = _("");
+const u8 gText_CommErrorCheckConnections[] = _("Communication error…\nPlease check all connections,\nthen turn the power OFF and ON.");
+const u8 gText_CommErrorEllipsis[] = _("Communication error…");
+const u8 gText_MoveCloserToLinkPartner[] = _("Move closer to your link partner(s).\nAvoid obstacles between partners.");
+const u8 gText_ABtnRegistrationCounter[] = _("A Button: Registration Counter");
+const u8 gText_ABtnTitleScreen[] = _("A Button: Title Screen");
+const u8 gUnknown_841DF82[] = _("{STR_VAR_1}P LINK");
+const u8 gUnknown_841DF8B[] = _("BRONZE");
+const u8 gUnknown_841DF92[] = _("COPPER");
+const u8 gUnknown_841DF99[] = _("SILVER");
+const u8 gUnknown_841DFA0[] = _("GOLD");
+const u8 gUnknown_841DFA5[] = _("{A_BUTTON}NEXT");
+const u8 gUnknown_841DFAC[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}OK {B_BUTTON}END");
+const u8 gUnknown_841DFBE[] = _("{A_BUTTON}{B_BUTTON}CANCEL");
+const u8 gUnknown_841DFC9[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}OK {B_BUTTON}CANCEL");
+const u8 gEasyChatGroupName_Pokemon[] = _("POKéMON");
+const u8 gEasyChatGroupName_Trainer[] = _("TRAINER");
+const u8 gEasyChatGroupName_Status[] = _("STATUS");
+const u8 gEasyChatGroupName_Battle[] = _("BATTLE");
+const u8 gEasyChatGroupName_Greetings[] = _("GREETINGS");
+const u8 gEasyChatGroupName_People[] = _("PEOPLE");
+const u8 gEasyChatGroupName_Voices[] = _("VOICES");
+const u8 gEasyChatGroupName_Speech[] = _("SPEECH");
+const u8 gEasyChatGroupName_Endings[] = _("ENDINGS");
+const u8 gEasyChatGroupName_Feelings[] = _("FEELINGS");
+const u8 gEasyChatGroupName_Conditions[] = _("CONDITIONS");
+const u8 gEasyChatGroupName_Actions[] = _("ACTIONS");
+const u8 gEasyChatGroupName_Lifestyle[] = _("LIFESTYLE");
+const u8 gEasyChatGroupName_Hobbies[] = _("HOBBIES");
+const u8 gEasyChatGroupName_Time[] = _("TIME");
+const u8 gEasyChatGroupName_Misc[] = _("MISC.");
+const u8 gEasyChatGroupName_Adjectives[] = _("ADJECTIVES");
+const u8 gEasyChatGroupName_Events[] = _("EVENTS");
+const u8 gEasyChatGroupName_Move1[] = _("MOVE 1");
+const u8 gEasyChatGroupName_Move2[] = _("MOVE 2");
+const u8 gEasyChatGroupName_TrendySaying[] = _("TRENDY SAYING");
+const u8 gEasyChatGroupName_Pokemon2[] = _("POKéMON2");
+const u8 gText_ThreeQuestionMarks[] = _("???");
+const u8 gText_UnusedEmpty[] = _("");
+const u8 gText_UnusedLv[] = _("Lv");
+const u8 gText_UnusedDashes[] = _("---");
+const u8 gUnknown_841E09F[] = _("????");
+const u8 gText_UnusedEmpty2[] = _("");
+const u8 gUnknown_841E0A5[] = _("Is this trade okay?");
+const u8 gTradeText_Cancel[] = _("CANCEL");
+const u8 gTradeText_ChooseAPokemon[] = _("Choose a POKéMON.");
+const u8 gTradeText_Summary[] = _("SUMMARY");
+const u8 gTradeText_Trade[] = _("TRADE");
+const u8 gTradeText_CancelTrade[] = _("Cancel trade?");
+const u8 gTradeText_PressBButtonToExit[] = _("Press the B Button to exit.");
+const u8 gUnknown_841E10A[] = _("SUMMARY");
+const u8 gUnknown_841E112[] = _("TRADE");
+const u8 gUnknown_841E118[] = _("{COLOR RED}{HIGHLIGHT DARK_GREY}{SHADOW GREEN}Communication standby…\nPlease wait.");
+const u8 gUnknown_841E145[] = _("{COLOR RED}{HIGHLIGHT DARK_GREY}{SHADOW GREEN}The trade has been canceled.");
+const u8 gUnknown_841E16B[] = _("{COLOR RED}{HIGHLIGHT DARK_GREY}{SHADOW GREEN}That's your only POKéMON\nfor battle.");
+const u8 gUnknown_841E199[] = _("{COLOR RED}{HIGHLIGHT DARK_GREY}{SHADOW GREEN}Waiting for your friend\nto finish…");
+const u8 gUnknown_841E1C5[] = _("Your friend wants\nto trade POKéMON.");
+const u8 gText_XWillBeSentToY[] = _("{STR_VAR_2} will be\nsent to {STR_VAR_1}.");
+const u8 gText_ByeByeVar1[] = _("Bye-bye, {STR_VAR_2}!");
+const u8 gText_XSentOverY[] = _("{STR_VAR_1} sent over {STR_VAR_3}.");
+const u8 gText_TakeGoodCareOfX[] = _("Take good care of {STR_VAR_3}!");
+const u8 gText_From[] = _("From ");
+const u8 gUnknown_841E23A[] = _("");
+const u8 gUnknown_841E23B[] = _("");
+const u8 gUnknown_841E23C[] = _("");
+const u8 gUnknown_841E23D[] = _("");
+const u8 gUnknown_841E23E[] = _("");
+const u8 gUnknown_841E23F[] = _("");
+const u8 gUnknown_841E240[] = _("");
+const u8 gUnknown_841E241[] = _("");
+const u8 gUnknown_841E242[] = _("");
+const u8 gUnknown_841E243[] = _("");
+const u8 gUnknown_841E244[] = _("");
+const u8 gText_WirelessCommunicationStatus[] = _("Wireless Communication Status");
+const u8 gText_PeopleTrading[] = _("People trading:");
+const u8 gText_PeopleBattling[] = _("People battling:");
+const u8 gText_PeopleInUnionRoom[] = _("People in the UNION ROOM:");
+const u8 gText_PeopleCommunicating[] = _("People communicating:");
+const u8 gUnknown_841E2B4[] = _("{DYNAMIC 0x00} players");
+const u8 gUnknown_841E2BF[] = _("{DYNAMIC 0x01} player");
+const u8 gUnknown_841E2C9[] = _("{DYNAMIC 0x02} players");
+const u8 gUnknown_841E2D4[] = _("{DYNAMIC 0x03} players");
+const u8 gUnknown_841E2DF[] = _("{DPAD_ANY}えらぶ:{A_BUTTON}けってい");
+const u8 gUnknown_841E2EC[] = _("{B_BUTTON}CANCEL");
+const u8 gUnknown_841E2F5[] = _("{COLOR BLUE}{SHADOW YELLOW}   たいせんの くみあわせ\n{COLOR RED}{SHADOW GREEN}じぶんの ばしょをきめて ください");
+const u8 gUnknown_841E322[] = _("{ID}");
+const u8 gText_CommunicationStandby5[] = _("Communication standby…");
+const u8 gDaycareText_GetAlongVeryWell[] = _("The two seem to get along\nvery well.");
+const u8 gDaycareText_GetAlong[] = _("The two seem to get along.");
+const u8 gDaycareText_DontLikeOther[] = _("The two don't seem to like\neach other much.");
+const u8 gDaycareText_PlayOther[] = _("The two prefer to play with other\nPOKéMON than each other.");
+const u8 gText_TeachWhichMoveToMon[] = _("Teach which move to {STR_VAR_1}?");
+const u8 gText_TeachMoveQues[] = _("Teach {STR_VAR_2}?");
+const u8 gText_MonLearnedMove[] = _("{STR_VAR_1} learned\n{STR_VAR_2}.");
+const u8 gText_MonIsTryingToLearnMove[] = _("{STR_VAR_1} is trying to learn\n{STR_VAR_2}.\pBut {STR_VAR_1} can't learn more\nthan four moves.\pDelete an older move to make\nroom for {STR_VAR_2}?");
+const u8 gText_StopLearningMove[] = _("Stop learning {STR_VAR_2}?");
+const u8 gText_1_2_and_Poof[] = _("{PAUSE 0x20}1, {PAUSE 0x0F}2, and {PAUSE 0x0F}‥ {PAUSE 0x0F}‥ {PAUSE 0x0F}‥ {PAUSE 0x0F}{PLAY_SE SE_KON}Poof!\p");
+const u8 gText_MonForgotOldMoveAndMonLearnedNewMove[] = _("{STR_VAR_1} forgot {STR_VAR_3}.\pAnd‥\p{STR_VAR_1}\nlearned {STR_VAR_2}.");
+const u8 gText_GiveUpTryingToTeachNewMove[] = _("Give up trying to teach a new\nmove to {STR_VAR_1}?");
+const u8 gText_WhichMoveShouldBeForgotten[] = _("Which move should be forgotten?\p");
+const u8 gUnknown_841E52D[] = _("----------");
+const u8 gText_CommStandbyAwaitingOtherPlayer[] = _("Communication standby‥\nAwaiting another player to choose.");
+const u8 gText_BattleWasRefused[] = _("The battle was refused.{PAUSE 0x3C}");
+const u8 gText_RefusedBattle[] = _("Refused the battle.{PAUSE 0x3C}");
+const u8 gFameCheckerText_MainScreenUI[] = _("{START_BUTTON}PICK {DPAD_UPDOWN}SELECT {A_BUTTON}OK");
+const u8 gFameCheckerText_PickScreenUI[] = _("{START_BUTTON}PICK {DPAD_UPDOWN}SELECT {B_BUTTON}CANCEL");
+const u8 gFameCheckerText_FlavorTextUI[] = _("{DPAD_ANY}PICK {A_BUTTON}READ {B_BUTTON}CANCEL");
+const u8 gFameCheckerOakName[] = _("OAK");
+const u8 gFameCheckerDaisyName[] = _("DAISY");
+const u8 gFameCheckerBillName[] = _("BILL");
+const u8 gFameCheckerMrFujiName[] = _("FUJI");
+const u8 gText_VarietyOfEventsImportedWireless[] = _("A variety of events will be imported\nover Wireless Communication.");
+const u8 gText_WonderCardsInPossession[] = _("Read the WONDER CARDS in your\npossession.");
+const u8 gText_ReadNewsThatArrived[] = _("Read the NEWS that arrived.");
+const u8 gText_ReturnToTitle[] = _("Return to the title screen.");
+const u8 gText_DontHaveCardNewOneInput[] = _("You don't have a WONDER CARD,\nso a new CARD will be input.");
+const u8 gText_DontHaveNewsNewOneInput[] = _("You don't have any WONDER NEWS,\nso new NEWS will be input.");
+const u8 gText_WhereShouldCardBeAccessed[] = _("Where should the WONDER CARD\nbe accessed?");
+const u8 gText_WhereShouldNewsBeAccessed[] = _("Where should the WONDER NEWS\nbe accessed?");
+const u8 gUnknown_841E76B[] = _("Link standby...\n... ... B Button: Cancel");
+const u8 gText_Communicating[] = _("Communicating…");
+const u8 gText_CommunicationCompleted[] = _("Communication completed.");
+const u8 gText_CommunicationError[] = _("Communication error.");
+const u8 gText_CommunicationCanceled[] = _("Communication has been canceled.");
+const u8 gText_ThrowAwayWonderCard[] = _("Throw away the WONDER CARD\nand input a new CARD?");
+const u8 gText_HaventReceivedCardsGift[] = _("You haven't received the CARD's gift\nyet. Input a new CARD anyway?");
+const u8 gText_WonderCardReceivedFrom[] = _("A WONDER CARD has been received\nfrom {STR_VAR_1}.");
+const u8 gText_WonderNewsReceivedFrom[] = _("A WONDER NEWS item has been\nreceived from {STR_VAR_1}.");
+const u8 gText_WonderCardReceived[] = _("A new WONDER CARD has been\nreceived.");
+const u8 gText_WonderNewsReceived[] = _("A new WONDER NEWS item has been\nreceived.");
+const u8 gText_NewStampReceived[] = _("A new STAMP has been received.");
+const u8 gText_NewTrainerReceived[] = _("A new TRAINER has arrived.");
+const u8 gText_AlreadyHadCard[] = _("You already had that\nWONDER CARD.");
+const u8 gText_AlreadyHadNews[] = _("You already had that\nWONDER NEWS item.");
+const u8 gText_AlreadyHadStamp[] = _("You already had that\nSTAMP.");
+const u8 gText_NoMoreRoomForStamps[] = _("There's no more room for adding\nSTAMPS.");
+const u8 gText_RecordUploadedViaWireless[] = _("Your record has been uploaded via\nWIRELESS COMMUNICATION.");
+const u8 gText_CantAcceptCardFromTrainer[] = _("You can't accept a WONDER CARD\nfrom this TRAINER.");
+const u8 gText_CantAcceptNewsFromTrainer[] = _("You can't accept WONDER NEWS\nfrom this TRAINER.");
+const u8 gText_NothingSentOver[] = _("Nothing was sent over…");
+const u8 gText_WhatToDoWithCards[] = _("What would you like to do\nwith the WONDER CARDS?");
+const u8 gText_WhatToDoWithNews[] = _("What would you like to do\nwith the WONDER NEWS?");
+const u8 gText_SendingWonderCard[] = _("Sending your WONDER CARD…");
+const u8 gText_SendingWonderNews[] = _("Sending your WONDER NEWS item…");
+const u8 gText_WonderCardSentTo[] = _("Your WONDER CARD has been sent\nto {STR_VAR_1}.");
+const u8 gText_WonderNewsSentTo[] = _("Your WONDER NEWS item has been\nsent to {STR_VAR_1}.");
+const u8 gText_StampSentTo[] = _("A STAMP has been sent to {STR_VAR_1}.");
+const u8 gText_GiftSentTo[] = _("A GIFT has been sent to {STR_VAR_1}.");
+const u8 gText_OtherTrainerHasCard[] = _("The other TRAINER has the same\nWONDER CARD already.");
+const u8 gText_OtherTrainerHasNews[] = _("The other TRAINER has the same\nWONDER NEWS already.");
+const u8 gText_OtherTrainerHasStamp[] = _("The other TRAINER has the same\nSTAMP already.");
+const u8 gText_OtherTrainerCanceled[] = _("The other TRAINER canceled\ncommunication.");
+const u8 gText_CantSendGiftToTrainer[] = _("You can't send a MYSTERY GIFT to\nthis TRAINER.");
+const u8 gText_IfThrowAwayCardEventWontHappen[] = _("If you throw away the CARD,\nits event won't happen. Okay?");
+const u8 gText_OkayToDiscardNews[] = _("Is it okay to discard this\nNEWS item?");
+const u8 gText_HaventReceivedGiftOkayToDiscard[] = _("You haven't received the\nGIFT. Is it okay to discard?");
+const u8 gText_DataWillBeSaved[] = _("Data will be saved.\nPlease wait.");
+const u8 gText_SaveCompletedPressA[] = _("Save completed.\nPlease press the A Button.");
+const u8 gText_WonderCardThrownAway[] = _("The WONDER CARD was thrown away.");
+const u8 gText_WonderNewsThrownAway[] = _("The WONDER NEWS was thrown away.");
+const u8 gText_MysteryGift2[] = _("MYSTERY GIFT");
+const u8 gText_PickOKCancel[] = _("{DPAD_UPDOWN}PICK {A_BUTTON}OK {B_BUTTON}EXIT");
+const u8 gText_WonderCards[] = _("WONDER CARDS");
+const u8 gText_WonderNews[] = _("WONDER NEWS");
+const u8 gText_WirelessCommunication[] = _("WIRELESS COMMUNICATION");
+const u8 gText_Friend2[] = _("FRIEND");
+const u8 gText_Exit3[] = _("EXIT");
+const u8 gText_Receive[] = _("RECEIVE");
+const u8 gText_Send[] = _("SEND");
+const u8 gText_Toss[] = _("TOSS");
+const u8 gUnknown_841EE2B[] = _("DEL. ALL{CLEAR_TO 0x57}CANCEL{CLEAR_TO 0xA4}OK");
diff --git a/src/teachy_tv.c b/src/teachy_tv.c
index 1467131b0..1d49ee3d9 100644
--- a/src/teachy_tv.c
+++ b/src/teachy_tv.c
@@ -500,7 +500,7 @@ static void TeachyTvMainCallback(void)
         ScheduleBgCopyTilemapToVram(1);
         ScheduleBgCopyTilemapToVram(2);
         ScheduleBgCopyTilemapToVram(3);
-        HelpSystem_SetSomeVariable(9); // help system something
+        SetHelpContextDontCheckBattle(HELPCONTEXT_BAG);
         BlendPalettes(0xFFFFFFFF, 0x10, 0);
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, 0);
         SetVBlankCallback(TeachyTvVblankHandler);
diff --git a/src/text.c b/src/text.c
index 83f089c12..2d4d4a9b0 100644
--- a/src/text.c
+++ b/src/text.c
@@ -1,15 +1,11 @@
 #include "global.h"
 #include "main.h"
-#include "palette.h"
-#include "string_util.h"
 #include "window.h"
 #include "text.h"
 #include "sprite.h"
-#include "blit.h"
 #include "sound.h"
 #include "m4a.h"
 #include "quest_log.h"
-#include "window.h"
 #include "graphics.h"
 #include "dynamic_placeholder_text_util.h"
 #include "constants/songs.h"
diff --git a/src/text_window.c b/src/text_window.c
index 98f82e818..6fde39078 100644
--- a/src/text_window.c
+++ b/src/text_window.c
@@ -1,7 +1,6 @@
 #include "global.h"
 #include "bg.h"
 #include "palette.h"
-#include "text.h"
 #include "window.h"
 #include "text_window.h"
 #include "text_window_graphics.h"
diff --git a/src/tileset_anims.c b/src/tileset_anims.c
index 44e86448f..04e129049 100644
--- a/src/tileset_anims.c
+++ b/src/tileset_anims.c
@@ -1,10 +1,4 @@
 #include "global.h"
-#include "graphics.h"
-#include "palette.h"
-#include "util.h"
-#include "battle_transition.h"
-#include "task.h"
-#include "fieldmap.h"
 
 static EWRAM_DATA struct {
     const u16 *src;
@@ -232,7 +226,7 @@ static void sub_8070120(u16 timer)
         sub_80700A4(timer >> 4);
 }
 
-void sub_8070154(void)
+void InitTilesetAnim_General(void)
 {
     sPrimaryTilesetAnimCounter = 0;
     sPrimaryTilesetAnimCounterMax = 640;
@@ -250,7 +244,7 @@ static void sub_80701AC(u16 timer)
         sub_807017C(timer / 12);
 }
 
-void sub_80701D8(void)
+void InitTilesetAnim_CeladonCity(void)
 {
     sSecondaryTilesetAnimCounter = 0;
     sSecondaryTilesetAnimCounterMax = 120;
@@ -268,7 +262,7 @@ static void sub_8070224(u16 timer)
         sub_80701FC(timer / 10);
 }
 
-void sub_8070250(void)
+void InitTilesetAnim_SilphCo(void)
 {
     sSecondaryTilesetAnimCounter = 0;
     sSecondaryTilesetAnimCounterMax = 160;
@@ -286,7 +280,7 @@ static void sub_807029C(u16 timer)
         sub_8070274(timer >> 4);
 }
 
-void sub_80702B4(void)
+void InitTilesetAnim_MtEmber(void)
 {
     sSecondaryTilesetAnimCounter = 0;
     sSecondaryTilesetAnimCounterMax = 256;
@@ -306,7 +300,7 @@ static void sub_8070304(u16 timer)
         sub_80702DC(timer >> 1);
 }
 
-void sub_807031C(void)
+void InitTilesetAnim_VermilionGym(void)
 {
     sSecondaryTilesetAnimCounter = 0;
     sSecondaryTilesetAnimCounterMax = 240;
@@ -326,7 +320,7 @@ static void sub_8070368(u16 timer)
         sub_8070340(timer >> 4);
 }
 
-void sub_8070380(void)
+void InitTilesetAnim_CeladonGym(void)
 {
     sSecondaryTilesetAnimCounter = 0;
     sSecondaryTilesetAnimCounterMax = 256;
diff --git a/src/title_screen.c b/src/title_screen.c
index af78893b9..0ff0a6b96 100644
--- a/src/title_screen.c
+++ b/src/title_screen.c
@@ -575,7 +575,7 @@ static void SetTitleScreenScene_Run(s16 * data)
     switch (data[1])
     {
     case 0:
-        HelpSystem_SetSomeVariable2(1);
+        SetHelpContext(HELPCONTEXT_TITLE_SCREEN);
         CreateTask(Task_TitleScreen_BlinkPressStart, 0);
         CreateTask(Task_FlameOrLeafSpawner, 5);
         SetGpuRegsForTitleScreenRun();
diff --git a/src/tm_case.c b/src/tm_case.c
index d45061bde..2f27cc0db 100644
--- a/src/tm_case.c
+++ b/src/tm_case.c
@@ -25,7 +25,6 @@
 #include "scanline_effect.h"
 #include "sound.h"
 #include "strings.h"
-#include "tm_case.h"
 #include "menu_indicators.h"
 #include "constants/items.h"
 #include "constants/songs.h"
@@ -613,7 +612,7 @@ static void PrintListMenuCursorAt_WithColorIdx(u8 a0, u8 a1)
     }
     else
     {
-        AddTextPrinterParameterized_ColorByIndex(0, 2, gFameCheckerText_ListMenuCursor, 0, a0, 0, 0, 0, a1);
+        AddTextPrinterParameterized_ColorByIndex(0, 2, gText_SelectorArrow2, 0, a0, 0, 0, 0, a1);
     }
 }
 
@@ -798,7 +797,7 @@ static void Task_SelectTMAction_FromFieldBag(u8 taskId)
     Menu_InitCursor(sTMCaseDynamicResources->contextMenuWindowId, 2, 0, 2, GetFontAttribute(2, 1) + 2, sTMCaseDynamicResources->numMenuActions, 0);
     strbuf = Alloc(256);
     GetTMNumberAndMoveString(strbuf, gSpecialVar_ItemId);
-    StringAppend(strbuf, gText_IsSelected);
+    StringAppend(strbuf, gText_Var1IsSelected + 2); // +2 skips over the stringvar
     AddTextPrinterParameterized_ColorByIndex(2, 2, strbuf, 0, 2, 1, 0, 0, 1);
     Free(strbuf);
     if (itemid_is_unique(gSpecialVar_ItemId))
@@ -1304,7 +1303,7 @@ static void InitWindowTemplatesAndPals(void)
     LoadPalette(gTMCaseMainWindowPalette, 0xA0, 0x20);
     LoadPalette(sPal3Override, 0xF6, 0x04);
     LoadPalette(sPal3Override, 0xD6, 0x04);
-    sub_8107D38(0xc0, 0x01);
+    ListMenuLoadStdPalAt(0xc0, 0x01);
     for (i = 0; i < 9; i++)
         FillWindowPixelBuffer(i, 0x00);
     PutWindowTilemap(0);
diff --git a/src/trade.c b/src/trade.c
index fe5f53be9..30bfa8389 100644
--- a/src/trade.c
+++ b/src/trade.c
@@ -6,7 +6,6 @@
 #include "pokemon_icon.h"
 #include "graphics.h"
 #include "link.h"
-#include "load_save.h"
 #include "link_rfu.h"
 #include "cable_club.h"
 #include "data.h"
@@ -14,7 +13,6 @@
 #include "menu.h"
 #include "overworld.h"
 #include "battle_anim.h"
-#include "pokeball.h"
 #include "party_menu.h"
 #include "daycare.h"
 #include "event_data.h"
@@ -22,7 +20,6 @@
 #include "pokemon_summary_screen.h"
 #include "pokemon_storage_system.h"
 #include "new_menu_helpers.h"
-#include "trade.h"
 #include "trade_scene.h"
 #include "constants/songs.h"
 #include "constants/moves.h"
@@ -765,9 +762,9 @@ static void sub_804C728(void)
 
             if (gWirelessCommType)
             {
-                sub_800B1F4();
+                SetWirelessCommType1();
                 OpenLink();
-                sub_80FBB20();
+                LinkRfu_CreateIdleTask();
             }
             else
             {
@@ -810,14 +807,14 @@ static void sub_804C728(void)
     case 4:
         if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE)
         {
-            sub_80FBB4C();
+            LinkRfu_DestroyIdleTask();
             CalculatePlayerPartyCount();
             gMain.state++;
             sTradeMenuResourcesPtr->unk_A8 = 0;
             if (gWirelessCommType)
             {
                 sub_80FA484(TRUE);
-                sub_800AB9C();
+                PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             }
         }
         break;
@@ -1213,7 +1210,7 @@ static void sub_804D548(void)
         }
         else
         {
-            sub_800AA80(32);
+            Link_StartSend5FFFwithParam(32);
             sTradeMenuResourcesPtr->unk_6F = 13;
         }
     }
@@ -2004,11 +2001,11 @@ static void sub_804E908(void)
     {
         if (gWirelessCommType)
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         }
         else
         {
-            sub_800AA80(12);
+            Link_StartSend5FFFwithParam(12);
         }
 
         sTradeMenuResourcesPtr->unk_6F = 12;
@@ -2044,7 +2041,7 @@ static void sub_804E9C0(void)
 {
     if (!sub_80FA484(FALSE))
     {
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         sTradeMenuResourcesPtr->unk_6F = 13;
     }
 }
@@ -2740,30 +2737,30 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet)
     return FALSE;
 }
 
-int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet)
+int GetUnionRoomTradeMessageId(struct GFtgtGnameSub playerSub, struct GFtgtGnameSub partnerSub, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet)
 {
-    u8 r9 = a0.hasNationalDex;
-    u8 r4 = a0.isChampion;
-    u8 r10 = a1.hasNationalDex;
-    u8 r0 = a1.isChampion;
-    u8 r1 = a1.unk_01_2;
-    u8 r2;
+    u8 playerHasNationalDex = playerSub.hasNationalDex;
+    u8 playerIsChampion = playerSub.isChampion;
+    u8 partnerHasNationalDex = partnerSub.hasNationalDex;
+    u8 partnerIsChampion = partnerSub.isChampion;
+    u8 partnerVersion = partnerSub.version;
+    bool8 isNotFRLG;
 
-    if (r1 == VERSION_FIRE_RED || r1 == VERSION_LEAF_GREEN)
+    if (partnerVersion == VERSION_FIRE_RED || partnerVersion == VERSION_LEAF_GREEN)
     {
-        r2 = 0;
+        isNotFRLG = FALSE;
     }
     else
     {
-        r2 = 1;
+        isNotFRLG = TRUE;
     }
-    if (r2)
+    if (isNotFRLG)
     {
-        if (!r4)
+        if (!playerIsChampion)
         {
             return 8;
         }
-        else if (!r0)
+        else if (!partnerIsChampion)
         {
             return 9;
         }
@@ -2794,7 +2791,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1,
         return 3;
     }
 
-    if (!r9)
+    if (!playerHasNationalDex)
     {
         if (species1 == SPECIES_EGG)
         {
@@ -2812,7 +2809,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1,
         }
     }
 
-    if (!r10 && species1 > SPECIES_MEW)
+    if (!partnerHasNationalDex && species1 > SPECIES_MEW)
     {
         return 7;
     }
@@ -2820,11 +2817,11 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1,
     return 0;
 }
 
-int CanRegisterMonForTradingBoard(struct GFtgtGnameSub a0, u16 species, u16 a2, u8 a3)
+int CanRegisterMonForTradingBoard(struct GFtgtGnameSub playerSub, u16 species2, u16 species, u8 obedience)
 {
-    u8 canTradeEggAndNational = a0.hasNationalDex;
+    u8 canTradeEggAndNational = playerSub.hasNationalDex;
 
-    if (IsDeoxysOrMewUntradable(a2, a3))
+    if (IsDeoxysOrMewUntradable(species, obedience))
     {
         return 1;
     }
@@ -2834,12 +2831,12 @@ int CanRegisterMonForTradingBoard(struct GFtgtGnameSub a0, u16 species, u16 a2,
         return 0;
     }
 
-    if (species == SPECIES_EGG)
+    if (species2 == SPECIES_EGG)
     {
         return 2;
     }
 
-    if (species > SPECIES_MEW && species != SPECIES_EGG)
+    if (species2 > SPECIES_MEW && species2 != SPECIES_EGG)
     {
         return 1;
     }
diff --git a/src/trade_scene.c b/src/trade_scene.c
index b420cb196..d609a9b53 100644
--- a/src/trade_scene.c
+++ b/src/trade_scene.c
@@ -10,7 +10,6 @@
 #include "palette.h"
 #include "trade.h"
 #include "link.h"
-#include "librfu.h"
 #include "link_rfu.h"
 #include "text.h"
 #include "mevent.h"
@@ -31,7 +30,6 @@
 #include "quest_log.h"
 #include "help_system.h"
 #include "new_menu_helpers.h"
-#include "battle_interface.h"
 #include "pokedex.h"
 #include "save.h"
 #include "load_save.h"
@@ -41,7 +39,7 @@
 #include "constants/items.h"
 #include "constants/easy_chat.h"
 #include "constants/songs.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 #include "constants/moves.h"
 
 #define TAG_GLOW1_TILES      5550
@@ -948,13 +946,13 @@ static void TradeAnimInit_LoadGfx(void)
     DeactivateAllTextPrinters();
     // Doing the graphics load...
     DecompressAndLoadBgGfxUsingHeap(0, gBattleTextboxTiles, 0, 0, 0);
-    LZDecompressWram(gFile_graphics_interface_menu_map_tilemap, gDecompressionBuffer);
+    LZDecompressWram(gBattleTextboxTilemap, gDecompressionBuffer);
     CopyToBgTilemapBuffer(0, gDecompressionBuffer, BG_SCREEN_SIZE, 0);
     LoadCompressedPalette(gBattleTextboxPalette, 0x000, 0x20);
     InitWindows(gUnknown_826D1BC);
     // ... and doing the same load again
     DecompressAndLoadBgGfxUsingHeap(0, gBattleTextboxTiles, 0, 0, 0);
-    LZDecompressWram(gFile_graphics_interface_menu_map_tilemap, gDecompressionBuffer);
+    LZDecompressWram(gBattleTextboxTilemap, gDecompressionBuffer);
     CopyToBgTilemapBuffer(0, gDecompressionBuffer, BG_SCREEN_SIZE, 0);
     LoadCompressedPalette(gBattleTextboxPalette, 0x000, 0x20);
 }
@@ -2556,7 +2554,7 @@ static void sub_8053E8C(void)
         DrawTextOnTradeWindow(0, gStringVar4, 0);
         break;
     case 1:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         gMain.state = 100;
         sTradeData->timer = 0;
         break;
@@ -2594,7 +2592,7 @@ static void sub_8053E8C(void)
         }
         if (gWirelessCommType)
         {
-            sub_8144714(2, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
+            MEvent_RecordIdOfWonderCardSenderByEventType(2, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
         }
         SetContinueGameWarpStatusToDynamicWarp();
         sub_80DA3AC();
@@ -2641,7 +2639,7 @@ static void sub_8053E8C(void)
     case 41:
         if (sTradeData->timer == 0)
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             gMain.state = 42;
         }
         else
@@ -2660,7 +2658,7 @@ static void sub_8053E8C(void)
         if (++sTradeData->timer > 60)
         {
             gMain.state++;
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         }
         break;
     case 6:
@@ -2682,11 +2680,11 @@ static void sub_8053E8C(void)
         {
             if (gWirelessCommType && gMain.savedCallback == CB2_ReturnFromLinkTrade)
             {
-                sub_800AB9C();
+                PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             }
             else
             {
-                sub_800AAC0();
+                Link_TryStartSend5FFF();
             }
             gMain.state++;
         }
diff --git a/src/trainer_card.c b/src/trainer_card.c
index e4778f5ed..df116d379 100644
--- a/src/trainer_card.c
+++ b/src/trainer_card.c
@@ -14,7 +14,6 @@
 #include "event_data.h"
 #include "easy_chat.h"
 #include "money.h"
-#include "window.h"
 #include "strings.h"
 #include "string_util.h"
 #include "trainer_card.h"
@@ -22,7 +21,6 @@
 #include "pokedex.h"
 #include "pokemon_icon.h"
 #include "graphics.h"
-#include "pokemon_icon.h"
 #include "help_system.h"
 #include "trainer_pokemon_sprites.h"
 #include "new_menu_helpers.h"
@@ -31,15 +29,7 @@
 #include "constants/game_stat.h"
 #include "constants/vars.h"
 #include "constants/species.h"
-
-#define BADGE_COUNT 8
-
-// Trainer Card Types
-enum
-{
-    CARD_TYPE_FRLG,
-    CARD_TYPE_EMERALD,
-};
+#include "constants/facility_trainer_classes.h"
 
 // Trainer Card Strings
 enum
@@ -61,46 +51,43 @@ enum
 
 struct TrainerCardData
 {
-    /*0x0000*/ u8 taskState;
-    /*0x0001*/ u8 printState;
-    /*0x0002*/ u8 gfxLoadState;
-    /*0x0003*/ u8 bgPalLoadState;
-    /*0x0004*/ u8 var_4;
-    /*0x0005*/ bool8 isLink;
-    /*0x0006*/ u8 var_6;
-    /*0x0007*/ u8 var_7;
-    /*0x0008*/ u8 var_8;
-    /*0x0009*/ bool8 allowDMACopy;
-    /*0x000A*/ bool8 hasPokedex;
-    /*0x000B*/ bool8 hasHofResult;
-    /*0x000C*/ bool8 hasLinkResults;
-    /*0x000D*/ bool8 hasBattleTowerWins;
-    /*0x000E*/ u8 var_E;
-    /*0x000F*/ u8 var_F;
-    /*0x0010*/ bool8 hasTrades;
-    /*0x0011*/ bool8 hasBadge[BADGE_COUNT];
-    /*0x0019*/ u8 var_19[4][13];
-    /*0x004D*/ u8 strings[TRAINER_CARD_STRING_COUNT][70];
-    /*0x0395*/ u8 var_395;
-    /*0x0396*/ u16 monIconPals[0x30];
-    /*0x03F6*/ u8 var_3DB[0x60];
-    /*0x0456*/ s8 var_456;
-    /*0x0457*/ u8 cardType;
-    /*0x0458*/ void (*callback2)(void);
-    /*0x045C*/ struct TrainerCard trainerCard;
-    /*0x04BC*/ u16 var_4BC;
-    /*0x04BE*/ u8 var_4BE[0x4AE];
-    /*0x096C*/ u16 var_96C[0x258];
-    /*0x0E1C*/ u16 var_E1C;
-    /*0x0E1E*/ u8 unk_E1E[0x4AE];
-    /*0x12CC*/ u16 cardTiles[0x200];
-    /*0x16CC*/ u16 bgTiles[0x100];
-    /*0x18CC*/ u16 var_18CC[0x1180];
-    /*0x3BCC*/ u16 bgTilemap0[0x1000];
-    /*0x5BCC*/ u16 bgTilemap2[0x1000];
-    /*0x7BCC*/ u16 var_7BCC;
-    /*0x7BCE*/ bool8 var_7BCE;
-    /*0x7BCF*/ u8 language;
+    u8 mainState;
+    u8 printState;
+    u8 gfxLoadState;
+    u8 bgPalLoadState;
+    u8 flipDrawState;
+    bool8 isLink;
+    u8 timeColonBlinkTimer;
+    bool8 timeColonInvisible;
+    bool8 onBack;
+    bool8 allowDMACopy;
+    bool8 hasPokedex;
+    bool8 hasHofResult;
+    bool8 hasLinkResults;
+    bool8 hasBattleTowerWins;
+    bool8 var_E;
+    bool8 var_F;
+    bool8 hasTrades;
+    bool8 hasBadge[NUM_BADGES];
+    u8 easyChatProfile[TRAINER_CARD_PROFILE_LENGTH][13];
+    u8 strings[TRAINER_CARD_STRING_COUNT][70];
+    u8 var_395;
+    u16 monIconPals[16 * PARTY_SIZE];
+    s8 flipBlendY;
+    u8 cardType;
+    void (*callback2)(void);
+    struct TrainerCard trainerCard;
+    u16 frontTilemap[600];
+    u16 backTilemap[600];
+    u16 bgTilemap[600];
+    u8 badgeTiles[0x80 * NUM_BADGES];
+    u16 stickerTiles[0x100];
+    u16 cardTiles[0x1180];
+    u16 cardTilemapBuffer[0x1000];
+    u16 bgTilemapBuffer[0x1000];
+    u16 var_7BCC;
+    bool8 timeColonNeedDraw;
+    u8 language;
 }; /* size = 0x7BD0 */
 
 // RAM
@@ -126,84 +113,84 @@ static void TrainerCardNull(void);
 static void sub_8089C5C(void);
 static void sub_8089C80(void);
 static void sub_8089CA4(void);
-static void ResetTrainerCard(void);
+static void InitBgsAndWindows(void);
 static void SetTrainerCardCB2(void);
-static void sub_8089DA4(void);
-static bool8 PrintAllOnCardPage1(void);
-static bool8 PrintStringsOnCardPage2(void);
-static void sub_8089ECC(void);
-static void PrintNameOnCard(void);
+static void SetUpTrainerCardTask(void);
+static bool8 PrintAllOnCardFront(void);
+static bool8 PrintAllOnCardBack(void);
+static void BufferTextForCardBack(void);
+static void PrintNameOnCardFront(void);
 static void PrintIdOnCard(void);
 static void PrintMoneyOnCard(void);
 static u16 GetCaughtMonsCount(void);
 static void PrintPokedexOnCard(void);
 static void PrintTimeOnCard(void);
 static void PrintProfilePhraseOnCard(void);
-static void PrintNameOnCard2(void);
-static void sub_808A4FC(void);
-static void PrintHofTimeOnCard(void);
-static void PrintHofDebutStringOnCard(void);
-static void PrintLinkResultsNumsOnCard(void);
-static void PrintWinsLossesStringOnCard(void);
-static void PrintTradesNumOnCard(void);
+static void BufferNameForCardBack(void);
+static void PrintNameOnCardBack(void);
+static void BufferHofDebutTime(void);
+static void PrintHofDebutTimeOnCard(void);
+static void BufferLinkBattleResults(void);
+static void PrintLinkBattleResultsOnCard(void);
+static void BufferNumTrades(void);
 static void PrintTradesStringOnCard(void);
-static void PrintBerryCrushNumOnCard(void);
+static void BufferBerryCrushPoints(void);
 static void PrintBerryCrushStringOnCard(void);
-static void PrintUnionNumOnCard(void);
+static void BufferUnionRoomStats(void);
 static void PrintUnionStringOnCard(void);
-static void TrainerCard_PrintPokemonIconsOnCard(void);
-static void sub_808AB10(void);
-static void sub_808ABE0(void);
-static void TrainerCardLoadStickerPals(void);
-static void PutTrainerCardWindow(u8 windowId);
+static void PrintPokemonIconsOnCard(void);
+static void LoadMonIconGfx(void);
+static void PrintStickersOnCard(void);
+static void LoadStickerGfx(void);
+static void DrawTrainerCardWindow(u8 windowId);
 static bool8 SetTrainerCardBgsAndPals(void);
-static void LoadTrainerCardTilemap2(const u16* ptr);
-static void LoadTrainerCardTilemap0(const u16* ptr);
-static void TrainerCard_PrintStarsAndBadgesOnCard(void);
-static void sub_808B090(void);
-static void sub_808B180(void);
-static void sub_808B1D4(void);
-static bool8 sub_808B1FC(void);
-static void sub_808B21C(u8 taskId);
-static bool8 sub_808B254(struct Task* task);
-static bool8 sub_808B294(struct Task* task);
-static bool8 sub_808B3C4(struct Task* task);
-static bool8 sub_808B4D8(struct Task* task);
-static bool8 sub_808B540(struct Task* task);
-static bool8 sub_808B66C(struct Task *task);
-static void sub_808B774(void);
+static void DrawCardScreenBackground(const u16* ptr);
+static void DrawCardFrontOrBack(const u16* ptr);
+static void DrawStarsAndBadgesOnCard(void);
+static void DrawCardBackStats(void);
+static void BlinkTimeColon(void);
+static void FlipTrainerCard(void);
+static bool8 IsCardFlipTaskActive(void);
+static void Task_DoCardFlipTask(u8 taskId);
+static bool8 Task_BeginCardFlip(struct Task* task);
+static bool8 Task_AnimateCardFlipDown(struct Task* task);
+static bool8 Task_DrawFlippedCardSide(struct Task* task);
+static bool8 Task_SetCardFlipped(struct Task* task);
+static bool8 Task_AnimateCardFlipUp(struct Task* task);
+static bool8 Task_EndCardFlip(struct Task *task);
+static void InitTrainerCardData(void);
 static u8 GetCardType(void);
-static void sub_808B838(void);
+static void CreateTrainerCardTrainerPic(void);
 
 // Data
-static const u32 sTrainerCardStickers[] = INCBIN_U32("graphics/trainer_card/stickers.4bpp.lz");
-static const u32 sUnknown_83CC4DC[] = INCBIN_U32("graphics/trainer_card/unk_83CC4DC.bin");
-static const u32 sUnknown_83CC6F0[] = INCBIN_U32("graphics/trainer_card/unk_83CC6F0.bin");
-static const u32 sUnknown_83CC8A8[] = INCBIN_U32("graphics/trainer_card/unk_83CC8A8.bin");
-static const u32 sUnknown_83CC984[] = INCBIN_U32("graphics/trainer_card/unk_83CC984.bin");
-static const u32 sUnknown_83CCAB0[] = INCBIN_U32("graphics/trainer_card/unk_83CCAB0.bin");
-static const u32 sUnknown_83CCCA4[] = INCBIN_U32("graphics/trainer_card/unk_83CCCA4.bin");
-static const u32 sUnknown_83CCE30[] = INCBIN_U32("graphics/trainer_card/unk_83CCE30.bin");
-static const u32 sUnknown_83CCEC8[] = INCBIN_U32("graphics/trainer_card/unk_83CCEC8.bin");
-static const u16 sEmeraldTrainerCard1Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_1stars_pals.gbapal");
-static const u16 sFireRedTrainerCard1Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_1stars_pals.gbapal");
-static const u16 sEmeraldTrainerCard2Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_2stars_pals.gbapal");
-static const u16 sFireRedTrainerCard2Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_2stars_pals.gbapal");
-static const u16 sEmeraldTrainerCard3Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_3stars_pals.gbapal");
-static const u16 sFireRedTrainerCard3Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_3stars_pals.gbapal");
-static const u16 sEmeraldTrainerCard4Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_4stars_pals.gbapal");
-static const u16 sFireRedTrainerCard4Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_4stars_pals.gbapal");
-static const u16 sEmeraldTrainerCardFemaleBackground_Pal[] = INCBIN_U16("graphics/trainer_card/em_female_bg.gbapal");
-static const u16 sFireRedTrainerCardFemaleBackground_Pal[] = INCBIN_U16("graphics/trainer_card/fr_female_bg.gbapal");
-static const u16 sEmeraldTrainerCardBadges_Pal[] = INCBIN_U16("graphics/trainer_card/em_badges.gbapal");
-static const u16 sFireRedTrainerCardBadges_Pal[] = INCBIN_U16("graphics/trainer_card/fr_badges.gbapal");
-static const u16 sUnknown_83CD300[] = INCBIN_U16("graphics/trainer_card/unk_83CD300.gbapal");
+static const u32 sTrainerCardStickers_Gfx[] = INCBIN_U32("graphics/trainer_card/stickers.4bpp.lz");
+static const u32 sHoennTrainerCardFront_Tilemap[] = INCBIN_U32("graphics/trainer_card/front_hoenn.bin");
+static const u32 sKantoTrainerCardFront_Tilemap[] = INCBIN_U32("graphics/trainer_card/front.bin");
+static const u32 sHoennTrainerCardBack_Tilemap[] = INCBIN_U32("graphics/trainer_card/back_hoenn.bin");
+static const u32 sKantoTrainerCardBack_Tilemap[] = INCBIN_U32("graphics/trainer_card/back.bin");
+static const u32 sHoennTrainerCardFrontLink_Tilemap[] = INCBIN_U32("graphics/trainer_card/front_hoenn_link.bin");
+static const u32 sKantoTrainerCardFrontLink_Tilemap[] = INCBIN_U32("graphics/trainer_card/front_link.bin");
+static const u32 sHoennTrainerCardBg_Tilemap[] = INCBIN_U32("graphics/trainer_card/bg_hoenn.bin");
+static const u32 sKantoTrainerCardBg_Tilemap[] = INCBIN_U32("graphics/trainer_card/bg.bin");
+static const u16 sHoennTrainerCard1Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_1stars_pals.gbapal");
+static const u16 sKantoTrainerCard1Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_1stars_pals.gbapal");
+static const u16 sHoennTrainerCard2Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_2stars_pals.gbapal");
+static const u16 sKantoTrainerCard2Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_2stars_pals.gbapal");
+static const u16 sHoennTrainerCard3Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_3stars_pals.gbapal");
+static const u16 sKantoTrainerCard3Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_3stars_pals.gbapal");
+static const u16 sHoennTrainerCard4Stars_Pals[] = INCBIN_U16("graphics/trainer_card/em_4stars_pals.gbapal");
+static const u16 sKantoTrainerCard4Stars_Pals[] = INCBIN_U16("graphics/trainer_card/fr_4stars_pals.gbapal");
+static const u16 sHoennTrainerCardFemaleBackground_Pal[] = INCBIN_U16("graphics/trainer_card/em_female_bg.gbapal");
+static const u16 sKantoTrainerCardFemaleBackground_Pal[] = INCBIN_U16("graphics/trainer_card/fr_female_bg.gbapal");
+static const u16 sHoennTrainerCardBadges_Pal[] = INCBIN_U16("graphics/trainer_card/em_badges.gbapal");
+static const u16 sKantoTrainerCardBadges_Pal[] = INCBIN_U16("graphics/trainer_card/fr_badges.gbapal");
+static const u16 sTrainerCardGold_Pal[] = INCBIN_U16("graphics/trainer_card/gold.gbapal");
 static const u16 sTrainerCardStickerPal1[] = INCBIN_U16("graphics/trainer_card/sticker1.gbapal");
 static const u16 sTrainerCardStickerPal2[] = INCBIN_U16("graphics/trainer_card/sticker2.gbapal");
 static const u16 sTrainerCardStickerPal3[] = INCBIN_U16("graphics/trainer_card/sticker3.gbapal");
 static const u16 sTrainerCardStickerPal4[] = INCBIN_U16("graphics/trainer_card/sticker4.gbapal");
-static const u32 sEmeraldTrainerCardBadges_Tile[] = INCBIN_U32("graphics/trainer_card/em_badges.4bpp.lz");
-static const u32 sFireRedTrainerCardBadges_Tile[] = INCBIN_U32("graphics/trainer_card/badges.4bpp.lz");
+static const u32 sHoennTrainerCardBadges_Gfx[] = INCBIN_U32("graphics/trainer_card/em_badges.4bpp.lz");
+static const u32 sKantoTrainerCardBadges_Gfx[] = INCBIN_U32("graphics/trainer_card/badges.4bpp.lz");
 
 static const struct BgTemplate sTrainerCardBgTemplates[4] = 
 {
@@ -277,150 +264,190 @@ static const struct WindowTemplate sTrainerCardWindowTemplates[4] =
     DUMMY_WIN_TEMPLATE
 };
 
-static const u16 *const sEmeraldTrainerCardStarPals[] =
+static const u16 *const sHoennTrainerCardStarPals[] =
 {
-    gEmeraldTrainerCard_Pal,
-    sEmeraldTrainerCard1Stars_Pals,
-    sEmeraldTrainerCard2Stars_Pals,
-    sEmeraldTrainerCard3Stars_Pals,
-    sEmeraldTrainerCard4Stars_Pals
+    gHoennTrainerCard_Pal,
+    sHoennTrainerCard1Stars_Pals,
+    sHoennTrainerCard2Stars_Pals,
+    sHoennTrainerCard3Stars_Pals,
+    sHoennTrainerCard4Stars_Pals
 };
 
-static const u16 *const sFireRedTrainerCardStarPals[] =
+static const u16 *const sKantoTrainerCardStarPals[] =
 {
-    gFireRedTrainerCard_Pal,
-    sFireRedTrainerCard1Stars_Pals,
-    sFireRedTrainerCard2Stars_Pals,
-    sFireRedTrainerCard3Stars_Pals,
-    sFireRedTrainerCard4Stars_Pals
+    gKantoTrainerCard_Pal,
+    sKantoTrainerCard1Stars_Pals,
+    sKantoTrainerCard2Stars_Pals,
+    sKantoTrainerCard3Stars_Pals,
+    sKantoTrainerCard4Stars_Pals
 };
 
-static const u8 sFireRedTrainerCardPage1TextColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY};
-static const u8 sTrainerCardPage2TextColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_RED, TEXT_COLOR_LIGHT_RED};
-static const u8 sEmeraldTrainerCardPage1TextColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_TRANSPARENT};
+static const u8 sTrainerCardTextColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY};
+static const u8 sTrainerCardStatColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_RED, TEXT_COLOR_LIGHT_RED};
+static const u8 sTimeColonInvisibleTextColors[] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_TRANSPARENT, TEXT_COLOR_TRANSPARENT};
 static const u8 sTrainerCardFontIds[] = {0, 2, 0};
 
-static const u8 sTrainerCardPicPositions[][2][2] = 
+static const u8 sTrainerPicOffsets[2][GENDER_COUNT][2] = 
 {
-    {{13, 4}, {13, 4}},
-    {{1, 0}, {1, 0}}
+    // Kanto
+    {
+        [MALE]   = {13, 4}, 
+        [FEMALE] = {13, 4}
+    },
+    // Hoenn
+    {
+        [MALE]   = {1, 0}, 
+        [FEMALE] = {1, 0}
+    }
 };
 
-static const u8 sLinkTrainerCardFrontPics[][2] = 
+static const u8 sTrainerPicFacilityClasses[][2] = 
 {
-    {TRAINER_PIC_RS_MAY_2, TRAINER_PIC_RED},
-    {TRAINER_PIC_PROFESSOR_OAK, TRAINER_PIC_RS_BRENDAN_2},
+    [CARD_TYPE_FRLG] = 
+    {
+        [MALE]   = FACILITY_CLASS_RED, 
+        [FEMALE] = FACILITY_CLASS_LEAF
+    },
+    [CARD_TYPE_RSE] = 
+    {
+        [MALE]   = FACILITY_CLASS_BRENDAN, 
+        [FEMALE] = FACILITY_CLASS_MAY
+    },
 };
 
-static const u8 sLinkTrainerCardFacilityClasses[][8] = 
+static const u8 sLinkTrainerPicFacilityClasses[GENDER_COUNT][NUM_LINK_TRAINER_CARD_CLASSES] = 
 {
-    {0x74, 0x6F, 0x5C, 0x58, 0x6A, 0x59, 0x6D, 0x6C},
-    {0x75, 0x7D, 0x5D, 0x5A, 0x16, 0x30, 0x41, 0x68}
+    [MALE] = 
+    {
+        FACILITY_CLASS_COOLTRAINER_3, 
+        FACILITY_CLASS_BLACK_BELT_2, 
+        FACILITY_CLASS_CAMPER_2, 
+        FACILITY_CLASS_YOUNGSTER_2, 
+        FACILITY_CLASS_PSYCHIC_3, 
+        FACILITY_CLASS_BUG_CATCHER_2, 
+        FACILITY_CLASS_TAMER, 
+        FACILITY_CLASS_JUGGLER
+    },
+    [FEMALE] = 
+    {
+        FACILITY_CLASS_COOLTRAINER_4,
+        FACILITY_CLASS_CHANNELER, 
+        FACILITY_CLASS_PICNICKER_2, 
+        FACILITY_CLASS_LASS_2, 
+        FACILITY_CLASS_PSYCHIC_2, 
+        FACILITY_CLASS_BATTLE_GIRL, 
+        FACILITY_CLASS_PKMN_BREEDER_2, 
+        FACILITY_CLASS_BEAUTY_2
+    }
 };
 
-static bool8 (*const sTrainerCardTasks[])(struct Task *) = 
+static bool8 (*const sTrainerCardFlipTasks[])(struct Task *) = 
 {
-    sub_808B254,
-    sub_808B294,
-    sub_808B3C4,
-    sub_808B4D8,
-    sub_808B540,
-    sub_808B66C
+    Task_BeginCardFlip,
+    Task_AnimateCardFlipDown,
+    Task_DrawFlippedCardSide,
+    Task_SetCardFlipped,
+    Task_AnimateCardFlipUp,
+    Task_EndCardFlip
 };
 
-static const u8 sTrainerCardPlayerNameXPositions[] = {0x14, 0x10};
-static const u8 sTrainerCardPlayerNameYPositions[] = {0x1D, 0x21};
+static const u8 sTrainerCardFrontNameXPositions[] = {0x14, 0x10};
+static const u8 sTrainerCardFrontNameYPositions[] = {0x1D, 0x21};
 static const u8 sTrainerCardIdXPositions[] = {0x8E, 0x80};
 static const u8 sTrainerCardIdYPositions[] = {0xA, 0x9};
-static const u8 *const sTrainerCardTextColors[] = {sFireRedTrainerCardPage1TextColors, sEmeraldTrainerCardPage1TextColors};
+static const u8 *const sTimeColonTextColors[] = {sTrainerCardTextColors, sTimeColonInvisibleTextColors};
 static const u8 sTrainerCardTimeHoursXPositions[] = {0x65, 0x55};
 static const u8 sTrainerCardTimeHoursYPositions[] = {0x77, 0x67};
 static const u8 sTrainerCardTimeMinutesXPositions[] = {0x7C, 0x6C};
 static const u8 sTrainerCardTimeMinutesYPositions[] = {0x58, 0x59};
 static const u8 sTrainerCardProfilePhraseXPositions[] = {0x73, 0x69};
 static const u8 sTrainerCardProfilePhraseYPositions[] = {0x82, 0x78};
-static const u8 sUnknown_83CD93C[] = {0x8A, 0xD8};
-static const u8 sUnknown_83CD93E[] = {0xB, 0xA};
+static const u8 sTrainerCardBackNameXPositions[] = {0x8A, 0xD8};
+static const u8 sTrainerCardBackNameYPositions[] = {0xB, 0xA};
 static const u8 sTrainerCardHofDebutXPositions[] = {0xA, 0x10, 0x0, 0x0};
 static const u8 *const sLinkTrainerCardRecordStrings[] = {gText_LinkBattles, gText_LinkCableBattles};
-static const u8 sUnknown_83CD94C[] = {5, 6, 7, 8, 9, 10};
-static const u8 sUnknown_83CD952[] = {0, 4, 8, 12, 16, 20};
-static const u8 sUnknown_83CD958[] = {11, 12, 13, 14};
-static const u8 sUnknown_83CD95C[] = {7, 6, 0, 0};
+static const u8 sPokemonIconPalSlots[] = {5, 6, 7, 8, 9, 10};
+static const u8 sPokemonIconXOffsets[] = {0, 4, 8, 12, 16, 20};
+static const u8 sStickerPalSlots[] = {11, 12, 13, 14};
+static const u8 sStarYOffsets[] = {7, 6, 0, 0};
 
 static const struct TrainerCard sLinkPlayerTrainerCardTemplate1 = 
 {
-    .gender = MALE,
-    .stars = 4,
-    .hasPokedex = TRUE,
-    .caughtAllHoenn = TRUE,
-    .hasAllPaintings = TRUE,
-    .hofDebutHours = 999,
-    .hofDebutMinutes = 59,
-    .hofDebutSeconds = 59,
-    .caughtMonsCount = 200,
-    .trainerId = 0x6072,
-    .playTimeHours = 999,
-    .playTimeMinutes = 59,
-    .linkBattleWins = 5535,
-    .linkBattleLosses = 5535,
-    .battleTowerWins = 5535,
-    .battleTowerStraightWins = 5535,
-    .contestsWithFriends = 55555,
-    .pokeblocksWithFriends = 44444,
-    .pokemonTrades = 33333,
-    .money = 999999,
-    .var_28 = {0, 0, 0, 0},
-    .playerName = _("あかみ どりお"),
+    .rse = {
+        .gender = MALE,
+        .stars = 4,
+        .hasPokedex = TRUE,
+        .caughtAllHoenn = TRUE,
+        .hasAllPaintings = TRUE,
+        .hofDebutHours = 999,
+        .hofDebutMinutes = 59,
+        .hofDebutSeconds = 59,
+        .caughtMonsCount = 200,
+        .trainerId = 0x6072,
+        .playTimeHours = 999,
+        .playTimeMinutes = 59,
+        .linkBattleWins = 5535,
+        .linkBattleLosses = 5535,
+        .battleTowerWins = 5535,
+        .battleTowerStraightWins = 5535,
+        .contestsWithFriends = 55555,
+        .pokeblocksWithFriends = 44444,
+        .pokemonTrades = 33333,
+        .money = 999999,
+        .easyChatProfile = {0, 0, 0, 0},
+        .playerName = _("あかみ どりお")
+    },
     .version = VERSION_FIRE_RED,
-    .var_3A = 0,
+    .hasAllFrontierSymbols = FALSE,
     .berryCrushPoints = 5555,
     .unionRoomNum = 8500,
     .berriesPicked = 5456,
     .jumpsInRow = 6300,
-    .var_4C = TRUE,
+    .shouldDrawStickers = TRUE,
     .hasAllMons = TRUE,
-    .var_4E = 2,
-    .var_4F = 0,
-    .var_50 = {1, 2, 3, 0},
+    .monIconTint = MON_ICON_TINT_PINK,
+    .facilityClass = 0,
+    .stickers = {1, 2, 3},
     .monSpecies = {SPECIES_CHARIZARD, SPECIES_DIGLETT, SPECIES_NIDORINA, SPECIES_FEAROW, SPECIES_PARAS, SPECIES_SLOWBRO}
 };
 
 static const struct TrainerCard sLinkPlayerTrainerCardTemplate2 = 
 {
-    .gender = FEMALE,
-    .stars = 2,
-    .hasPokedex = TRUE,
-    .caughtAllHoenn = TRUE,
-    .hasAllPaintings = TRUE,
-    .hofDebutHours = 999,
-    .hofDebutMinutes = 59,
-    .hofDebutSeconds = 59,
-    .caughtMonsCount = 200,
-    .trainerId = 0x6072,
-    .playTimeHours = 999,
-    .playTimeMinutes = 59,
-    .linkBattleWins = 5535,
-    .linkBattleLosses = 5535,
-    .battleTowerWins = 65535,
-    .battleTowerStraightWins = 65535,
-    .contestsWithFriends = 55555,
-    .pokeblocksWithFriends = 44444,
-    .pokemonTrades = 33333,
-    .money = 999999,
-    .var_28 = {0, 0, 0, 0},
-    .playerName = _("るびさふぁこ！"),
+    .rse = {
+        .gender = FEMALE,
+        .stars = 2,
+        .hasPokedex = TRUE,
+        .caughtAllHoenn = TRUE,
+        .hasAllPaintings = TRUE,
+        .hofDebutHours = 999,
+        .hofDebutMinutes = 59,
+        .hofDebutSeconds = 59,
+        .caughtMonsCount = 200,
+        .trainerId = 0x6072,
+        .playTimeHours = 999,
+        .playTimeMinutes = 59,
+        .linkBattleWins = 5535,
+        .linkBattleLosses = 5535,
+        .battleTowerWins = 65535,
+        .battleTowerStraightWins = 65535,
+        .contestsWithFriends = 55555,
+        .pokeblocksWithFriends = 44444,
+        .pokemonTrades = 33333,
+        .money = 999999,
+        .easyChatProfile = {0, 0, 0, 0},
+        .playerName = _("るびさふぁこ！")
+    },
     .version = 0,
-    .var_3A = 0,
+    .hasAllFrontierSymbols = FALSE,
     .berryCrushPoints = 555,
     .unionRoomNum = 500,
     .berriesPicked = 456,
     .jumpsInRow = 300,
-    .var_4C = TRUE,
+    .shouldDrawStickers = TRUE,
     .hasAllMons = TRUE,
-    .var_4E = 2,
-    .var_4F = 0,
-    .var_50 = {1, 2, 3, 0},
+    .monIconTint = MON_ICON_TINT_PINK,
+    .facilityClass = 0,
+    .stickers = {1, 2, 3},
     .monSpecies = {SPECIES_CHARIZARD, SPECIES_DIGLETT, SPECIES_NIDORINA, SPECIES_FEAROW, SPECIES_PARAS, SPECIES_SLOWBRO}
 };
 
@@ -430,7 +457,7 @@ static void VBlankCB_TrainerCard(void)
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
-    sub_808B180();
+    BlinkTimeColon();
     if (sTrainerCardDataPtr->allowDMACopy)
         DmaCopy16(3, &gScanlineEffectRegBuffers[0], &gScanlineEffectRegBuffers[1], 0x140);
 }
@@ -463,43 +490,54 @@ static void CloseTrainerCard(u8 taskId)
     DestroyTask(taskId);
 }
 
+// States for Task_TrainerCard. Skips the initial states, which are done once in order
+#define STATE_HANDLE_INPUT_FRONT  10
+#define STATE_HANDLE_INPUT_BACK   11
+#define STATE_WAIT_FLIP_TO_BACK   12
+#define STATE_WAIT_FLIP_TO_FRONT  13
+#define STATE_CLOSE_CARD          14
+#define STATE_WAIT_LINK_PARTNER   15
+#define STATE_CLOSE_CARD_LINK     16
+
 static void Task_TrainerCard(u8 taskId)
 {
-    switch (sTrainerCardDataPtr->taskState)
+    switch (sTrainerCardDataPtr->mainState)
     {
+    // Draw card initially
     case 0:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
             FillWindowPixelBuffer(1, PIXEL_FILL(0));
-            sTrainerCardDataPtr->taskState++;
+            sTrainerCardDataPtr->mainState++;
         }
         break;
     case 1:
-        if (PrintAllOnCardPage1())
-            sTrainerCardDataPtr->taskState++;
+        if (PrintAllOnCardFront())
+            sTrainerCardDataPtr->mainState++;
         break;
     case 2:
-        PutTrainerCardWindow(1);
-        sTrainerCardDataPtr->taskState++;
+        DrawTrainerCardWindow(1);
+        sTrainerCardDataPtr->mainState++;
         break;
     case 3:
         FillWindowPixelBuffer(2, PIXEL_FILL(0));
-        sub_808B838();
-        PutTrainerCardWindow(2);
-        sTrainerCardDataPtr->taskState++;
+        CreateTrainerCardTrainerPic();
+        DrawTrainerCardWindow(2);
+        sTrainerCardDataPtr->mainState++;
         break;
     case 4:
-        LoadTrainerCardTilemap2(&sTrainerCardDataPtr->var_E1C);
-        sTrainerCardDataPtr->taskState++;
+        DrawCardScreenBackground(sTrainerCardDataPtr->bgTilemap);
+        sTrainerCardDataPtr->mainState++;
         break;
     case 5:
-        LoadTrainerCardTilemap0(&sTrainerCardDataPtr->var_4BC);
-        sTrainerCardDataPtr->taskState++;
+        DrawCardFrontOrBack(sTrainerCardDataPtr->frontTilemap);
+        sTrainerCardDataPtr->mainState++;
         break;
     case 6:
-        TrainerCard_PrintStarsAndBadgesOnCard();
-        sTrainerCardDataPtr->taskState++;
+        DrawStarsAndBadgesOnCard();
+        sTrainerCardDataPtr->mainState++;
         break;
+    // Fade in
     case 7:
         if (gWirelessCommType == 1 && gReceivedRemoteLinkPlayers == TRUE)
         {
@@ -508,71 +546,72 @@ static void Task_TrainerCard(u8 taskId)
         }
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
         SetVBlankCallback(VBlankCB_TrainerCard);
-        sTrainerCardDataPtr->taskState++;
+        sTrainerCardDataPtr->mainState++;
         break;
     case 8:
         if (!UpdatePaletteFade() && !IsDma3ManagerBusyWithBgCopy())
         {
             PlaySE(SE_CARD3);
-            sTrainerCardDataPtr->taskState = 10;
+            sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_FRONT;
         }
         break;
     case 9:
         if (!IsSEPlaying())
-            sTrainerCardDataPtr->taskState++;
+            sTrainerCardDataPtr->mainState++;
         break;
-    case 10:
-        if (!gReceivedRemoteLinkPlayers && sTrainerCardDataPtr->var_7BCE)
+    case STATE_HANDLE_INPUT_FRONT:
+        // Blink the : in play time
+        if (!gReceivedRemoteLinkPlayers && sTrainerCardDataPtr->timeColonNeedDraw)
         {
             PrintTimeOnCard();
-            PutTrainerCardWindow(1);
-            sTrainerCardDataPtr->var_7BCE = FALSE;
+            DrawTrainerCardWindow(1);
+            sTrainerCardDataPtr->timeColonNeedDraw = FALSE;
         }
 
         if (JOY_NEW(A_BUTTON))
         {
-            HelpSystem_SetSomeVariable2(11);
-            sub_808B1D4();
+            SetHelpContext(HELPCONTEXT_TRAINER_CARD_BACK);
+            FlipTrainerCard();
             PlaySE(SE_CARD1);
-            sTrainerCardDataPtr->taskState = 12;
+            sTrainerCardDataPtr->mainState = STATE_WAIT_FLIP_TO_BACK;
         }
         else if (JOY_NEW(B_BUTTON))
         {
             if (gReceivedRemoteLinkPlayers && sTrainerCardDataPtr->isLink && InUnionRoom() == TRUE)
             {
-                sTrainerCardDataPtr->taskState = 15;
+                sTrainerCardDataPtr->mainState = STATE_WAIT_LINK_PARTNER;
             }
             else
             {
                 BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
-                sTrainerCardDataPtr->taskState = 14;
+                sTrainerCardDataPtr->mainState = STATE_CLOSE_CARD;
             }
         }
         break;
-    case 12:
-        if (sub_808B1FC() && sub_8058244() != TRUE)
+    case STATE_WAIT_FLIP_TO_BACK:
+        if (IsCardFlipTaskActive() && sub_8058244() != TRUE)
         {
             PlaySE(SE_CARD3);
-            sTrainerCardDataPtr->taskState = 11;
+            sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_BACK;
         }
         break;
-    case 11:
+    case STATE_HANDLE_INPUT_BACK:
         if (JOY_NEW(B_BUTTON))
         {
             if (gReceivedRemoteLinkPlayers && sTrainerCardDataPtr->isLink && InUnionRoom() == TRUE)
             {
-                sTrainerCardDataPtr->taskState = 15;
+                sTrainerCardDataPtr->mainState = STATE_WAIT_LINK_PARTNER;
             }
             else if (gReceivedRemoteLinkPlayers)
             {
                 BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
-                sTrainerCardDataPtr->taskState = 14;
+                sTrainerCardDataPtr->mainState = STATE_CLOSE_CARD;
             }
             else
             {
-                HelpSystem_SetSomeVariable2(10);
-                sub_808B1D4();
-                sTrainerCardDataPtr->taskState = 13;
+                SetHelpContext(HELPCONTEXT_TRAINER_CARD_FRONT);
+                FlipTrainerCard();
+                sTrainerCardDataPtr->mainState = STATE_WAIT_FLIP_TO_FRONT;
                 PlaySE(SE_CARD1);
             }
         }
@@ -580,37 +619,37 @@ static void Task_TrainerCard(u8 taskId)
         {
            if (gReceivedRemoteLinkPlayers && sTrainerCardDataPtr->isLink && InUnionRoom() == TRUE)
            {
-               sTrainerCardDataPtr->taskState = 15;
+               sTrainerCardDataPtr->mainState = STATE_WAIT_LINK_PARTNER;
            }
            else
            {
                BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
-               sTrainerCardDataPtr->taskState = 14;
+               sTrainerCardDataPtr->mainState = STATE_CLOSE_CARD;
            }
         }
         break;
-    case 15:
-        sub_800AAC0();
+    case STATE_WAIT_LINK_PARTNER:
+        Link_TryStartSend5FFF();
         DrawDialogueFrame(0, 1);
         AddTextPrinterParameterized(0, 2, gText_WaitingTrainerFinishReading, 0, 1, TEXT_SPEED_FF, 0);
         CopyWindowToVram(0, 3);
-        sTrainerCardDataPtr->taskState = 16;
+        sTrainerCardDataPtr->mainState = STATE_CLOSE_CARD_LINK;
         break;
-    case 16:
+    case STATE_CLOSE_CARD_LINK:
         if (!gReceivedRemoteLinkPlayers)
         {
             BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
-            sTrainerCardDataPtr->taskState = 14;
+            sTrainerCardDataPtr->mainState = STATE_CLOSE_CARD;
         }
         break;
-    case 14:
+    case STATE_CLOSE_CARD:
         if (!UpdatePaletteFade())
             CloseTrainerCard(taskId);
         break;
-    case 13:
-        if (sub_808B1FC() && sub_8058244() != TRUE)
+    case STATE_WAIT_FLIP_TO_FRONT:
+        if (IsCardFlipTaskActive() && sub_8058244() != TRUE)
         {
-            sTrainerCardDataPtr->taskState = 10;
+            sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_FRONT;
             PlaySE(SE_CARD3);
         }
         break;
@@ -622,45 +661,46 @@ static bool8 LoadCardGfx(void)
     switch (sTrainerCardDataPtr->gfxLoadState)
     {
     case 0:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LZ77UnCompWram(sUnknown_83CCE30, &sTrainerCardDataPtr->var_E1C);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+            LZ77UnCompWram(sHoennTrainerCardBg_Tilemap, sTrainerCardDataPtr->bgTilemap);
         else
-            LZ77UnCompWram(sUnknown_83CCEC8, &sTrainerCardDataPtr->var_E1C);
+            LZ77UnCompWram(sKantoTrainerCardBg_Tilemap, sTrainerCardDataPtr->bgTilemap);
         break;
     case 1:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LZ77UnCompWram(sUnknown_83CC8A8, &sTrainerCardDataPtr->var_96C);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+            LZ77UnCompWram(sHoennTrainerCardBack_Tilemap, sTrainerCardDataPtr->backTilemap);
         else
-            LZ77UnCompWram(sUnknown_83CC984, &sTrainerCardDataPtr->var_96C);
+            LZ77UnCompWram(sKantoTrainerCardBack_Tilemap, sTrainerCardDataPtr->backTilemap);
         break;
     case 2:
         if (!sTrainerCardDataPtr->isLink)
         {
-            if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-                LZ77UnCompWram(sUnknown_83CC4DC, &sTrainerCardDataPtr->var_4BC);
+            if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+                LZ77UnCompWram(sHoennTrainerCardFront_Tilemap, sTrainerCardDataPtr->frontTilemap);
             else
-                LZ77UnCompWram(sUnknown_83CC6F0, &sTrainerCardDataPtr->var_4BC);
+                LZ77UnCompWram(sKantoTrainerCardFront_Tilemap, sTrainerCardDataPtr->frontTilemap);
         }
         else
         {
-            if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-                LZ77UnCompWram(sUnknown_83CCAB0, &sTrainerCardDataPtr->var_4BC);
+            if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+                LZ77UnCompWram(sHoennTrainerCardFrontLink_Tilemap, sTrainerCardDataPtr->frontTilemap);
             else
-                LZ77UnCompWram(sUnknown_83CCCA4, &sTrainerCardDataPtr->var_4BC);
+                LZ77UnCompWram(sKantoTrainerCardFrontLink_Tilemap, sTrainerCardDataPtr->frontTilemap);
         }
         break;
     case 3:
-        LZ77UnCompWram(sFireRedTrainerCardBadges_Tile, &sTrainerCardDataPtr->cardTiles);
+        // ? Doesnt check for RSE, sHoennTrainerCardBadges_Gfx goes unused
+        LZ77UnCompWram(sKantoTrainerCardBadges_Gfx, sTrainerCardDataPtr->badgeTiles);
         break;
     case 4:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LZ77UnCompWram(gEmeraldTrainerCard_Gfx, &sTrainerCardDataPtr->var_18CC);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+            LZ77UnCompWram(gHoennTrainerCard_Gfx, &sTrainerCardDataPtr->cardTiles);
         else
-            LZ77UnCompWram(gFireRedTrainerCard_Gfx, &sTrainerCardDataPtr->var_18CC);
+            LZ77UnCompWram(gKantoTrainerCard_Gfx, &sTrainerCardDataPtr->cardTiles);
         break;
     case 5:
         if (sTrainerCardDataPtr->cardType == CARD_TYPE_FRLG)
-            LZ77UnCompWram(sTrainerCardStickers, &sTrainerCardDataPtr->bgTiles);
+            LZ77UnCompWram(sTrainerCardStickers_Gfx, sTrainerCardDataPtr->stickerTiles);
         break;
     default:
         sTrainerCardDataPtr->gfxLoadState = 0;
@@ -676,7 +716,7 @@ static void CB2_InitTrainerCard(void)
     {
     case 0:
         ResetGpuRegs();
-        sub_8089DA4();
+        SetUpTrainerCardTask();
         gMain.state++;
         break;
     case 1:
@@ -696,7 +736,7 @@ static void CB2_InitTrainerCard(void)
         gMain.state++;
         break;
     case 5:
-        ResetTrainerCard();
+        InitBgsAndWindows();
         gMain.state++;
         break;
     case 6:
@@ -704,7 +744,7 @@ static void CB2_InitTrainerCard(void)
         gMain.state++;
         break;
     case 7:
-        sub_808AB10();
+        LoadMonIconGfx();
         gMain.state++;
         break;
     case 8:
@@ -712,7 +752,7 @@ static void CB2_InitTrainerCard(void)
             gMain.state++;
         break;
     case 9:
-        TrainerCardLoadStickerPals();
+        LoadStickerGfx();
         gMain.state++;
         break;
     case 10:
@@ -720,7 +760,7 @@ static void CB2_InitTrainerCard(void)
         gMain.state++;
         break;
     case 11:
-        sub_8089ECC();
+        BufferTextForCardBack();
         gMain.state++;
         break;
     case 12:
@@ -746,16 +786,16 @@ static u8 GetTrainerStarCount(struct TrainerCard *trainerCard)
 {
     u8 stars = 0;
 
-    if (trainerCard->hofDebutHours != 0 || trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0)
+    if (trainerCard->rse.hofDebutHours != 0 || trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0)
         stars++;
 
-    if (trainerCard->caughtAllHoenn)
+    if (trainerCard->rse.caughtAllHoenn)
         stars++;
 
-    if (trainerCard->battleTowerStraightWins > 49)
+    if (trainerCard->rse.battleTowerStraightWins > 49)
         stars++;
 
-    if (trainerCard->hasAllPaintings)
+    if (trainerCard->rse.hasAllPaintings)
         stars++;
 
     return stars;
@@ -766,63 +806,63 @@ static void SetPlayerCardData(struct TrainerCard *trainerCard, u8 cardType)
     u32 playTime;
     u8 i;
 
-    trainerCard->gender = gSaveBlock2Ptr->playerGender;
-    trainerCard->playTimeHours = gSaveBlock2Ptr->playTimeHours;
-    trainerCard->playTimeMinutes = gSaveBlock2Ptr->playTimeMinutes;
+    trainerCard->rse.gender = gSaveBlock2Ptr->playerGender;
+    trainerCard->rse.playTimeHours = gSaveBlock2Ptr->playTimeHours;
+    trainerCard->rse.playTimeMinutes = gSaveBlock2Ptr->playTimeMinutes;
 
     playTime = GetGameStat(GAME_STAT_FIRST_HOF_PLAY_TIME);
     if (!GetGameStat(GAME_STAT_ENTERED_HOF))
         playTime = 0;
 
-    trainerCard->hofDebutHours = playTime >> 16;
-    trainerCard->hofDebutMinutes = (playTime >> 8) & 0xFF;
-    trainerCard->hofDebutSeconds = playTime & 0xFF;
+    trainerCard->rse.hofDebutHours = playTime >> 16;
+    trainerCard->rse.hofDebutMinutes = (playTime >> 8) & 0xFF;
+    trainerCard->rse.hofDebutSeconds = playTime & 0xFF;
     if ((playTime >> 16) > 999)
     {
-        trainerCard->hofDebutHours = 999;
-        trainerCard->hofDebutMinutes = 59;
-        trainerCard->hofDebutSeconds = 59;
+        trainerCard->rse.hofDebutHours = 999;
+        trainerCard->rse.hofDebutMinutes = 59;
+        trainerCard->rse.hofDebutSeconds = 59;
     }
 
-    trainerCard->hasPokedex = FlagGet(FLAG_SYS_POKEDEX_GET);
-    trainerCard->caughtAllHoenn = HasAllHoennMons();
-    trainerCard->caughtMonsCount = GetCaughtMonsCount();
+    trainerCard->rse.hasPokedex = FlagGet(FLAG_SYS_POKEDEX_GET);
+    trainerCard->rse.caughtAllHoenn = HasAllHoennMons();
+    trainerCard->rse.caughtMonsCount = GetCaughtMonsCount();
 
-    trainerCard->trainerId = (gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0];
+    trainerCard->rse.trainerId = (gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0];
 
-    trainerCard->linkBattleWins = GetCappedGameStat(GAME_STAT_LINK_BATTLE_WINS, 9999);
-    trainerCard->linkBattleLosses = GetCappedGameStat(GAME_STAT_LINK_BATTLE_LOSSES, 9999);
-    trainerCard->pokemonTrades = GetCappedGameStat(GAME_STAT_POKEMON_TRADES, 0xFFFF);
+    trainerCard->rse.linkBattleWins = GetCappedGameStat(GAME_STAT_LINK_BATTLE_WINS, 9999);
+    trainerCard->rse.linkBattleLosses = GetCappedGameStat(GAME_STAT_LINK_BATTLE_LOSSES, 9999);
+    trainerCard->rse.pokemonTrades = GetCappedGameStat(GAME_STAT_POKEMON_TRADES, 0xFFFF);
 
-    trainerCard->battleTowerWins = 0;
-    trainerCard->battleTowerStraightWins = 0;
-    trainerCard->contestsWithFriends = 0;
-    trainerCard->pokeblocksWithFriends = 0;
+    trainerCard->rse.battleTowerWins = 0;
+    trainerCard->rse.battleTowerStraightWins = 0;
+    trainerCard->rse.contestsWithFriends = 0;
+    trainerCard->rse.pokeblocksWithFriends = 0;
 
-    trainerCard->hasAllPaintings = FALSE;
+    trainerCard->rse.hasAllPaintings = FALSE;
 
-    trainerCard->money = GetMoney(&gSaveBlock1Ptr->money);
+    trainerCard->rse.money = GetMoney(&gSaveBlock1Ptr->money);
 
-    for (i = 0; i < 4; i++)
-        trainerCard->var_28[i] = gSaveBlock1Ptr->easyChatProfile[i];
+    for (i = 0; i < TRAINER_CARD_PROFILE_LENGTH; i++)
+        trainerCard->rse.easyChatProfile[i] = gSaveBlock1Ptr->easyChatProfile[i];
 
-    StringCopy(trainerCard->playerName, gSaveBlock2Ptr->playerName);
+    StringCopy(trainerCard->rse.playerName, gSaveBlock2Ptr->playerName);
 
     if (cardType == CARD_TYPE_FRLG)
     {
-        trainerCard->stars = GetTrainerStarCount(trainerCard);
+        trainerCard->rse.stars = GetTrainerStarCount(trainerCard);
     }
-    else if (cardType == CARD_TYPE_EMERALD)
+    else if (cardType == CARD_TYPE_RSE)
     {
-        trainerCard->stars = 0;
-        if (trainerCard->hofDebutHours != 0 || (trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0))
-            trainerCard->stars = cardType;
+        trainerCard->rse.stars = 0;
+        if (trainerCard->rse.hofDebutHours != 0 || (trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0))
+            trainerCard->rse.stars = cardType;
 
         if (HasAllKantoMons())
-            trainerCard->stars++;
+            trainerCard->rse.stars++;
 
         if (HasAllMons())
-            trainerCard->stars++;
+            trainerCard->rse.stars++;
     }
 }
 
@@ -831,43 +871,43 @@ void TrainerCard_GenerateCardForLinkPlayer(struct TrainerCard *trainerCard)
     u8 id = 0;
 
     trainerCard->version = GAME_VERSION;
-    SetPlayerCardData(trainerCard, CARD_TYPE_EMERALD);
+    SetPlayerCardData(trainerCard, CARD_TYPE_RSE);
     if (GetCardType() != CARD_TYPE_FRLG)
         return;
 
-    trainerCard->stars = id;
-    if (trainerCard->hofDebutHours != 0 || trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0)
-        trainerCard->stars = 1;
+    trainerCard->rse.stars = id;
+    if (trainerCard->rse.hofDebutHours != 0 || trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0)
+        trainerCard->rse.stars = 1;
 
-    trainerCard->caughtAllHoenn = HasAllKantoMons();
+    trainerCard->rse.caughtAllHoenn = HasAllKantoMons();
     trainerCard->hasAllMons = HasAllMons();
     trainerCard->berriesPicked = gSaveBlock2Ptr->berryPick.berriesPicked;
     trainerCard->jumpsInRow = gSaveBlock2Ptr->pokeJump.jumpsInRow;
 
     trainerCard->berryCrushPoints = GetCappedGameStat(GAME_STAT_BERRY_CRUSH_POINTS, 0xFFFF);
     trainerCard->unionRoomNum = GetCappedGameStat(GAME_STAT_NUM_UNION_ROOM_BATTLES, 0xFFFF);
-    trainerCard->var_4C = TRUE;
+    trainerCard->shouldDrawStickers = TRUE;
 
-    if (trainerCard->caughtAllHoenn)
-        trainerCard->stars++;
+    if (trainerCard->rse.caughtAllHoenn)
+        trainerCard->rse.stars++;
 
     if (trainerCard->hasAllMons)
-        trainerCard->stars++;
+        trainerCard->rse.stars++;
 
     if (trainerCard->berriesPicked >= 200 && trainerCard->jumpsInRow >= 200)
-        trainerCard->stars++;
+        trainerCard->rse.stars++;
 
-    id = ((u16)trainerCard->trainerId) % 8;
-    if (trainerCard->gender == FEMALE)
-        trainerCard->var_4F = sLinkTrainerCardFacilityClasses[1][id];
+    id = ((u16)trainerCard->rse.trainerId) % NUM_LINK_TRAINER_CARD_CLASSES;
+    if (trainerCard->rse.gender == FEMALE)
+        trainerCard->facilityClass = sLinkTrainerPicFacilityClasses[FEMALE][id];
     else
-        trainerCard->var_4F = sLinkTrainerCardFacilityClasses[0][id];
+        trainerCard->facilityClass = sLinkTrainerPicFacilityClasses[MALE][id];
 
-    trainerCard->var_50[0] = VarGet(VAR_HOF_BRAG_STATE);
-    trainerCard->var_50[1] = VarGet(VAR_EGG_BRAG_STATE);
-    trainerCard->var_50[2] = VarGet(VAR_LINK_WIN_BRAG_STATE);
+    trainerCard->stickers[0] = VarGet(VAR_HOF_BRAG_STATE);
+    trainerCard->stickers[1] = VarGet(VAR_EGG_BRAG_STATE);
+    trainerCard->stickers[2] = VarGet(VAR_LINK_WIN_BRAG_STATE);
 
-    trainerCard->var_4E = VarGet(VAR_TRAINER_CARD_MON_ICON_TINT_IDX);
+    trainerCard->monIconTint = VarGet(VAR_TRAINER_CARD_MON_ICON_TINT_IDX);
 
     trainerCard->monSpecies[0] = MailSpeciesToIconSpecies(VarGet(VAR_TRAINER_CARD_MON_ICON_1));
     trainerCard->monSpecies[1] = MailSpeciesToIconSpecies(VarGet(VAR_TRAINER_CARD_MON_ICON_2));
@@ -890,19 +930,19 @@ static void SetDataFromTrainerCard(void)
     sTrainerCardDataPtr->var_F = FALSE;
     sTrainerCardDataPtr->hasTrades = FALSE;
 
-    memset(&sTrainerCardDataPtr->hasBadge, FALSE, BADGE_COUNT);
-    if (sTrainerCardDataPtr->trainerCard.hasPokedex)
+    memset(sTrainerCardDataPtr->hasBadge, FALSE, sizeof(sTrainerCardDataPtr->hasBadge));
+    if (sTrainerCardDataPtr->trainerCard.rse.hasPokedex)
         sTrainerCardDataPtr->hasPokedex++;
 
-    if (sTrainerCardDataPtr->trainerCard.hofDebutHours != 0
-     || sTrainerCardDataPtr->trainerCard.hofDebutMinutes != 0
-     || sTrainerCardDataPtr->trainerCard.hofDebutSeconds != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.hofDebutHours != 0
+     || sTrainerCardDataPtr->trainerCard.rse.hofDebutMinutes != 0
+     || sTrainerCardDataPtr->trainerCard.rse.hofDebutSeconds != 0)
         sTrainerCardDataPtr->hasHofResult++;
 
-    if (sTrainerCardDataPtr->trainerCard.linkBattleWins != 0 || sTrainerCardDataPtr->trainerCard.linkBattleLosses != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.linkBattleWins != 0 || sTrainerCardDataPtr->trainerCard.rse.linkBattleLosses != 0)
         sTrainerCardDataPtr->hasLinkResults++;
 
-    if (sTrainerCardDataPtr->trainerCard.pokemonTrades != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.pokemonTrades != 0)
         sTrainerCardDataPtr->hasTrades++;
 
     for (i = 0, badgeFlag = FLAG_BADGE01_GET; badgeFlag <= FLAG_BADGE08_GET; badgeFlag++, i++)
@@ -931,6 +971,7 @@ static void HandleGpuRegs(void)
         EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_HBLANK);
 }
 
+// Part of animating card flip
 static void sub_8089BD8(u16 arg0)
 {
     s8 quotient = (arg0 + 40) / 10;
@@ -938,8 +979,8 @@ static void sub_8089BD8(u16 arg0)
     if (quotient <= 4)
         quotient = 0;
 
-    sTrainerCardDataPtr->var_456 = quotient;
-    SetGpuReg(REG_OFFSET_BLDY, sTrainerCardDataPtr->var_456);
+    sTrainerCardDataPtr->flipBlendY = quotient;
+    SetGpuReg(REG_OFFSET_BLDY, sTrainerCardDataPtr->flipBlendY);
     SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(sTrainerCardDataPtr->var_7BCC, 160 - sTrainerCardDataPtr->var_7BCC));
 }
 
@@ -980,7 +1021,7 @@ static void sub_8089CA4(void)
     SetGpuReg(REG_OFFSET_BG3VOFS, DISPCNT_MODE_0);
 }
 
-static void ResetTrainerCard(void)
+static void InitBgsAndWindows(void)
 {
     ResetSpriteData();
     ResetPaletteFade();
@@ -1001,24 +1042,24 @@ static void ResetTrainerCard(void)
 static void SetTrainerCardCB2(void)
 {
     SetMainCallback2(CB2_TrainerCard);
-    HelpSystem_SetSomeVariable2(10);
+    SetHelpContext(HELPCONTEXT_TRAINER_CARD_FRONT);
 }
 
-static void sub_8089DA4(void)
+static void SetUpTrainerCardTask(void)
 {
     ResetTasks();
     ScanlineEffect_Stop();
     CreateTask(Task_TrainerCard, 0);
-    sub_808B774();
+    InitTrainerCardData();
     SetDataFromTrainerCard();
 }
 
-static bool8 PrintAllOnCardPage1(void)
+static bool8 PrintAllOnCardFront(void)
 {
     switch (sTrainerCardDataPtr->printState)
     {
     case 0:
-        PrintNameOnCard();
+        PrintNameOnCardFront();
         break;
     case 1:
         PrintIdOnCard();
@@ -1043,18 +1084,18 @@ static bool8 PrintAllOnCardPage1(void)
     return FALSE;
 }
 
-static bool8 PrintStringsOnCardPage2(void)
+static bool8 PrintAllOnCardBack(void)
 {
     switch (sTrainerCardDataPtr->printState)
     {
     case 0:
-        sub_808A4FC();
+        PrintNameOnCardBack();
         break;
     case 1:
-        PrintHofDebutStringOnCard();
+        PrintHofDebutTimeOnCard();
         break;
     case 2:
-        PrintWinsLossesStringOnCard();
+        PrintLinkBattleResultsOnCard();
         break;
     case 3:
         PrintTradesStringOnCard();
@@ -1066,10 +1107,10 @@ static bool8 PrintStringsOnCardPage2(void)
         PrintUnionStringOnCard();
         break;
     case 6:
-        TrainerCard_PrintPokemonIconsOnCard();
+        PrintPokemonIconsOnCard();
         break;
     case 7:
-        sub_808ABE0();
+        PrintStickersOnCard();
         break;
     default:
         sTrainerCardDataPtr->printState = 0;
@@ -1079,27 +1120,27 @@ static bool8 PrintStringsOnCardPage2(void)
     return FALSE;
 }
 
-static void sub_8089ECC(void)
+static void BufferTextForCardBack(void)
 {
-    PrintNameOnCard2();
-    PrintHofTimeOnCard();
-    PrintLinkResultsNumsOnCard();
-    PrintTradesNumOnCard();
-    PrintBerryCrushNumOnCard();
-    PrintUnionNumOnCard();
+    BufferNameForCardBack();
+    BufferHofDebutTime();
+    BufferLinkBattleResults();
+    BufferNumTrades();
+    BufferBerryCrushPoints();
+    BufferUnionRoomStats();
 }
 
-static void PrintNameOnCard(void)
+static void PrintNameOnCardFront(void)
 {
     u8 buffer[2][32];
     u8* txtPtr;
 
     txtPtr = StringCopy(buffer[0], gText_TrainerCardName);
     txtPtr = buffer[1];
-    StringCopy(txtPtr, sTrainerCardDataPtr->trainerCard.playerName);
+    StringCopy(txtPtr, sTrainerCardDataPtr->trainerCard.rse.playerName);
     ConvertInternationalString(txtPtr, sTrainerCardDataPtr->language);
     StringAppend(buffer[0], txtPtr);
-    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardPlayerNameXPositions[sTrainerCardDataPtr->cardType], sTrainerCardPlayerNameYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer[0]);
+    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardFrontNameXPositions[sTrainerCardDataPtr->cardType], sTrainerCardFrontNameYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors, TEXT_SPEED_FF, buffer[0]);
 }
 
 static void PrintIdOnCard(void)
@@ -1108,8 +1149,8 @@ static void PrintIdOnCard(void)
     u8* txtPtr;
 
     txtPtr = StringCopy(buffer, gText_TrainerCardIDNo);
-    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.trainerId, STR_CONV_MODE_LEADING_ZEROS, 5);
-    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardIdXPositions[sTrainerCardDataPtr->cardType], sTrainerCardIdYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
+    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.rse.trainerId, STR_CONV_MODE_LEADING_ZEROS, 5);
+    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardIdXPositions[sTrainerCardDataPtr->cardType], sTrainerCardIdYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
 }
 
 static void PrintMoneyOnCard(void)
@@ -1119,18 +1160,18 @@ static void PrintMoneyOnCard(void)
     u8 x;
 
     txtPtr = StringCopy(buffer, gText_TrainerCardYen);
-    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.money, STR_CONV_MODE_LEFT_ALIGN, 6);
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.rse.money, STR_CONV_MODE_LEFT_ALIGN, 6);
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
     {
         x = -122 - 6 * StringLength(buffer);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 56, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardMoney);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 56, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 56, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardMoney);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 56, sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
     }
     else
     {
         x = 118 - 6 * StringLength(buffer);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 57, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardMoney);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 57, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 57, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardMoney);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 57, sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
     }    
 }
 
@@ -1149,20 +1190,20 @@ static void PrintPokedexOnCard(void)
 
     if (FlagGet(FLAG_SYS_POKEDEX_GET))
     {
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.caughtMonsCount, 0, 3);
-        if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.caughtMonsCount, 0, 3);
+        if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
         {
             x = -120 - 6 * StringLength(buffer);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 72, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardPokedex);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 72, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 138, 72, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardNull);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 72, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardPokedex);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 72, sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 138, 72, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardNull);
         }
         else
         {
             x = 120 - 6 * StringLength(buffer);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 73, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardPokedex);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 73, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
-            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 138, 73, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardNull);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 73, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardPokedex);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, 73, sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
+            AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 138, 73, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardNull);
         }
     }
 }
@@ -1177,8 +1218,8 @@ static void PrintTimeOnCard(void)
     minutes = gSaveBlock2Ptr->playTimeMinutes;
     if (sTrainerCardDataPtr->isLink)
     {
-        hours = sTrainerCardDataPtr->trainerCard.playTimeHours;
-        minutes = sTrainerCardDataPtr->trainerCard.playTimeMinutes;
+        hours = sTrainerCardDataPtr->trainerCard.rse.playTimeHours;
+        minutes = sTrainerCardDataPtr->trainerCard.rse.playTimeMinutes;
     }
 
     if (hours > 999)
@@ -1188,19 +1229,19 @@ static void PrintTimeOnCard(void)
         minutes = 59;
 
     FillWindowPixelRect(1, PIXEL_FILL(0), sTrainerCardTimeHoursXPositions[sTrainerCardDataPtr->cardType], sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], 50, 12);
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 88, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardTime);
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 20, 88, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardTime);
     else
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 89, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_TrainerCardTime);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 16, 89, sTrainerCardTextColors, TEXT_SPEED_FF, gText_TrainerCardTime);
 
     ConvertIntToDecimalStringN(buffer, hours, STR_CONV_MODE_RIGHT_ALIGN, 3);
     AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardTimeHoursXPositions[sTrainerCardDataPtr->cardType],
-        sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
+        sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
     AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardTimeHoursYPositions[sTrainerCardDataPtr->cardType],
-        sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors[sTrainerCardDataPtr->var_7], TEXT_SPEED_FF, gText_Colon2);
+        sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sTimeColonTextColors[sTrainerCardDataPtr->timeColonInvisible], TEXT_SPEED_FF, gText_Colon2);
 
     ConvertIntToDecimalStringN(buffer, minutes, STR_CONV_MODE_LEADING_ZEROS, 2);
-    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardTimeMinutesXPositions[sTrainerCardDataPtr->cardType], sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
+    AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardTimeMinutesXPositions[sTrainerCardDataPtr->cardType], sTrainerCardTimeMinutesYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors, TEXT_SPEED_FF, buffer);
 }
 
 static void PrintProfilePhraseOnCard(void)
@@ -1208,75 +1249,75 @@ static void PrintProfilePhraseOnCard(void)
     if (sTrainerCardDataPtr->isLink)
     {
         AddTextPrinterParameterized3(1, 2, 10, sTrainerCardProfilePhraseXPositions[sTrainerCardDataPtr->cardType],
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->var_19[0]);
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->easyChatProfile[0]);
 
-        AddTextPrinterParameterized3(1, 2, GetStringWidth(2, sTrainerCardDataPtr->var_19[0], 0) + 16, sTrainerCardProfilePhraseXPositions[sTrainerCardDataPtr->cardType],
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->var_19[1]);
+        AddTextPrinterParameterized3(1, 2, GetStringWidth(2, sTrainerCardDataPtr->easyChatProfile[0], 0) + 16, sTrainerCardProfilePhraseXPositions[sTrainerCardDataPtr->cardType],
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->easyChatProfile[1]);
 
         AddTextPrinterParameterized3(1, 2, 10, sTrainerCardProfilePhraseYPositions[sTrainerCardDataPtr->cardType],
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->var_19[2]);
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->easyChatProfile[2]);
 
-        AddTextPrinterParameterized3(1, 2, GetStringWidth(2, sTrainerCardDataPtr->var_19[2], 0) + 16, sTrainerCardProfilePhraseYPositions[sTrainerCardDataPtr->cardType],
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->var_19[3]);    
+        AddTextPrinterParameterized3(1, 2, GetStringWidth(2, sTrainerCardDataPtr->easyChatProfile[2], 0) + 16, sTrainerCardProfilePhraseYPositions[sTrainerCardDataPtr->cardType],
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->easyChatProfile[3]);    
     }
 }
 
-static void PrintNameOnCard2(void)
+static void BufferNameForCardBack(void)
 {
-    StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->trainerCard.playerName);
+    StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->trainerCard.rse.playerName);
     ConvertInternationalString(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->language);
-    if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
+    if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
     {
         StringAppend(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], gText_Var1sTrainerCard);
     }
 }
 
-static void sub_808A4FC(void)
+static void PrintNameOnCardBack(void)
 {
     u8 x;
 
     if (sTrainerCardDataPtr->cardType == CARD_TYPE_FRLG)
     {
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sUnknown_83CD93C[sTrainerCardDataPtr->cardType],
-            sUnknown_83CD93E[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardBackNameXPositions[sTrainerCardDataPtr->cardType],
+            sTrainerCardBackNameYPositions[sTrainerCardDataPtr->cardType], sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME]);
     }
     else
     {    
-        x = sUnknown_83CD93C[sTrainerCardDataPtr->cardType] - GetStringWidth(sTrainerCardFontIds[1], sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], GetFontAttribute(sTrainerCardFontIds[1], FONTATTR_LETTER_SPACING));
+        x = sTrainerCardBackNameXPositions[sTrainerCardDataPtr->cardType] - GetStringWidth(sTrainerCardFontIds[1], sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], GetFontAttribute(sTrainerCardFontIds[1], FONTATTR_LETTER_SPACING));
 
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, sUnknown_83CD93E[sTrainerCardDataPtr->cardType],
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], x, sTrainerCardBackNameYPositions[sTrainerCardDataPtr->cardType],
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME]);
     }
 }
 
-static void PrintHofTimeOnCard(void)
+static void BufferHofDebutTime(void)
 {
     u8 buffer[10];
     u8* txtPtr;
 
     if (sTrainerCardDataPtr->hasHofResult)
     {
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutHours, STR_CONV_MODE_RIGHT_ALIGN, 3);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutHours, STR_CONV_MODE_RIGHT_ALIGN, 3);
         txtPtr = StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], gText_Colon2, 2);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer, 3);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], gText_Colon2, 2);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutSeconds, STR_CONV_MODE_LEADING_ZEROS, 2);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutSeconds, STR_CONV_MODE_LEADING_ZEROS, 2);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer, 3);
     }
 }
 
-static void PrintHofDebutStringOnCard(void)
+static void PrintHofDebutTimeOnCard(void)
 {
     if (sTrainerCardDataPtr->hasHofResult)
     {
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 35, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, gText_HallOfFameDebut);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 164, 35, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 35, sTrainerCardTextColors, TEXT_SPEED_FF, gText_HallOfFameDebut);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 164, 35, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME]);
     }
 }
 
-static void PrintLinkResultsNumsOnCard(void)
+static void BufferLinkBattleResults(void)
 {
     u8 buffer[30];
 
@@ -1284,31 +1325,31 @@ static void PrintLinkResultsNumsOnCard(void)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_RECORD], sLinkTrainerCardRecordStrings[sTrainerCardDataPtr->cardType]);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_WIN_LOSS], gText_WinLossRatio);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.linkBattleWins, STR_CONV_MODE_RIGHT_ALIGN, 4);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.linkBattleWins, STR_CONV_MODE_RIGHT_ALIGN, 4);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_WINS], buffer);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.linkBattleLosses, STR_CONV_MODE_RIGHT_ALIGN, 4);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.linkBattleLosses, STR_CONV_MODE_RIGHT_ALIGN, 4);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_LOSSES], buffer);
     }
 }
 
-static void PrintWinsLossesStringOnCard(void)
+static void PrintLinkBattleResultsOnCard(void)
 {    
     if (sTrainerCardDataPtr->hasLinkResults)
     {
         AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 51, 
-            sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_RECORD]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 130, 51, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_WIN_LOSS]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 144, 51, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_WINS]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 192, 51, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_LOSSES]);
+            sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_RECORD]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 130, 51, sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_WIN_LOSS]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 144, 51, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_WINS]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 192, 51, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_LOSSES]);
     }
 }
 
-static void PrintTradesNumOnCard(void)
+static void BufferNumTrades(void)
 {
     if (sTrainerCardDataPtr->hasTrades)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADES], gText_PokemonTrades);
-        ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT], sTrainerCardDataPtr->trainerCard.pokemonTrades, STR_CONV_MODE_RIGHT_ALIGN, 5);
+        ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT], sTrainerCardDataPtr->trainerCard.rse.pokemonTrades, STR_CONV_MODE_RIGHT_ALIGN, 5);
     }
 }
 
@@ -1316,14 +1357,14 @@ static void PrintTradesStringOnCard(void)
 {
     if (sTrainerCardDataPtr->hasTrades)
     {
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 67, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADES]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 67, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 67, sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADES]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 67, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT]);
     }
 }
 
-static void PrintBerryCrushNumOnCard(void)
+static void BufferBerryCrushPoints(void)
 {
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH], gText_BerryCrushes);
         ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH_COUNT], sTrainerCardDataPtr->trainerCard.berryCrushPoints, STR_CONV_MODE_RIGHT_ALIGN, 5);
@@ -1332,16 +1373,16 @@ static void PrintBerryCrushNumOnCard(void)
 
 static void PrintBerryCrushStringOnCard(void)
 {
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD && sTrainerCardDataPtr->trainerCard.berryCrushPoints)
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE && sTrainerCardDataPtr->trainerCard.berryCrushPoints)
     {
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 99, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 99, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH_COUNT]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 99, sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 99, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_BERRY_CRUSH_COUNT]);
     }
 }
 
-static void PrintUnionNumOnCard(void)
+static void BufferUnionRoomStats(void)
 {
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM], gText_UnionRoomTradesBattles);
         ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM_NUM], sTrainerCardDataPtr->trainerCard.unionRoomNum, STR_CONV_MODE_RIGHT_ALIGN, 5);
@@ -1350,88 +1391,88 @@ static void PrintUnionNumOnCard(void)
 
 static void PrintUnionStringOnCard(void)
 {
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD && sTrainerCardDataPtr->trainerCard.unionRoomNum)
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE && sTrainerCardDataPtr->trainerCard.unionRoomNum)
     {
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 83, sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM]);
-        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 83, sTrainerCardPage2TextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM_NUM]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardHofDebutXPositions[sTrainerCardDataPtr->cardType], 83, sTrainerCardTextColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM]);
+        AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], 186, 83, sTrainerCardStatColors, TEXT_SPEED_FF, sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_UNION_ROOM_NUM]);
     }
 }
 
-static void TrainerCard_PrintPokemonIconsOnCard(void)
+static void PrintPokemonIconsOnCard(void)
 {
     u8 i;
-    u8 buffer[6];
-    u8 buffer2[6];
+    u8 paletteSlots[PARTY_SIZE];
+    u8 xOffsets[PARTY_SIZE];
 
-    memcpy(buffer, sUnknown_83CD94C, sizeof(sUnknown_83CD94C));
-    memcpy(buffer2, sUnknown_83CD952, sizeof(sUnknown_83CD952));
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+    memcpy(paletteSlots, sPokemonIconPalSlots, sizeof(sPokemonIconPalSlots));
+    memcpy(xOffsets, sPokemonIconXOffsets, sizeof(sPokemonIconXOffsets));
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
     {
-        for (i = 0; i < 6; i++)
+        for (i = 0; i < PARTY_SIZE; i++)
         {
             if (sTrainerCardDataPtr->trainerCard.monSpecies[i])
             {
                 u8 monSpecies = GetMonIconPaletteIndexFromSpecies(sTrainerCardDataPtr->trainerCard.monSpecies[i]);
-                WriteSequenceToBgTilemapBuffer(3, 16 * i + 224, buffer2[i] + 3, 15, 4, 4, buffer[monSpecies], 1);
+                WriteSequenceToBgTilemapBuffer(3, 16 * i + 224, xOffsets[i] + 3, 15, 4, 4, paletteSlots[monSpecies], 1);
             }
         }
     }
 }
 
-static void sub_808AB10(void)
+static void LoadMonIconGfx(void)
 {
     u8 i;
 
-    CpuSet(gMonIconPalettes, sTrainerCardDataPtr->monIconPals, 32 * 3);
-    switch (sTrainerCardDataPtr->trainerCard.var_4E)
+    CpuSet(gMonIconPalettes, sTrainerCardDataPtr->monIconPals, NELEMS(sTrainerCardDataPtr->monIconPals));
+    switch (sTrainerCardDataPtr->trainerCard.monIconTint)
     {
-    case 0:
+    case MON_ICON_TINT_NORMAL:
         break;
-    case 1:
+    case MON_ICON_TINT_BLACK:
         TintPalette_CustomTone(sTrainerCardDataPtr->monIconPals, 96, 0, 0, 0);
         break;
-    case 2:
+    case MON_ICON_TINT_PINK:
         TintPalette_CustomTone(sTrainerCardDataPtr->monIconPals, 96, 500, 330, 310);
         break;
-    case 3:
+    case MON_ICON_TINT_SEPIA:
         TintPalette_SepiaTone(sTrainerCardDataPtr->monIconPals, 96);
         break;
     }
 
     LoadPalette(sTrainerCardDataPtr->monIconPals, 80, 192);
-    for (i = 0; i < 6; i++)
+    for (i = 0; i < PARTY_SIZE; i++)
     {
         LoadBgTiles(3, GetMonIconTiles(sTrainerCardDataPtr->trainerCard.monSpecies[i], 0), 512, 16 * i + 32);
     }
 }
 
-static void sub_808ABE0(void)
+static void PrintStickersOnCard(void)
 {
     u8 i;
-    u8 buffer[4];
+    u8 palSlots[4];
 
-    memcpy(buffer, sUnknown_83CD958, sizeof(sUnknown_83CD958));
-    if (sTrainerCardDataPtr->cardType == CARD_TYPE_FRLG && sTrainerCardDataPtr->trainerCard.var_4C == 1)
+    memcpy(palSlots, sStickerPalSlots, sizeof(sStickerPalSlots));
+    if (sTrainerCardDataPtr->cardType == CARD_TYPE_FRLG && sTrainerCardDataPtr->trainerCard.shouldDrawStickers == TRUE)
     {
-        for (i = 0; i < 3; i++)
+        for (i = 0; i < TRAINER_CARD_STICKER_TYPES; i++)
         {
-            u8 var_50 = sTrainerCardDataPtr->trainerCard.var_50[i];
-            if (sTrainerCardDataPtr->trainerCard.var_50[i])
-                WriteSequenceToBgTilemapBuffer(3, i * 4 + 320, i * 3 + 2, 2, 2, 2, buffer[var_50 - 1], 1);
+            u8 sticker = sTrainerCardDataPtr->trainerCard.stickers[i];
+            if (sTrainerCardDataPtr->trainerCard.stickers[i])
+                WriteSequenceToBgTilemapBuffer(3, i * 4 + 320, i * 3 + 2, 2, 2, 2, palSlots[sticker - 1], 1);
         }
     }
 }
 
-static void TrainerCardLoadStickerPals(void)
+static void LoadStickerGfx(void)
 {
     LoadPalette(sTrainerCardStickerPal1, 176, 32);
     LoadPalette(sTrainerCardStickerPal2, 192, 32);
     LoadPalette(sTrainerCardStickerPal3, 208, 32);
     LoadPalette(sTrainerCardStickerPal4, 224, 32);
-    LoadBgTiles(3, sTrainerCardDataPtr->bgTiles, 1024, 128);
+    LoadBgTiles(3, sTrainerCardDataPtr->stickerTiles, 1024, 128);
 }
 
-static void PutTrainerCardWindow(u8 windowId)
+static void DrawTrainerCardWindow(u8 windowId)
 {
     PutWindowTilemap(windowId);
     CopyWindowToVram(windowId, 3);
@@ -1442,35 +1483,35 @@ static bool8 SetTrainerCardBgsAndPals(void)
     switch (sTrainerCardDataPtr->bgPalLoadState)
     {
     case 0:
-        LoadBgTiles(3, sTrainerCardDataPtr->cardTiles, 1024, 0);
+        LoadBgTiles(3, sTrainerCardDataPtr->badgeTiles, ARRAY_COUNT(sTrainerCardDataPtr->badgeTiles), 0);
         break;
     case 1:
-        LoadBgTiles(0, sTrainerCardDataPtr->var_18CC, 6144, 0);
+        LoadBgTiles(0, sTrainerCardDataPtr->cardTiles, 0x1800, 0);
         break;
     case 2:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LoadPalette(sEmeraldTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.stars], 0, 96);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+            LoadPalette(sHoennTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.rse.stars], 0, 96);
         else
-            LoadPalette(sFireRedTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.stars], 0, 96);
+            LoadPalette(sKantoTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.rse.stars], 0, 96);
         break;
     case 3:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LoadPalette(sEmeraldTrainerCardBadges_Pal, 48, 32);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE)
+            LoadPalette(sHoennTrainerCardBadges_Pal, 48, 32);
         else
-            LoadPalette(sFireRedTrainerCardBadges_Pal, 48, 32);
+            LoadPalette(sKantoTrainerCardBadges_Pal, 48, 32);
         break;
     case 4:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD && sTrainerCardDataPtr->trainerCard.gender != MALE)
-            LoadPalette(sEmeraldTrainerCardFemaleBackground_Pal, 16, 32);
-        else if (sTrainerCardDataPtr->trainerCard.gender != MALE)
-            LoadPalette(sFireRedTrainerCardFemaleBackground_Pal, 16, 32);
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_RSE && sTrainerCardDataPtr->trainerCard.rse.gender != MALE)
+            LoadPalette(sHoennTrainerCardFemaleBackground_Pal, 16, 32);
+        else if (sTrainerCardDataPtr->trainerCard.rse.gender != MALE)
+            LoadPalette(sKantoTrainerCardFemaleBackground_Pal, 16, 32);
         break;
     case 5:
-        LoadPalette(sUnknown_83CD300, 64, 32);
+        LoadPalette(sTrainerCardGold_Pal, 64, 32);
         break;
     case 6:
-        SetBgTilemapBuffer(0, sTrainerCardDataPtr->bgTilemap0);
-        SetBgTilemapBuffer(2, sTrainerCardDataPtr->bgTilemap2);
+        SetBgTilemapBuffer(0, sTrainerCardDataPtr->cardTilemapBuffer);
+        SetBgTilemapBuffer(2, sTrainerCardDataPtr->bgTilemapBuffer);
         break;
     default:
         FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
@@ -1483,10 +1524,10 @@ static bool8 SetTrainerCardBgsAndPals(void)
     return FALSE;
 }
 
-static void LoadTrainerCardTilemap2(const u16* ptr)
+static void DrawCardScreenBackground(const u16* ptr)
 {
     s16 i, j;
-    u16 *dst = sTrainerCardDataPtr->bgTilemap2;
+    u16 *dst = sTrainerCardDataPtr->bgTilemapBuffer;
 
     for (i = 0; i < 20; i++)
     {
@@ -1502,10 +1543,10 @@ static void LoadTrainerCardTilemap2(const u16* ptr)
     CopyBgTilemapBufferToVram(2);
 }
 
-static void LoadTrainerCardTilemap0(const u16* ptr)
+static void DrawCardFrontOrBack(const u16* ptr)
 {
     s16 i, j;
-    u16 *dst = sTrainerCardDataPtr->bgTilemap0;
+    u16 *dst = sTrainerCardDataPtr->cardTilemapBuffer;
 
     for (i = 0; i < 20; i++)
     {
@@ -1521,17 +1562,17 @@ static void LoadTrainerCardTilemap0(const u16* ptr)
     CopyBgTilemapBufferToVram(0);
 }
 
-static void TrainerCard_PrintStarsAndBadgesOnCard(void)
+static void DrawStarsAndBadgesOnCard(void)
 {
     s16 i, x;
     u16 tileNum = 192;
     u8 palNum = 3;
 
-    FillBgTilemapBufferRect(3, 143, 15, sUnknown_83CD95C[sTrainerCardDataPtr->cardType], sTrainerCardDataPtr->trainerCard.stars, 1, 4);
+    FillBgTilemapBufferRect(3, 143, 15, sStarYOffsets[sTrainerCardDataPtr->cardType], sTrainerCardDataPtr->trainerCard.rse.stars, 1, 4);
     if (!sTrainerCardDataPtr->isLink)
     {
         x = 4;
-        for (i = 0; i < BADGE_COUNT; i++, tileNum += 2, x += 3)
+        for (i = 0; i < NUM_BADGES; i++, tileNum += 2, x += 3)
         {
             if (sTrainerCardDataPtr->hasBadge[i])
             {
@@ -1546,9 +1587,9 @@ static void TrainerCard_PrintStarsAndBadgesOnCard(void)
     CopyBgTilemapBufferToVram(3);
 }
 
-static void sub_808B090(void)
+static void DrawCardBackStats(void)
 {
-    if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
+    if (sTrainerCardDataPtr->cardType != CARD_TYPE_RSE)
     {
         if (sTrainerCardDataPtr->hasTrades)
         {
@@ -1580,43 +1621,45 @@ static void sub_808B090(void)
     CopyBgTilemapBufferToVram(3);
 }
 
-static void sub_808B180(void)
+static void BlinkTimeColon(void)
 {
-    if (++sTrainerCardDataPtr->var_6 > 60)
+    if (++sTrainerCardDataPtr->timeColonBlinkTimer > 60)
     {
-        sTrainerCardDataPtr->var_6 = 0;
-        sTrainerCardDataPtr->var_7 ^= 1;
-        sTrainerCardDataPtr->var_7BCE = TRUE;
+        sTrainerCardDataPtr->timeColonBlinkTimer = 0;
+        sTrainerCardDataPtr->timeColonInvisible ^= 1;
+        sTrainerCardDataPtr->timeColonNeedDraw = TRUE;
     }
 }
 
 u8 GetTrainerCardStars(u8 cardId)
 {
-    return gTrainerCards[cardId].stars;
+    return gTrainerCards[cardId].rse.stars;
 }
 
-static void sub_808B1D4(void)
+#define tFlipState data[0]
+
+static void FlipTrainerCard(void)
 {
-    u8 taskId = CreateTask(sub_808B21C, 0);
-    sub_808B21C(taskId);
+    u8 taskId = CreateTask(Task_DoCardFlipTask, 0);
+    Task_DoCardFlipTask(taskId);
     SetHBlankCallback(HBlankCB_TrainerCard);
 }
 
-static bool8 sub_808B1FC(void)
+static bool8 IsCardFlipTaskActive(void)
 {
-    if (FindTaskIdByFunc(sub_808B21C) == 0xFF)
+    if (FindTaskIdByFunc(Task_DoCardFlipTask) == 0xFF)
         return TRUE;
     else
         return FALSE;
 }
 
-static void sub_808B21C(u8 taskId)
+static void Task_DoCardFlipTask(u8 taskId)
 {
-    while(sTrainerCardTasks[gTasks[taskId].data[0]](&gTasks[taskId]))
+    while(sTrainerCardFlipTasks[gTasks[taskId].tFlipState](&gTasks[taskId]))
         ;
 }
 
-static bool8 sub_808B254(struct Task* task)
+static bool8 Task_BeginCardFlip(struct Task* task)
 {
     u32 i;
 
@@ -1625,15 +1668,12 @@ static bool8 sub_808B254(struct Task* task)
     ScanlineEffect_Stop();
     ScanlineEffect_Clear();
     for (i = 0; i < 160; i++)
-    {
         gScanlineEffectRegBuffers[1][i] = 0;
-    }
-
-    task->data[0]++;
+    task->tFlipState++;
     return FALSE;
 }
 
-static bool8 sub_808B294(struct Task* task)
+static bool8 Task_AnimateCardFlipDown(struct Task* task)
 {
     u32 r4, r5, r10, r7, r6, var_24, r9, var;
     s16 i;
@@ -1679,12 +1719,12 @@ static bool8 sub_808B294(struct Task* task)
 
     sTrainerCardDataPtr->allowDMACopy = TRUE;
     if (task->data[1] >= 77)
-        task->data[0]++;
+        task->tFlipState++;
 
     return FALSE;
 }
 
-static bool8 sub_808B3C4(struct Task* task)
+static bool8 Task_DrawFlippedCardSide(struct Task* task)
 {
     sTrainerCardDataPtr->allowDMACopy = FALSE;
     if (sub_8058244() == TRUE)
@@ -1692,72 +1732,74 @@ static bool8 sub_808B3C4(struct Task* task)
 
     do
     {
-        switch (sTrainerCardDataPtr->var_4)
+        switch (sTrainerCardDataPtr->flipDrawState)
         {
         case 0:
             FillWindowPixelBuffer(1, PIXEL_FILL(0));
             FillBgTilemapBufferRect_Palette0(3, 0, 0, 0, 32, 32);
             break;
         case 1:
-            if (!sTrainerCardDataPtr->var_8)
+            if (!sTrainerCardDataPtr->onBack)
             {
-                if (!PrintStringsOnCardPage2())
+                if (!PrintAllOnCardBack())
                     return FALSE;
             }
             else
             {
-                if (!PrintAllOnCardPage1())
+                if (!PrintAllOnCardFront())
                     return FALSE;
             }
             break;
         case 2:
-            if (!sTrainerCardDataPtr->var_8)
-                LoadTrainerCardTilemap0(sTrainerCardDataPtr->var_96C);
+            if (!sTrainerCardDataPtr->onBack)
+                DrawCardFrontOrBack(sTrainerCardDataPtr->backTilemap);
             else
-                PutTrainerCardWindow(1);
+                DrawTrainerCardWindow(1);
             break;
         case 3:
-            if (!sTrainerCardDataPtr->var_8)
-                sub_808B090();
+            if (!sTrainerCardDataPtr->onBack)
+                DrawCardBackStats();
             else
                 FillWindowPixelBuffer(2, PIXEL_FILL(0));
             break;
         case 4:
-            if (sTrainerCardDataPtr->var_8)
-                sub_808B838();
+            if (sTrainerCardDataPtr->onBack)
+                CreateTrainerCardTrainerPic();
             break;
         default:
-            task->data[0]++;
+            task->tFlipState++;
             sTrainerCardDataPtr->allowDMACopy = TRUE;
-            sTrainerCardDataPtr->var_4 = 0;
+            sTrainerCardDataPtr->flipDrawState = 0;
             return FALSE;
         }
-        sTrainerCardDataPtr->var_4++;
+        sTrainerCardDataPtr->flipDrawState++;
     } while (gReceivedRemoteLinkPlayers == 0);
 
     return FALSE;
 }
 
-static bool8 sub_808B4D8(struct Task* task)
+static bool8 Task_SetCardFlipped(struct Task* task)
 {
     sTrainerCardDataPtr->allowDMACopy = FALSE;
-    if (sTrainerCardDataPtr->var_8)
+
+    // If on back of card, draw front of card because its being flipped
+    if (sTrainerCardDataPtr->onBack)
     {
-        PutTrainerCardWindow(2);
-        LoadTrainerCardTilemap2(&sTrainerCardDataPtr->var_E1C);
-        LoadTrainerCardTilemap0(&sTrainerCardDataPtr->var_4BC);
-        TrainerCard_PrintStarsAndBadgesOnCard();
+        DrawTrainerCardWindow(2);
+        DrawCardScreenBackground(sTrainerCardDataPtr->bgTilemap);
+        DrawCardFrontOrBack(sTrainerCardDataPtr->frontTilemap);
+        DrawStarsAndBadgesOnCard();
     }
 
-    PutTrainerCardWindow(1);
-    sTrainerCardDataPtr->var_8 ^= 1;
-    task->data[0]++;
+    DrawTrainerCardWindow(1);
+    sTrainerCardDataPtr->onBack ^= 1;
+    task->tFlipState++;
     sTrainerCardDataPtr->allowDMACopy = TRUE;
     PlaySE(SE_CARD2);
     return FALSE;
 }
 
-static bool8 sub_808B540(struct Task* task)
+static bool8 Task_AnimateCardFlipUp(struct Task* task)
 {
     u32 r4, r5, r10, r7, r6, var_24, r9, var;
     s16 i;
@@ -1803,17 +1845,17 @@ static bool8 sub_808B540(struct Task* task)
 
     sTrainerCardDataPtr->allowDMACopy = TRUE;
     if (task->data[1] <= 0)
-        task->data[0]++;
+        task->tFlipState++;
 
     return FALSE;
 }
 
-static bool8 sub_808B66C(struct Task *task)
+static bool8 Task_EndCardFlip(struct Task *task)
 {
     ShowBg(1);
     ShowBg(3);
     SetHBlankCallback(NULL);
-    DestroyTask(FindTaskIdByFunc(sub_808B21C));
+    DestroyTask(FindTaskIdByFunc(Task_DoCardFlipTask));
     return FALSE;
 }
 
@@ -1841,24 +1883,22 @@ void ShowTrainerCardInLink(u8 cardId, void (*callback)(void))
     SetMainCallback2(CB2_InitTrainerCard);
 }
 
-static void sub_808B774(void)
+static void InitTrainerCardData(void)
 {
     u8 i;
 
-    sTrainerCardDataPtr->taskState = 0;
-    sTrainerCardDataPtr->var_6 = gSaveBlock2Ptr->playTimeVBlanks;
-    sTrainerCardDataPtr->var_7 = 0;
-    sTrainerCardDataPtr->var_8 = 0;
-    sTrainerCardDataPtr->var_456 = 0;
-    if (GetCardType() == CARD_TYPE_EMERALD)
-        sTrainerCardDataPtr->cardType = CARD_TYPE_EMERALD;
+    sTrainerCardDataPtr->mainState = 0;
+    sTrainerCardDataPtr->timeColonBlinkTimer = gSaveBlock2Ptr->playTimeVBlanks;
+    sTrainerCardDataPtr->timeColonInvisible = FALSE;
+    sTrainerCardDataPtr->onBack = FALSE;
+    sTrainerCardDataPtr->flipBlendY = 0;
+    if (GetCardType() == CARD_TYPE_RSE)
+        sTrainerCardDataPtr->cardType = CARD_TYPE_RSE;
     else
         sTrainerCardDataPtr->cardType = CARD_TYPE_FRLG;
 
-    for (i = 0; i < 4; i++)
-    {
-        CopyEasyChatWord(sTrainerCardDataPtr->var_19[i], sTrainerCardDataPtr->trainerCard.var_28[i]);
-    }
+    for (i = 0; i < TRAINER_CARD_PROFILE_LENGTH; i++)
+        CopyEasyChatWord(sTrainerCardDataPtr->easyChatProfile[i], sTrainerCardDataPtr->trainerCard.rse.easyChatProfile[i]);
 }
 
 static u8 GetCardType(void)
@@ -1868,39 +1908,39 @@ static u8 GetCardType(void)
         if (gGameVersion == VERSION_FIRE_RED || gGameVersion == VERSION_LEAF_GREEN)
             return CARD_TYPE_FRLG;
         else
-            return CARD_TYPE_EMERALD;
+            return CARD_TYPE_RSE;
     }
     else
     {
         if (sTrainerCardDataPtr->trainerCard.version == VERSION_FIRE_RED || sTrainerCardDataPtr->trainerCard.version == VERSION_LEAF_GREEN)
             return CARD_TYPE_FRLG;
         else
-            return CARD_TYPE_EMERALD;
+            return CARD_TYPE_RSE;
     }
 }
 
-static void sub_808B838(void)
+static void CreateTrainerCardTrainerPic(void)
 {
-    u8 val = sLinkTrainerCardFrontPics[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender];
+    u8 facilityClass = sTrainerPicFacilityClasses[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender];
 
     if (InUnionRoom() == TRUE && gReceivedRemoteLinkPlayers == 1)
     {
-        val = sTrainerCardDataPtr->trainerCard.var_4F;
-        sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1], 8, 2);
+        facilityClass = sTrainerCardDataPtr->trainerCard.facilityClass;
+        CreateTrainerCardTrainerPicSprite(FacilityClassToPicIndex(facilityClass), TRUE, sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1], 8, 2);
     }
     else
     {
         if (sTrainerCardDataPtr->cardType != CARD_TYPE_FRLG)
         {
-            sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1], 8, 2);
+            CreateTrainerCardTrainerPicSprite(FacilityClassToPicIndex(facilityClass), TRUE, sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1], 8, 2);
         }
         else
         {
-            sub_810C330(PlayerGenderToFrontTrainerPicId_Debug(sTrainerCardDataPtr->trainerCard.gender, TRUE), TRUE,
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1],
+            CreateTrainerCardTrainerPicSprite(PlayerGenderToFrontTrainerPicId_Debug(sTrainerCardDataPtr->trainerCard.rse.gender, TRUE), TRUE,
+                    sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerPicOffsets[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1],
                     8, 2);
         }
     }
diff --git a/src/trainer_pokemon_sprites.c b/src/trainer_pokemon_sprites.c
index 7262954c9..8567d791b 100644
--- a/src/trainer_pokemon_sprites.c
+++ b/src/trainer_pokemon_sprites.c
@@ -2,12 +2,9 @@
 #include "sprite.h"
 #include "window.h"
 #include "malloc.h"
-#include "constants/species.h"
 #include "palette.h"
 #include "decompress.h"
-#include "trainer_pokemon_sprites.h"
 #include "pokemon.h"
-#include "constants/trainer_classes.h"
 
 extern const struct CompressedSpriteSheet gMonFrontPicTable[];
 extern const struct CompressedSpriteSheet gMonBackPicTable[];
@@ -303,7 +300,7 @@ u16 sub_810C2FC(u16 species, bool8 isFrontPic, u8 paletteSlot, u8 windowId)
     return sub_810C050(species, 0, 0, isFrontPic, paletteSlot, windowId, TRUE);
 }
 
-u16 sub_810C330(u16 species, bool8 isFrontPic, u16 destX, u16 destY, u8 paletteSlot, u8 windowId)
+u16 CreateTrainerCardTrainerPicSprite(u16 species, bool8 isFrontPic, u16 destX, u16 destY, u8 paletteSlot, u8 windowId)
 {
     return sub_810C0C0(species, 0, 0, isFrontPic, destX, destY, paletteSlot, windowId, TRUE);
 }
diff --git a/src/trainer_see.c b/src/trainer_see.c
new file mode 100644
index 000000000..3dbfbdf38
--- /dev/null
+++ b/src/trainer_see.c
@@ -0,0 +1,751 @@
+#include "global.h"
+#include "battle_setup.h"
+#include "event_object_movement.h"
+#include "field_effect.h"
+#include "field_player_avatar.h"
+#include "quest_log.h"
+#include "script.h"
+#include "task.h"
+#include "util.h"
+#include "constants/battle_setup.h"
+#include "constants/event_object_movement.h"
+#include "constants/event_objects.h"
+
+typedef u8 (*TrainerApproachFunc)(struct ObjectEvent *, s16, s16, s16);
+typedef bool8 (*TrainerSeeFunc)(u8, struct Task *, struct ObjectEvent *);
+
+/*static*/ bool8 CheckTrainer(u8 trainerObjId);
+/*static*/ u8 GetTrainerApproachDistance(struct ObjectEvent * trainerObj);
+/*static*/ u8 GetTrainerApproachDistanceSouth(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y);
+/*static*/ u8 GetTrainerApproachDistanceNorth(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y);
+/*static*/ u8 GetTrainerApproachDistanceWest(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y);
+/*static*/ u8 GetTrainerApproachDistanceEast(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y);
+/*static*/ u8 CheckPathBetweenTrainerAndPlayer(struct ObjectEvent * trainerObj, u8 approachDistance, u8 facingDirection);
+/*static*/ void TrainerApproachPlayer(struct ObjectEvent * trainerObj, u8 approachDistance);
+/*static*/ void Task_RunTrainerSeeFuncList(u8 taskId);
+/*static*/ bool8 TrainerSeeFunc_Dummy(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_StartExclMark(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_WaitExclMark(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_TrainerApproach(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_PrepareToEngage(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_End(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_BeginRemoveDisguise(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_WaitRemoveDisguise(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_TrainerInAshFacesPlayer(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_BeginJumpOutOfAsh(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_WaitJumpOutOfAsh(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_EndJumpOutOfAsh(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCreateCameraObj(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveUp(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveDown(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj);
+/*static*/ void Task_DestroyTrainerApproachTask(u8 taskId);
+/*static*/ void SpriteCB_TrainerIcons(struct Sprite * sprite);
+/*static*/ void SetIconSpriteData(struct Sprite *sprite, u16 fldEffId, u8 spriteAnimNum);
+
+/*static*/ const u16 sGfx_Emoticons[] = INCBIN_U16("graphics/object_events/emoticons.4bpp");
+
+// u8 func(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y)
+// range is the maximum distance the trainer can see
+// x and y are the player's coordinates
+// Returns distance to walk if trainer has unobstructed view of player
+// Returns 0 if trainer can't see player
+/*static*/ const TrainerApproachFunc sDirectionalApproachDistanceFuncs[] = {
+    GetTrainerApproachDistanceSouth,
+    GetTrainerApproachDistanceNorth,
+    GetTrainerApproachDistanceWest,
+    GetTrainerApproachDistanceEast
+};
+
+// bool8 func(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+// Returns TRUE to run the next func immediately
+// Returns FALSE to delay the next func to the next frame
+/*static*/ const TrainerSeeFunc sTrainerSeeFuncList[] = {
+    TrainerSeeFunc_Dummy,
+    TrainerSeeFunc_StartExclMark,
+    TrainerSeeFunc_WaitExclMark,
+    TrainerSeeFunc_TrainerApproach,
+    TrainerSeeFunc_PrepareToEngage,
+    TrainerSeeFunc_End,
+    TrainerSeeFunc_BeginRemoveDisguise,
+    TrainerSeeFunc_WaitRemoveDisguise,
+    TrainerSeeFunc_TrainerInAshFacesPlayer,
+    TrainerSeeFunc_BeginJumpOutOfAsh,
+    TrainerSeeFunc_WaitJumpOutOfAsh,
+    TrainerSeeFunc_EndJumpOutOfAsh,
+    TrainerSeeFunc_OffscreenAboveTrainerCreateCameraObj,
+    TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveUp,
+    TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveDown
+};
+
+/*static*/ const TrainerSeeFunc sTrainerSeeFuncList2[] = {
+    TrainerSeeFunc_TrainerInAshFacesPlayer,
+    TrainerSeeFunc_BeginJumpOutOfAsh,
+    TrainerSeeFunc_WaitJumpOutOfAsh,
+    TrainerSeeFunc_EndJumpOutOfAsh
+};
+
+bool8 CheckForTrainersWantingBattle(void)
+{
+    u8 i;
+    if (sub_8111C2C() == TRUE)
+        return FALSE;
+
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (gObjectEvents[i].active
+         && (
+             gObjectEvents[i].trainerType == 1
+          || gObjectEvents[i].trainerType == 3
+         )
+         && CheckTrainer(i)
+      )
+            return TRUE;
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 CheckTrainer(u8 trainerObjId)
+{
+    const u8 *script = GetObjectEventScriptPointerByObjectEventId(trainerObjId);
+    u8 approachDistance;
+    if (GetTrainerFlagFromScriptPointer(script))
+        return FALSE;
+    approachDistance = GetTrainerApproachDistance(&gObjectEvents[trainerObjId]);
+    if (approachDistance != 0)
+    {
+        if (script[1] == TRAINER_BATTLE_DOUBLE && GetMonsStateToDoubles())
+            return FALSE;
+        ConfigureAndSetUpOneTrainerBattle(trainerObjId, script);
+        TrainerApproachPlayer(&gObjectEvents[trainerObjId], approachDistance - 1);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+/*static*/ u8 GetTrainerApproachDistance(struct ObjectEvent *trainerObj)
+{
+    s16 x, y;
+    u8 i;
+    u8 approachDistance;
+
+    PlayerGetDestCoords(&x, &y);
+    if (trainerObj->trainerType == 1)  // can only see in one direction
+    {
+        approachDistance = sDirectionalApproachDistanceFuncs[trainerObj->facingDirection - 1](trainerObj, trainerObj->trainerRange_berryTreeId, x, y);
+        return CheckPathBetweenTrainerAndPlayer(trainerObj, approachDistance, trainerObj->facingDirection);
+    }
+    else  // can see in all directions
+    {
+        for (i = 0; i < 4; i++)
+        {
+            approachDistance = sDirectionalApproachDistanceFuncs[i](trainerObj, trainerObj->trainerRange_berryTreeId, x, y);
+            if (CheckPathBetweenTrainerAndPlayer(trainerObj, approachDistance, i + 1)) // directions are 1-4 instead of 0-3. south north west east
+                return approachDistance;
+        }
+    }
+
+    return 0;
+}
+
+// Returns how far south the player is from trainer. 0 if out of trainer's sight.
+/*static*/ u8 GetTrainerApproachDistanceSouth(struct ObjectEvent *trainerObj, s16 range, s16 x, s16 y)
+{
+    if (trainerObj->currentCoords.x == x
+        && y > trainerObj->currentCoords.y
+        && y <= trainerObj->currentCoords.y + range)
+    {
+        if (range > 3 && GetFirstInactiveObjectEventId() == OBJECT_EVENTS_COUNT)
+            return 0;
+        return (y - trainerObj->currentCoords.y);
+    }
+    else
+        return 0;
+}
+
+// Returns how far north the player is from trainer. 0 if out of trainer's sight.
+/*static*/ u8 GetTrainerApproachDistanceNorth(struct ObjectEvent *trainerObj, s16 range, s16 x, s16 y)
+{
+    if (trainerObj->currentCoords.x == x
+        && y < trainerObj->currentCoords.y
+        && y >= trainerObj->currentCoords.y - range)
+        return (trainerObj->currentCoords.y - y);
+    else
+        return 0;
+}
+
+// Returns how far west the player is from trainer. 0 if out of trainer's sight.
+/*static*/ u8 GetTrainerApproachDistanceWest(struct ObjectEvent *trainerObj, s16 range, s16 x, s16 y)
+{
+    if (trainerObj->currentCoords.y == y
+        && x < trainerObj->currentCoords.x
+        && x >= trainerObj->currentCoords.x - range)
+        return (trainerObj->currentCoords.x - x);
+    else
+        return 0;
+}
+
+// Returns how far east the player is from trainer. 0 if out of trainer's sight.
+/*static*/ u8 GetTrainerApproachDistanceEast(struct ObjectEvent *trainerObj, s16 range, s16 x, s16 y)
+{
+    if (trainerObj->currentCoords.y == y
+        && x > trainerObj->currentCoords.x
+        && x <= trainerObj->currentCoords.x + range)
+        return (x - trainerObj->currentCoords.x);
+    else
+        return 0;
+}
+
+#define COLLISION_MASK (~1)
+
+/*static*/ u8 CheckPathBetweenTrainerAndPlayer(struct ObjectEvent *trainerObj, u8 approachDistance, u8 direction)
+{
+    s16 x, y;
+    u8 unk19_temp;
+    u8 unk19b_temp;
+    u8 i;
+    u8 collision;
+
+    if (approachDistance == 0)
+        return 0;
+
+    x = trainerObj->currentCoords.x;
+    y = trainerObj->currentCoords.y;
+
+    for (i = 0; i <= approachDistance - 1; i++, MoveCoords(direction, &x, &y))
+    {
+        collision = GetCollisionFlagsAtCoords(trainerObj, x, y, direction);
+        if (collision != 0 && (collision & COLLISION_MASK))
+            return 0;
+    }
+
+    // preserve mapobj_unk_19 before clearing.
+    unk19_temp = trainerObj->range.as_nybbles.x;
+    unk19b_temp = trainerObj->range.as_nybbles.y;
+    trainerObj->range.as_nybbles.x = 0;
+    trainerObj->range.as_nybbles.y = 0;
+
+    collision = GetCollisionAtCoords(trainerObj, x, y, direction);
+
+    trainerObj->range.as_nybbles.x = unk19_temp;
+    trainerObj->range.as_nybbles.y = unk19b_temp;
+    if (collision == 4)
+        return approachDistance;
+
+    return 0;
+}
+
+#define tFuncId             data[0]
+#define tTrainerObjHi       data[1]
+#define tTrainerObjLo       data[2]
+#define tTrainerRange       data[3]
+#define tOutOfAshSpriteId   data[4]
+#define tData5              data[5]
+
+#define TaskGetTrainerObj(dest, task) do { \
+    (dest) = (struct ObjectEvent *)(((task)->tTrainerObjHi << 16) | ((u16)(task)->tTrainerObjLo)); \
+} while (0)
+
+/*static*/ void TrainerApproachPlayer(struct ObjectEvent * trainerObj, u8 approachDistance)
+{
+    u8 taskId = CreateTask(Task_RunTrainerSeeFuncList, 80);
+    struct Task * task = &gTasks[taskId];
+    task->tTrainerObjHi = ((uintptr_t)trainerObj) >> 16;
+    task->tTrainerObjLo = (uintptr_t)trainerObj;
+    task->tTrainerRange = approachDistance;
+}
+
+/*static*/ void StartTrainerApproachWithFollowupTask(TaskFunc taskFunc)
+{
+    u8 taskId = FindTaskIdByFunc(Task_RunTrainerSeeFuncList);
+    SetTaskFuncWithFollowupFunc(taskId, Task_RunTrainerSeeFuncList, taskFunc);
+    gTasks[taskId].tFuncId = 1;
+    Task_RunTrainerSeeFuncList(taskId);
+}
+
+/*static*/ void Task_RunTrainerSeeFuncList(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    struct ObjectEvent * trainerObj;
+    TaskGetTrainerObj(trainerObj, task);
+
+    if (!trainerObj->active)
+    {
+        SwitchTaskToFollowupFunc(taskId);
+    }
+    else
+    {
+        while (sTrainerSeeFuncList[task->tFuncId](taskId, task, trainerObj))
+            ;
+    }
+}
+
+// TrainerSeeFuncs
+
+/*static*/ bool8 TrainerSeeFunc_Dummy(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_StartExclMark(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    u8 action;
+    // FRLG introduces trainers who can see the player from offscreen above.
+    // Handle this case here.
+    if (trainerObj->facingDirection == DIR_SOUTH && task->tTrainerRange > 2)
+    {
+        task->tFuncId = 12;
+    }
+    else
+    {
+        ObjectEventGetLocalIdAndMap(trainerObj, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
+        FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON);
+        action = GetFaceDirectionMovementAction(trainerObj->facingDirection);
+        ObjectEventSetHeldMovement(trainerObj, action);
+        task->tFuncId++;
+    }
+    return TRUE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_WaitExclMark(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (FieldEffectActiveListContains(FLDEFF_EXCLAMATION_MARK_ICON))
+    {
+        return FALSE;
+    }
+    else
+    {
+        task->tFuncId++;
+        if (trainerObj->movementType  == MOVEMENT_TYPE_TREE_DISGUISE || trainerObj->movementType  == MOVEMENT_TYPE_MOUNTAIN_DISGUISE)
+            task->tFuncId = 6;
+        if (trainerObj->movementType  == MOVEMENT_TYPE_HIDDEN)
+            task->tFuncId = 8;
+        return TRUE;
+    }
+}
+
+/*static*/ bool8 TrainerSeeFunc_TrainerApproach(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (!ObjectEventIsMovementOverridden(trainerObj) || ObjectEventClearHeldMovementIfFinished(trainerObj))
+    {
+        if (task->tTrainerRange)
+        {
+            ObjectEventSetHeldMovement(trainerObj, GetWalkNormalMovementAction(trainerObj->facingDirection));
+            task->tTrainerRange--;
+        }
+        else
+        {
+            ObjectEventSetHeldMovement(trainerObj, MOVEMENT_ACTION_FACE_PLAYER);
+            task->tFuncId++;
+        }
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_PrepareToEngage(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    struct ObjectEvent *playerObj;
+
+    if (ObjectEventIsMovementOverridden(trainerObj) && !ObjectEventClearHeldMovementIfFinished(trainerObj))
+        return FALSE;
+
+    SetTrainerMovementType(trainerObj, GetTrainerFacingDirectionMovementType(trainerObj->facingDirection));
+    OverrideMovementTypeForObjectEvent(trainerObj, GetTrainerFacingDirectionMovementType(trainerObj->facingDirection));
+    OverrideTemplateCoordsForObjectEvent(trainerObj);
+
+    playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+    if (ObjectEventIsMovementOverridden(playerObj) && !ObjectEventClearHeldMovementIfFinished(playerObj))
+        return FALSE;
+
+    sub_805C774();
+    // Uncomment to have player turn to face their opponent
+    // ObjectEventSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], GetFaceDirectionMovementAction(GetOppositeDirection(trainerObj->facingDirection)));
+    task->tFuncId++;
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_End(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    struct ObjectEvent *playerObj = &gObjectEvents[gPlayerAvatar.objectEventId];
+
+    if (!ObjectEventIsMovementOverridden(playerObj)
+        || ObjectEventClearHeldMovementIfFinished(playerObj))
+        SwitchTaskToFollowupFunc(taskId); // This ends the trainer walk routine.
+    return FALSE;
+}
+
+// Jumps here if disguised. Not used in FRLG.
+/*static*/ bool8 TrainerSeeFunc_BeginRemoveDisguise(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (!ObjectEventIsMovementOverridden(trainerObj)
+     || ObjectEventClearHeldMovementIfFinished(trainerObj))
+    {
+        ObjectEventSetHeldMovement(trainerObj, MOVEMENT_ACTION_REVEAL_TRAINER);
+        task->tFuncId++;
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_WaitRemoveDisguise(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (ObjectEventClearHeldMovementIfFinished(trainerObj))
+        task->tFuncId = 3;
+
+    return FALSE;
+}
+
+// Jump here if hidden in ash. Not used in FRLG.
+/*static*/ bool8 TrainerSeeFunc_TrainerInAshFacesPlayer(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (!ObjectEventIsMovementOverridden(trainerObj)
+        || ObjectEventClearHeldMovementIfFinished(trainerObj))
+    {
+        ObjectEventSetHeldMovement(trainerObj, MOVEMENT_ACTION_FACE_PLAYER);
+        task->tFuncId++;
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_BeginJumpOutOfAsh(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    if (ObjectEventCheckHeldMovementStatus(trainerObj))
+    {
+        gFieldEffectArguments[0] = trainerObj->currentCoords.x;
+        gFieldEffectArguments[1] = trainerObj->currentCoords.y;
+        gFieldEffectArguments[2] = gSprites[trainerObj->spriteId].subpriority - 1;
+        gFieldEffectArguments[3] = 2;
+        task->tOutOfAshSpriteId = FieldEffectStart(FLDEFF_POP_OUT_OF_ASH);
+        task->tFuncId++;
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_WaitJumpOutOfAsh(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    struct Sprite *sprite;
+
+    if (gSprites[task->tOutOfAshSpriteId].animCmdIndex == 2)
+    {
+        trainerObj->fixedPriority = FALSE;
+        trainerObj->triggerGroundEffectsOnMove = TRUE;
+
+        sprite = &gSprites[trainerObj->spriteId];
+        sprite->oam.priority = 2;
+        ObjectEventClearHeldMovementIfFinished(trainerObj);
+        ObjectEventSetHeldMovement(trainerObj, GetJumpInPlaceMovementAction(trainerObj->facingDirection));
+        task->tFuncId++;
+    }
+
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_EndJumpOutOfAsh(u8 taskId, struct Task *task, struct ObjectEvent *trainerObj)
+{
+    if (!FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH))
+        task->tFuncId = 3;
+
+    return FALSE;
+}
+
+// FRLG exclusive: Scroll the camera up to reveal an offscreen above trainer
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCreateCameraObj(u8 taskId, struct Task *task, struct ObjectEvent *trainerObj)
+{
+    int specialObjectId;
+    task->tData5 = 0;
+    specialObjectId = SpawnSpecialObjectEventParameterized(OBJ_EVENT_GFX_YOUNGSTER, 7, OBJ_EVENT_ID_CAMERA, gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7, 3);
+    gObjectEvents[specialObjectId].invisible = TRUE;
+    CameraObjectSetFollowedObjectId(gObjectEvents[specialObjectId].spriteId);
+    task->tFuncId++;
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveUp(u8 taskId, struct Task *task, struct ObjectEvent *trainerObj)
+{
+    u8 specialObjectId;
+    TryGetObjectEventIdByLocalIdAndMap(OBJ_EVENT_ID_CAMERA, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &specialObjectId);
+
+    if (ObjectEventIsMovementOverridden(&gObjectEvents[specialObjectId]) && !ObjectEventClearHeldMovementIfFinished(&gObjectEvents[specialObjectId]))
+        return FALSE;
+
+    if (task->tData5 != task->tTrainerRange - 1)
+    {
+        ObjectEventSetHeldMovement(&gObjectEvents[specialObjectId], GetWalkFastMovementAction(DIR_NORTH));
+        task->tData5++;
+    }
+    else
+    {
+        ObjectEventGetLocalIdAndMap(trainerObj, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
+        FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON);
+        task->tData5 = 0;
+        task->tFuncId++;
+    }
+    return FALSE;
+}
+
+/*static*/ bool8 TrainerSeeFunc_OffscreenAboveTrainerCameraObjMoveDown(u8 taskId, struct Task * task, struct ObjectEvent * trainerObj)
+{
+    u8 specialObjectId;
+    TryGetObjectEventIdByLocalIdAndMap(OBJ_EVENT_ID_CAMERA, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &specialObjectId);
+
+    if (FieldEffectActiveListContains(FLDEFF_EXCLAMATION_MARK_ICON))
+        return FALSE;
+
+    if (ObjectEventIsMovementOverridden(&gObjectEvents[specialObjectId]) && !ObjectEventClearHeldMovementIfFinished(&gObjectEvents[specialObjectId]))
+        return FALSE;
+
+    if (task->tData5 != task->tTrainerRange - 1)
+    {
+        ObjectEventSetHeldMovement(&gObjectEvents[specialObjectId], GetWalkFastMovementAction(DIR_SOUTH));
+        task->tData5++;
+    }
+    else
+    {
+        CameraObjectSetFollowedObjectId(GetPlayerAvatarObjectId());
+        RemoveObjectEventByLocalIdAndMap(OBJ_EVENT_ID_CAMERA, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+        task->tData5 = 0;
+        task->tFuncId = 2;
+    }
+    return FALSE;
+}
+
+#undef tData5
+#undef tOutOfAshSpriteId
+#undef tTrainerRange
+#undef tTrainerObjLo
+#undef tTrainerObjHi
+#undef tFuncId
+
+/*static*/ void Task_RevealTrainer_RunTrainerSeeFuncList(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    struct ObjectEvent * trainerObj;
+
+    // another objEvent loaded into by loadword?
+    LoadWordFromTwoHalfwords((u16 *)&task->data[1], (uintptr_t *)&trainerObj);
+    if (!task->data[7])
+    {
+        ObjectEventClearHeldMovement(trainerObj);
+        task->data[7]++;
+    }
+    sTrainerSeeFuncList2[task->data[0]](taskId, task, trainerObj);
+    if (task->data[0] == 3 && !FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH))
+    {
+        SetTrainerMovementType(trainerObj, GetTrainerFacingDirectionMovementType(trainerObj->facingDirection));
+        OverrideMovementTypeForObjectEvent(trainerObj, GetTrainerFacingDirectionMovementType(trainerObj->facingDirection));
+        DestroyTask(taskId);
+    }
+    else
+    {
+        trainerObj->heldMovementFinished = FALSE;
+    }
+}
+
+void MovementAction_RevealTrainer_RunTrainerSeeFuncList(struct ObjectEvent *var)
+{
+    StoreWordInTwoHalfwords((u16 *)&gTasks[CreateTask(Task_RevealTrainer_RunTrainerSeeFuncList, 0)].data[1], (u32)var);
+}
+
+void EndTrainerApproach(void)
+{
+    StartTrainerApproachWithFollowupTask(Task_DestroyTrainerApproachTask);
+}
+
+/*static*/ void Task_DestroyTrainerApproachTask(u8 taskId)
+{
+    DestroyTask(taskId);
+    EnableBothScriptContexts();
+}
+
+// Trainer See Excl Mark Field Effect
+
+#define sLocalId    data[0]
+#define sMapNum     data[1]
+#define sMapGroup   data[2]
+#define sData3      data[3]
+#define sData4      data[4]
+#define sFldEffId   data[7]
+
+/*static*/ const struct OamData sOamData_Emoticons = {
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .mosaic = 0,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .matrixNum = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+/*static*/ const struct SpriteFrameImage sSpriteImages_Emoticons[] = {
+    {sGfx_Emoticons + 0x000, 0x80},
+    {sGfx_Emoticons + 0x040, 0x80},
+    {sGfx_Emoticons + 0x080, 0x80},
+
+    {sGfx_Emoticons + 0x180, 0x80},
+    {sGfx_Emoticons + 0x1C0, 0x80},
+    {sGfx_Emoticons + 0x200, 0x80},
+
+    {sGfx_Emoticons + 0x0C0, 0x80},
+    {sGfx_Emoticons + 0x100, 0x80},
+    {sGfx_Emoticons + 0x140, 0x80},
+
+    {sGfx_Emoticons + 0x240, 0x80},
+    {sGfx_Emoticons + 0x280, 0x80},
+    {sGfx_Emoticons + 0x2C0, 0x80},
+
+    {sGfx_Emoticons + 0x300, 0x80},
+    {sGfx_Emoticons + 0x340, 0x80},
+    {sGfx_Emoticons + 0x380, 0x80},
+};
+
+/*static*/ const union AnimCmd sAnimCmd_ExclamationMark1[] = {
+    ANIMCMD_FRAME( 0,  4),
+    ANIMCMD_FRAME( 1,  4),
+    ANIMCMD_FRAME( 2, 52),
+    ANIMCMD_END
+};
+
+/*static*/ const union AnimCmd sAnimCmd_DoubleExclMark[] = {
+    ANIMCMD_FRAME( 6,  4),
+    ANIMCMD_FRAME( 7,  4),
+    ANIMCMD_FRAME( 8, 52),
+    ANIMCMD_END
+};
+
+/*static*/ const union AnimCmd sAnimCmd_X[] = {
+    ANIMCMD_FRAME( 3,  4),
+    ANIMCMD_FRAME( 4,  4),
+    ANIMCMD_FRAME( 5, 52),
+    ANIMCMD_END
+};
+
+/*static*/ const union AnimCmd sAnimCmd_SmileyFace[] = {
+    ANIMCMD_FRAME( 9,  4),
+    ANIMCMD_FRAME(10,  4),
+    ANIMCMD_FRAME(11, 52),
+    ANIMCMD_END
+};
+
+/*static*/ const union AnimCmd sAnimCmd_QuestionMark[] = {
+    ANIMCMD_FRAME(12,  4),
+    ANIMCMD_FRAME(13,  4),
+    ANIMCMD_FRAME(14, 52),
+    ANIMCMD_END
+};
+
+/*static*/ const union AnimCmd *const sSpriteAnimTable_Emoticons[] = {
+    sAnimCmd_ExclamationMark1,
+    sAnimCmd_DoubleExclMark,
+    sAnimCmd_X,
+    sAnimCmd_SmileyFace,
+    sAnimCmd_QuestionMark
+};
+
+/*static*/ const struct SpriteTemplate sSpriteTemplate_Emoticons = {
+    .tileTag = 0xFFFF,
+    .paletteTag = 0xFFFF,
+    .oam = &sOamData_Emoticons,
+    .anims = sSpriteAnimTable_Emoticons,
+    .images = sSpriteImages_Emoticons,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_TrainerIcons
+};
+
+u8 FldEff_ExclamationMarkIcon1(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&sSpriteTemplate_Emoticons, 0, 0, 0x53);
+
+    if (spriteId != MAX_SPRITES)
+        SetIconSpriteData(&gSprites[spriteId], FLDEFF_EXCLAMATION_MARK_ICON, 0);
+
+    return 0;
+}
+
+u8 FldEff_DoubleExclMarkIcon(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&sSpriteTemplate_Emoticons, 0, 0, 0x52);
+
+    if (spriteId != MAX_SPRITES)
+        SetIconSpriteData(&gSprites[spriteId], FLDEFF_DOUBLE_EXCL_MARK_ICON, 1);
+
+    return 0;
+}
+
+u8 FldEff_XIcon(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&sSpriteTemplate_Emoticons, 0, 0, 0x52);
+
+    if (spriteId != MAX_SPRITES)
+        SetIconSpriteData(&gSprites[spriteId], FLDEFF_X_ICON, 2);
+
+    return 0;
+}
+
+u8 FldEff_SmileyFaceIcon(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&sSpriteTemplate_Emoticons, 0, 0, 0x52);
+
+    if (spriteId != MAX_SPRITES)
+        SetIconSpriteData(&gSprites[spriteId], FLDEFF_SMILEY_FACE_ICON, 3);
+
+    return 0;
+}
+
+u8 FldEff_QuestionMarkIcon(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&sSpriteTemplate_Emoticons, 0, 0, 0x52);
+
+    if (spriteId != MAX_SPRITES)
+        SetIconSpriteData(&gSprites[spriteId], FLDEFF_QUESTION_MARK_ICON, 4);
+
+    return 0;
+}
+
+/*static*/ void SetIconSpriteData(struct Sprite *sprite, u16 fldEffId, u8 spriteAnimNum)
+{
+    sprite->oam.priority = 1;
+    sprite->coordOffsetEnabled = 1;
+
+    sprite->sLocalId = gFieldEffectArguments[0];
+    sprite->sMapNum = gFieldEffectArguments[1];
+    sprite->sMapGroup = gFieldEffectArguments[2];
+    sprite->sData3 = -5;
+    sprite->sFldEffId = fldEffId;
+
+    StartSpriteAnim(sprite, spriteAnimNum);
+}
+
+/*static*/ void SpriteCB_TrainerIcons(struct Sprite *sprite)
+{
+    u8 objEventId;
+
+    if (TryGetObjectEventIdByLocalIdAndMap(sprite->sLocalId, sprite->sMapNum, sprite->sMapGroup, &objEventId)
+        || sprite->animEnded)
+    {
+        FieldEffectStop(sprite, sprite->sFldEffId);
+    }
+    else
+    {
+        struct Sprite *objEventSprite = &gSprites[gObjectEvents[objEventId].spriteId];
+        sprite->sData4 += sprite->sData3;
+        sprite->pos1.x = objEventSprite->pos1.x;
+        sprite->pos1.y = objEventSprite->pos1.y - 16;
+        sprite->pos2.x = objEventSprite->pos2.x;
+        sprite->pos2.y = objEventSprite->pos2.y + sprite->sData4;
+        if (sprite->sData4)
+            sprite->sData3++;
+        else
+            sprite->sData3 = 0;
+    }
+}
+
+#undef sLocalId
+#undef sMapNum
+#undef sMapGroup
+#undef sData3
+#undef sData4
+#undef sFldEffId
diff --git a/src/trainer_tower.c b/src/trainer_tower.c
index 60c6fd93d..0c673b5aa 100644
--- a/src/trainer_tower.c
+++ b/src/trainer_tower.c
@@ -2,11 +2,9 @@
 #include "main.h"
 #include "task.h"
 #include "malloc.h"
-#include "save.h"
 #include "util.h"
 #include "string_util.h"
 #include "event_data.h"
-#include "random.h"
 #include "cereader_tool.h"
 #include "easy_chat.h"
 #include "text.h"
@@ -20,25 +18,26 @@
 #include "menu.h"
 #include "new_menu_helpers.h"
 #include "sound.h"
-#include "renewable_hidden_items.h"
-#include "constants/flags.h"
 #include "constants/vars.h"
 #include "constants/items.h"
 #include "constants/species.h"
-#include "constants/maps.h"
 #include "constants/songs.h"
 #include "constants/layouts.h"
 #include "constants/trainers.h"
 #include "constants/facility_trainer_classes.h"
-#include "constants/object_events.h"
+#include "constants/event_objects.h"
+#include "constants/trainer_tower.h"
+
+#define CURR_FLOOR sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx]
+#define TRAINER_TOWER gSaveBlock1Ptr->trainerTower[gSaveBlock1Ptr->towerChallengeId]
 
 struct UnkStruct_203F458
 {
     /* 0x0000 */ u8 floorIdx;
-    /* 0x0004 */ struct EReaderTrainerHillSet unk_0004;
+    /* 0x0004 */ struct EReaderTrainerTowerSet unk_0004;
 };
 
-struct UnkStruct_203F45C
+struct TrainerTowerOpponent
 {
     /* 0x00 */ u8 name[11];
     /* 0x0C */ u16 speechWin[6];
@@ -52,15 +51,15 @@ struct UnkStruct_203F45C
 
 struct SinglesTrainerInfo
 {
-    u8 mapObjGfx;
+    u8 objGfx;
     u8 facilityClass;
     bool8 gender;
 };
 
 struct DoublesTrainerInfo
 {
-    u8 mapObjGfx1;
-    u8 mapObjGfx2;
+    u8 objGfx1;
+    u8 objGfx2;
     u8 facilityClass;
     bool8 gender1;
     bool8 gender2;
@@ -68,147 +67,147 @@ struct DoublesTrainerInfo
 
 struct TrainerEncounterMusicPairs
 {
-    u8 unk0;
-    u8 unk1;
+    u8 facilityClass;
+    u8 musicId;
 };
 
 static EWRAM_DATA struct UnkStruct_203F458 * sTrainerTowerState = NULL;
-static EWRAM_DATA struct UnkStruct_203F45C * sTrainerTowerOpponent = NULL;
+static EWRAM_DATA struct TrainerTowerOpponent * sTrainerTowerOpponent = NULL;
 static EWRAM_DATA u8 sUnused_203F460 = 0;
 
-static void sub_815DC8C(void);  // setup
-static void sub_815DD2C(void);  // teardown
-static void sub_815DD44(void);
+static void SetUpTrainerTowerDataStruct(void);
+static void FreeTrainerTowerDataStruct(void);
+static void InitTrainerTowerFloor(void);
 static void SetTrainerTowerNPCGraphics(void);
 static void TT_ConvertEasyChatMessageToString(u16 *ecWords, u8 *dest);
-static void sub_815DF54(void);
+static void BufferTowerOpponentSpeech(void);
 static void TrainerTowerGetOpponentTextColor(u8 battleType, u8 facilityClass);
-static void sub_815E160(void);
-static void sub_815E1C0(void);
-static void sub_815E1F0(void);
-static void TTSpecial_HasReachedTheRoof(void);
-static void sub_815E28C(void);
-static void sub_815E394(void);
-static void sub_815E408(void);
-static void sub_815E4B0(void);
-static void TTSpecial_StartTimer(void);
-static void sub_815E5C4(void);
-static void sub_815E5F0(void);
-static void sub_815E658(void);
-static void sub_815E720(void);
-static void sub_815E88C(void);
-static void sub_815E8B4(void);
-static void sub_815E8CC(void);
-static void sub_815E908(void);
-static void sub_815E948(void);
-static void sub_815E9C8(void);
+static void DoTrainerTowerBattle(void);
+static void TrainerTowerGetChallengeType(void);
+static void TrainerTowerAddFloorCleared(void);
+static void GetFloorAlreadyCleared(void);
+static void StartTrainerTowerChallenge(void);
+static void GetOwnerState(void);
+static void GiveChallengePrize(void);
+static void CheckFinalTime(void);
+static void TrainerTowerResumeTimer(void);
+static void TrainerTowerSetPlayerLost(void);
+static void GetTrainerTowerChallengeStatus(void);
+static void GetCurrentTime(void);
+static void ShowResultsBoard(void);
+static void CloseResultsBoard(void);
+static void TrainerTowerGetDoublesEligiblity(void);
+static void TrainerTowerGetNumFloors(void);
+static void ShouldWarpToCounter(void);
+static void PlayTrainerTowerEncounterMusic(void);
+static void HasSpokenToOwner(void);
 static void BuildEnemyParty(void);
 static s32 GetPartyMaxLevel(void);
 static void ValidateOrResetCurTrainerTowerRecord(void);
 static u32 GetTrainerTowerRecordTime(u32 *);
 static void SetTrainerTowerRecordTime(u32 *, u32);
 
-extern const u8 gUnknown_83FE982[];
-extern const u8 gUnknown_83FE998[];
-extern const u8 *const gUnknown_83FE9C4[];
+extern const u8 gText_TimeBoard[];
+extern const u8 gText_XMinYZSec[];
+extern const u8 *const gTrainerTowerChallengeTypeTexts[];
 
 static const struct SinglesTrainerInfo sSingleBattleTrainerInfo[] = {
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_AROMA_LADY,       FEMALE},
-    {OBJECT_EVENT_GFX_HIKER,          FACILITY_CLASS_RUIN_MANIAC,      MALE},
-    {OBJECT_EVENT_GFX_TUBER_F,        FACILITY_CLASS_TUBER,            FEMALE},
-    {OBJECT_EVENT_GFX_TUBER_M_2,      FACILITY_CLASS_TUBER_2,          MALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_COOLTRAINER,      MALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOLTRAINER_2,    FEMALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_HEX_MANIAC,       MALE},
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_LADY,             FEMALE},
-    {OBJECT_EVENT_GFX_BEAUTY,         FACILITY_CLASS_BEAUTY,           FEMALE},
-    {OBJECT_EVENT_GFX_BOY,            FACILITY_CLASS_RICH_BOY,         MALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_POKEMANIAC,       MALE},
-    {OBJECT_EVENT_GFX_SWIMMER_M_LAND, FACILITY_CLASS_SWIMMER_MALE,     MALE},
-    {OBJECT_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_BLACK_BELT,       MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_GUITARIST,        MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_KINDLER,          MALE},
-    {OBJECT_EVENT_GFX_CAMPER,         FACILITY_CLASS_CAMPER,           MALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_BUG_MANIAC,       MALE},
-    {OBJECT_EVENT_GFX_BOY,            FACILITY_CLASS_PSYCHIC,          MALE},
-    {OBJECT_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_PSYCHIC_2,        FEMALE},
-    {OBJECT_EVENT_GFX_GENTLEMAN,      FACILITY_CLASS_GENTLEMAN,        MALE},
-    {OBJECT_EVENT_GFX_BOY,            FACILITY_CLASS_SCHOOL_KID,       MALE},
-    {OBJECT_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_SCHOOL_KID_2,     FEMALE},
-    {OBJECT_EVENT_GFX_BALDING_MAN,    FACILITY_CLASS_POKEFAN,          MALE},
-    {OBJECT_EVENT_GFX_WOMAN_3,        FACILITY_CLASS_POKEFAN_2,        FEMALE},
-    {OBJECT_EVENT_GFX_OLD_MAN_1,      FACILITY_CLASS_EXPERT,           MALE},
-    {OBJECT_EVENT_GFX_OLD_WOMAN,      FACILITY_CLASS_EXPERT_2,         FEMALE},
-    {OBJECT_EVENT_GFX_YOUNGSTER,      FACILITY_CLASS_YOUNGSTER,        MALE},
-    {OBJECT_EVENT_GFX_FISHER,         FACILITY_CLASS_FISHERMAN,        MALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_DRAGON_TAMER,     MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_BIRD_KEEPER,      MALE},
-    {OBJECT_EVENT_GFX_LITTLE_BOY,     FACILITY_CLASS_NINJA_BOY,        MALE},
-    {OBJECT_EVENT_GFX_BATTLE_GIRL,    FACILITY_CLASS_BATTLE_GIRL,      FEMALE},
-    {OBJECT_EVENT_GFX_BEAUTY,         FACILITY_CLASS_PARASOL_LADY,     FEMALE},
-    {OBJECT_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SWIMMER_FEMALE,   FEMALE},
-    {OBJECT_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PICNICKER,        FEMALE},
-    {OBJECT_EVENT_GFX_SAILOR,         FACILITY_CLASS_SAILOR,           MALE},
-    {OBJECT_EVENT_GFX_FAT_MAN,        FACILITY_CLASS_COLLECTOR,        MALE},
-    {OBJECT_EVENT_GFX_MAN,            FACILITY_CLASS_PKMN_BREEDER,     MALE},
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_PKMN_BREEDER_2,   FEMALE},
-    {OBJECT_EVENT_GFX_CAMPER,         FACILITY_CLASS_PKMN_RANGER,      MALE},
-    {OBJECT_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PKMN_RANGER_2,    FEMALE},
-    {OBJECT_EVENT_GFX_LASS,           FACILITY_CLASS_LASS,             FEMALE},
-    {OBJECT_EVENT_GFX_BUG_CATCHER,    FACILITY_CLASS_BUG_CATCHER,      MALE},
-    {OBJECT_EVENT_GFX_HIKER,          FACILITY_CLASS_HIKER,            MALE},
-    {OBJECT_EVENT_GFX_YOUNGSTER,      FACILITY_CLASS_YOUNGSTER_2,      MALE},
-    {OBJECT_EVENT_GFX_BUG_CATCHER,    FACILITY_CLASS_BUG_CATCHER_2,    MALE},
-    {OBJECT_EVENT_GFX_LASS,           FACILITY_CLASS_LASS_2,           FEMALE},
-    {OBJECT_EVENT_GFX_SAILOR,         FACILITY_CLASS_SAILOR_2,         MALE},
-    {OBJECT_EVENT_GFX_CAMPER,         FACILITY_CLASS_CAMPER_2,         MALE},
-    {OBJECT_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PICNICKER_2,      FEMALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_POKEMANIAC_2,     MALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_SUPER_NERD,       MALE},
-    {OBJECT_EVENT_GFX_HIKER,          FACILITY_CLASS_HIKER_2,          MALE},
-    {OBJECT_EVENT_GFX_BIKER,          FACILITY_CLASS_BIKER,            MALE},
-    {OBJECT_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_BURGLAR,          MALE},
-    {OBJECT_EVENT_GFX_BALDING_MAN,    FACILITY_CLASS_ENGINEER,         MALE},
-    {OBJECT_EVENT_GFX_FISHER,         FACILITY_CLASS_FISHERMAN_2,      MALE},
-    {OBJECT_EVENT_GFX_SWIMMER_M_LAND, FACILITY_CLASS_SWIMMER_MALE_2,   MALE},
-    {OBJECT_EVENT_GFX_BIKER,          FACILITY_CLASS_CUE_BALL,         MALE},
-    {OBJECT_EVENT_GFX_OLD_MAN_1,      FACILITY_CLASS_GAMER,            MALE},
-    {OBJECT_EVENT_GFX_BEAUTY,         FACILITY_CLASS_BEAUTY_2,         FEMALE},
-    {OBJECT_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SWIMMER_FEMALE_2, FEMALE},
-    {OBJECT_EVENT_GFX_BOY,            FACILITY_CLASS_PSYCHIC_3,        MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_ROCKER,           MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_JUGGLER,          MALE},
-    {OBJECT_EVENT_GFX_MAN,            FACILITY_CLASS_TAMER,            MALE},
-    {OBJECT_EVENT_GFX_ROCKER,         FACILITY_CLASS_BIRD_KEEPER_2,    MALE},
-    {OBJECT_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_BLACK_BELT_2,     MALE},
-    {OBJECT_EVENT_GFX_SCIENTIST,      FACILITY_CLASS_SCIENTIST,        MALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_COOLTRAINER_3,    MALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOLTRAINER_4,    FEMALE},
-    {OBJECT_EVENT_GFX_GENTLEMAN,      FACILITY_CLASS_GENTLEMAN_2,      MALE},
-    {OBJECT_EVENT_GFX_CHANNELER,      FACILITY_CLASS_CHANNELER,        FEMALE},
-    {OBJECT_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_PSYCHIC_4,        FEMALE},
-    {OBJECT_EVENT_GFX_BATTLE_GIRL,    FACILITY_CLASS_CRUSH_GIRL,       FEMALE},
-    {OBJECT_EVENT_GFX_TUBER_F,        FACILITY_CLASS_TUBER_3,          FEMALE},
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_PKMN_BREEDER_3,   FEMALE},
-    {OBJECT_EVENT_GFX_CAMPER,         FACILITY_CLASS_PKMN_RANGER_3,    MALE},
-    {OBJECT_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PKMN_RANGER_4,    FEMALE},
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_AROMA_LADY_2,     FEMALE},
-    {OBJECT_EVENT_GFX_HIKER,          FACILITY_CLASS_RUIN_MANIAC_2,    MALE},
-    {OBJECT_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_LADY_2,           FEMALE},
-    {OBJECT_EVENT_GFX_LASS,           FACILITY_CLASS_PAINTER,          FEMALE}
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_AROMA_LADY,       FEMALE},
+    {OBJ_EVENT_GFX_HIKER,          FACILITY_CLASS_RUIN_MANIAC,      MALE},
+    {OBJ_EVENT_GFX_TUBER_F,        FACILITY_CLASS_TUBER,            FEMALE},
+    {OBJ_EVENT_GFX_TUBER_M_2,      FACILITY_CLASS_TUBER_2,          MALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_COOLTRAINER,      MALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOLTRAINER_2,    FEMALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_HEX_MANIAC,       MALE},
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_LADY,             FEMALE},
+    {OBJ_EVENT_GFX_BEAUTY,         FACILITY_CLASS_BEAUTY,           FEMALE},
+    {OBJ_EVENT_GFX_BOY,            FACILITY_CLASS_RICH_BOY,         MALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_POKEMANIAC,       MALE},
+    {OBJ_EVENT_GFX_SWIMMER_M_LAND, FACILITY_CLASS_SWIMMER_MALE,     MALE},
+    {OBJ_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_BLACK_BELT,       MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_GUITARIST,        MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_KINDLER,          MALE},
+    {OBJ_EVENT_GFX_CAMPER,         FACILITY_CLASS_CAMPER,           MALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_BUG_MANIAC,       MALE},
+    {OBJ_EVENT_GFX_BOY,            FACILITY_CLASS_PSYCHIC,          MALE},
+    {OBJ_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_PSYCHIC_2,        FEMALE},
+    {OBJ_EVENT_GFX_GENTLEMAN,      FACILITY_CLASS_GENTLEMAN,        MALE},
+    {OBJ_EVENT_GFX_BOY,            FACILITY_CLASS_SCHOOL_KID,       MALE},
+    {OBJ_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_SCHOOL_KID_2,     FEMALE},
+    {OBJ_EVENT_GFX_BALDING_MAN,    FACILITY_CLASS_POKEFAN,          MALE},
+    {OBJ_EVENT_GFX_WOMAN_3,        FACILITY_CLASS_POKEFAN_2,        FEMALE},
+    {OBJ_EVENT_GFX_OLD_MAN_1,      FACILITY_CLASS_EXPERT,           MALE},
+    {OBJ_EVENT_GFX_OLD_WOMAN,      FACILITY_CLASS_EXPERT_2,         FEMALE},
+    {OBJ_EVENT_GFX_YOUNGSTER,      FACILITY_CLASS_YOUNGSTER,        MALE},
+    {OBJ_EVENT_GFX_FISHER,         FACILITY_CLASS_FISHERMAN,        MALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_DRAGON_TAMER,     MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_BIRD_KEEPER,      MALE},
+    {OBJ_EVENT_GFX_LITTLE_BOY,     FACILITY_CLASS_NINJA_BOY,        MALE},
+    {OBJ_EVENT_GFX_BATTLE_GIRL,    FACILITY_CLASS_BATTLE_GIRL,      FEMALE},
+    {OBJ_EVENT_GFX_BEAUTY,         FACILITY_CLASS_PARASOL_LADY,     FEMALE},
+    {OBJ_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SWIMMER_FEMALE,   FEMALE},
+    {OBJ_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PICNICKER,        FEMALE},
+    {OBJ_EVENT_GFX_SAILOR,         FACILITY_CLASS_SAILOR,           MALE},
+    {OBJ_EVENT_GFX_FAT_MAN,        FACILITY_CLASS_COLLECTOR,        MALE},
+    {OBJ_EVENT_GFX_MAN,            FACILITY_CLASS_PKMN_BREEDER,     MALE},
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_PKMN_BREEDER_2,   FEMALE},
+    {OBJ_EVENT_GFX_CAMPER,         FACILITY_CLASS_PKMN_RANGER,      MALE},
+    {OBJ_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PKMN_RANGER_2,    FEMALE},
+    {OBJ_EVENT_GFX_LASS,           FACILITY_CLASS_LASS,             FEMALE},
+    {OBJ_EVENT_GFX_BUG_CATCHER,    FACILITY_CLASS_BUG_CATCHER,      MALE},
+    {OBJ_EVENT_GFX_HIKER,          FACILITY_CLASS_HIKER,            MALE},
+    {OBJ_EVENT_GFX_YOUNGSTER,      FACILITY_CLASS_YOUNGSTER_2,      MALE},
+    {OBJ_EVENT_GFX_BUG_CATCHER,    FACILITY_CLASS_BUG_CATCHER_2,    MALE},
+    {OBJ_EVENT_GFX_LASS,           FACILITY_CLASS_LASS_2,           FEMALE},
+    {OBJ_EVENT_GFX_SAILOR,         FACILITY_CLASS_SAILOR_2,         MALE},
+    {OBJ_EVENT_GFX_CAMPER,         FACILITY_CLASS_CAMPER_2,         MALE},
+    {OBJ_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PICNICKER_2,      FEMALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_POKEMANIAC_2,     MALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_SUPER_NERD,       MALE},
+    {OBJ_EVENT_GFX_HIKER,          FACILITY_CLASS_HIKER_2,          MALE},
+    {OBJ_EVENT_GFX_BIKER,          FACILITY_CLASS_BIKER,            MALE},
+    {OBJ_EVENT_GFX_SUPER_NERD,     FACILITY_CLASS_BURGLAR,          MALE},
+    {OBJ_EVENT_GFX_BALDING_MAN,    FACILITY_CLASS_ENGINEER,         MALE},
+    {OBJ_EVENT_GFX_FISHER,         FACILITY_CLASS_FISHERMAN_2,      MALE},
+    {OBJ_EVENT_GFX_SWIMMER_M_LAND, FACILITY_CLASS_SWIMMER_MALE_2,   MALE},
+    {OBJ_EVENT_GFX_BIKER,          FACILITY_CLASS_CUE_BALL,         MALE},
+    {OBJ_EVENT_GFX_OLD_MAN_1,      FACILITY_CLASS_GAMER,            MALE},
+    {OBJ_EVENT_GFX_BEAUTY,         FACILITY_CLASS_BEAUTY_2,         FEMALE},
+    {OBJ_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SWIMMER_FEMALE_2, FEMALE},
+    {OBJ_EVENT_GFX_BOY,            FACILITY_CLASS_PSYCHIC_3,        MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_ROCKER,           MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_JUGGLER,          MALE},
+    {OBJ_EVENT_GFX_MAN,            FACILITY_CLASS_TAMER,            MALE},
+    {OBJ_EVENT_GFX_ROCKER,         FACILITY_CLASS_BIRD_KEEPER_2,    MALE},
+    {OBJ_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_BLACK_BELT_2,     MALE},
+    {OBJ_EVENT_GFX_SCIENTIST,      FACILITY_CLASS_SCIENTIST,        MALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_M,  FACILITY_CLASS_COOLTRAINER_3,    MALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOLTRAINER_4,    FEMALE},
+    {OBJ_EVENT_GFX_GENTLEMAN,      FACILITY_CLASS_GENTLEMAN_2,      MALE},
+    {OBJ_EVENT_GFX_CHANNELER,      FACILITY_CLASS_CHANNELER,        FEMALE},
+    {OBJ_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_PSYCHIC_4,        FEMALE},
+    {OBJ_EVENT_GFX_BATTLE_GIRL,    FACILITY_CLASS_CRUSH_GIRL,       FEMALE},
+    {OBJ_EVENT_GFX_TUBER_F,        FACILITY_CLASS_TUBER_3,          FEMALE},
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_PKMN_BREEDER_3,   FEMALE},
+    {OBJ_EVENT_GFX_CAMPER,         FACILITY_CLASS_PKMN_RANGER_3,    MALE},
+    {OBJ_EVENT_GFX_PICNICKER,      FACILITY_CLASS_PKMN_RANGER_4,    FEMALE},
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_AROMA_LADY_2,     FEMALE},
+    {OBJ_EVENT_GFX_HIKER,          FACILITY_CLASS_RUIN_MANIAC_2,    MALE},
+    {OBJ_EVENT_GFX_WOMAN_2,        FACILITY_CLASS_LADY_2,           FEMALE},
+    {OBJ_EVENT_GFX_LASS,           FACILITY_CLASS_PAINTER,          FEMALE}
 };
 
 static const struct DoublesTrainerInfo sDoubleBattleTrainerInfo[] = {
-    {OBJECT_EVENT_GFX_BEAUTY,         OBJECT_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_SR_AND_JR,      FEMALE, FEMALE},
-    {OBJECT_EVENT_GFX_LITTLE_GIRL,    OBJECT_EVENT_GFX_LITTLE_GIRL,    FACILITY_CLASS_TWINS,          FEMALE, FEMALE},
-    {OBJECT_EVENT_GFX_BEAUTY,         OBJECT_EVENT_GFX_MAN,            FACILITY_CLASS_YOUNG_COUPLE,   FEMALE, MALE},
-    {OBJECT_EVENT_GFX_OLD_MAN_1,      OBJECT_EVENT_GFX_OLD_WOMAN,      FACILITY_CLASS_OLD_COUPLE,     MALE, FEMALE},
-    {OBJECT_EVENT_GFX_TUBER_M_2,      OBJECT_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SIS_AND_BRO,    MALE, FEMALE},
-    {OBJECT_EVENT_GFX_LITTLE_GIRL,    OBJECT_EVENT_GFX_LITTLE_GIRL,    FACILITY_CLASS_TWINS_2,        FEMALE, FEMALE},
-    {OBJECT_EVENT_GFX_COOLTRAINER_M,  OBJECT_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOL_COUPLE,    MALE, FEMALE},
-    {OBJECT_EVENT_GFX_BEAUTY,         OBJECT_EVENT_GFX_MAN,            FACILITY_CLASS_YOUNG_COUPLE_2, FEMALE, MALE},
-    {OBJECT_EVENT_GFX_BATTLE_GIRL,    OBJECT_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_CRUSH_KIN,      FEMALE, MALE},
-    {OBJECT_EVENT_GFX_SWIMMER_F_LAND, OBJECT_EVENT_GFX_TUBER_M_2,      FACILITY_CLASS_SIS_AND_BRO_2,  FEMALE, MALE}
+    {OBJ_EVENT_GFX_BEAUTY,         OBJ_EVENT_GFX_WOMAN_1,        FACILITY_CLASS_SR_AND_JR,      FEMALE, FEMALE},
+    {OBJ_EVENT_GFX_LITTLE_GIRL,    OBJ_EVENT_GFX_LITTLE_GIRL,    FACILITY_CLASS_TWINS,          FEMALE, FEMALE},
+    {OBJ_EVENT_GFX_BEAUTY,         OBJ_EVENT_GFX_MAN,            FACILITY_CLASS_YOUNG_COUPLE,   FEMALE, MALE},
+    {OBJ_EVENT_GFX_OLD_MAN_1,      OBJ_EVENT_GFX_OLD_WOMAN,      FACILITY_CLASS_OLD_COUPLE,     MALE, FEMALE},
+    {OBJ_EVENT_GFX_TUBER_M_2,      OBJ_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SIS_AND_BRO,    MALE, FEMALE},
+    {OBJ_EVENT_GFX_LITTLE_GIRL,    OBJ_EVENT_GFX_LITTLE_GIRL,    FACILITY_CLASS_TWINS_2,        FEMALE, FEMALE},
+    {OBJ_EVENT_GFX_COOLTRAINER_M,  OBJ_EVENT_GFX_COOLTRAINER_F,  FACILITY_CLASS_COOL_COUPLE,    MALE, FEMALE},
+    {OBJ_EVENT_GFX_BEAUTY,         OBJ_EVENT_GFX_MAN,            FACILITY_CLASS_YOUNG_COUPLE_2, FEMALE, MALE},
+    {OBJ_EVENT_GFX_BATTLE_GIRL,    OBJ_EVENT_GFX_BLACKBELT,      FACILITY_CLASS_CRUSH_KIN,      FEMALE, MALE},
+    {OBJ_EVENT_GFX_SWIMMER_F_LAND, OBJ_EVENT_GFX_TUBER_M_2,      FACILITY_CLASS_SIS_AND_BRO_2,  FEMALE, MALE}
 };
 
 static const struct TrainerEncounterMusicPairs sTrainerEncounterMusicLUT[105] = {
@@ -319,51 +318,52 @@ static const struct TrainerEncounterMusicPairs sTrainerEncounterMusicLUT[105] =
     {FACILITY_CLASS_ELITE_FOUR_2,     TRAINER_ENCOUNTER_MUSIC_MALE}
 };
 
-static const struct WindowTemplate gUnknown_847A218[] = {
+static const struct WindowTemplate sTimeBoardWindowTemplate[] = {
     {0, 3, 1, 27, 18, 15, 0x001},
     DUMMY_WIN_TEMPLATE
 };
 
-static const u32 gUnknown_847A228 = 0x70;  // unused
-
-static const u8 gUnknown_847A22C[3] = {0, 2, 3};
-
-static void (*const gUnknown_847A230[])(void) = {
-    sub_815DD44,
-    sub_815DF54,
-    sub_815E160,
-    sub_815E1C0,
-    sub_815E1F0,
-    TTSpecial_HasReachedTheRoof,
-    sub_815E28C,
-    sub_815E394,
-    sub_815E408,
-    sub_815E4B0,
-    TTSpecial_StartTimer,
-    sub_815E5C4,
-    sub_815E5F0,
-    sub_815E658,
-    sub_815E720,
-    sub_815E88C,
-    sub_815E8B4,
-    sub_815E8CC,
-    sub_815E908,
-    sub_815E948,
-    sub_815E9C8
+static const u32 sUnused_847A228 = 0x70;
+
+static const u8 sTextColors[3] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY};
+
+static void (*const sTrainerTowerFunctions[])(void) = {
+    [TRAINER_TOWER_FUNC_INIT_FLOOR]             = InitTrainerTowerFloor,
+    [TRAINER_TOWER_FUNC_GET_SPEECH]             = BufferTowerOpponentSpeech,
+    [TRAINER_TOWER_FUNC_DO_BATTLE]              = DoTrainerTowerBattle,
+    [TRAINER_TOWER_FUNC_GET_CHALLENGE_TYPE]     = TrainerTowerGetChallengeType,
+    [TRAINER_TOWER_FUNC_CLEARED_FLOOR]          = TrainerTowerAddFloorCleared,
+    [TRAINER_TOWER_FUNC_GET_FLOOR_CLEARED]      = GetFloorAlreadyCleared,
+    [TRAINER_TOWER_FUNC_START_CHALLENGE]        = StartTrainerTowerChallenge,
+    [TRAINER_TOWER_FUNC_GET_OWNER_STATE]        = GetOwnerState,
+    [TRAINER_TOWER_FUNC_GIVE_PRIZE]             = GiveChallengePrize,
+    [TRAINER_TOWER_FUNC_CHECK_FINAL_TIME]       = CheckFinalTime,
+    [TRAINER_TOWER_FUNC_RESUME_TIMER]           = TrainerTowerResumeTimer,
+    [TRAINER_TOWER_FUNC_SET_LOST]               = TrainerTowerSetPlayerLost,
+    [TRAINER_TOWER_FUNC_GET_CHALLENGE_STATUS]   = GetTrainerTowerChallengeStatus,
+    [TRAINER_TOWER_FUNC_GET_TIME]               = GetCurrentTime,
+    [TRAINER_TOWER_FUNC_SHOW_RESULTS]           = ShowResultsBoard,
+    [TRAINER_TOWER_FUNC_CLOSE_RESULTS]          = CloseResultsBoard,
+    [TRAINER_TOWER_FUNC_CHECK_DOUBLES]          = TrainerTowerGetDoublesEligiblity,
+    [TRAINER_TOWER_FUNC_GET_NUM_FLOORS]         = TrainerTowerGetNumFloors,
+    [TRAINER_TOWER_FUNC_SHOULD_WARP_TO_COUNTER] = ShouldWarpToCounter,
+    [TRAINER_TOWER_FUNC_ENCOUNTER_MUSIC]        = PlayTrainerTowerEncounterMusic,
+    [TRAINER_TOWER_FUNC_GET_BEAT_CHALLENGE]     = HasSpokenToOwner
 };
 
-static const u16 sFloorLayouts[8][3] = {
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_1F, LAYOUT_UNUSED_LAYOUT_834BC2C, LAYOUT_UNUSED_LAYOUT_834D06C},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_2F, LAYOUT_UNUSED_LAYOUT_834BEB4, LAYOUT_UNUSED_LAYOUT_834D2F4},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_3F, LAYOUT_UNUSED_LAYOUT_834C13C, LAYOUT_UNUSED_LAYOUT_834D57C},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_4F, LAYOUT_UNUSED_LAYOUT_834C3C4, LAYOUT_UNUSED_LAYOUT_834D804},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_5F, LAYOUT_UNUSED_LAYOUT_834C64C, LAYOUT_UNUSED_LAYOUT_834DA8C},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_6F, LAYOUT_UNUSED_LAYOUT_834C8D4, LAYOUT_UNUSED_LAYOUT_834DD14},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_7F, LAYOUT_UNUSED_LAYOUT_834CB5C, LAYOUT_UNUSED_LAYOUT_834DF9C},
-    {LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_8F, LAYOUT_UNUSED_LAYOUT_834CDE4, LAYOUT_UNUSED_LAYOUT_834E224}
+// - 1 excludes Mixed challenge, which just uses one of the 3 other types
+static const u16 sFloorLayouts[MAX_TRAINER_TOWER_FLOORS][NUM_TOWER_CHALLENGE_TYPES - 1] = {
+    {LAYOUT_TRAINER_TOWER_1F, LAYOUT_TRAINER_TOWER_1F_DOUBLES, LAYOUT_TRAINER_TOWER_1F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_2F, LAYOUT_TRAINER_TOWER_2F_DOUBLES, LAYOUT_TRAINER_TOWER_2F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_3F, LAYOUT_TRAINER_TOWER_3F_DOUBLES, LAYOUT_TRAINER_TOWER_3F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_4F, LAYOUT_TRAINER_TOWER_4F_DOUBLES, LAYOUT_TRAINER_TOWER_4F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_5F, LAYOUT_TRAINER_TOWER_5F_DOUBLES, LAYOUT_TRAINER_TOWER_5F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_6F, LAYOUT_TRAINER_TOWER_6F_DOUBLES, LAYOUT_TRAINER_TOWER_6F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_7F, LAYOUT_TRAINER_TOWER_7F_DOUBLES, LAYOUT_TRAINER_TOWER_7F_KNOCKOUT},
+    {LAYOUT_TRAINER_TOWER_8F, LAYOUT_TRAINER_TOWER_8F_DOUBLES, LAYOUT_TRAINER_TOWER_8F_KNOCKOUT}
 };
 
-static const u16 gUnknown_847A2B4[] = {
+static const u16 sPrizeList[] = {
     ITEM_HP_UP,
     ITEM_PROTEIN,
     ITEM_IRON,
@@ -381,21 +381,21 @@ static const u16 gUnknown_847A2B4[] = {
     ITEM_UP_GRADE
 };
 
-static const u16 gUnknown_847A2D2[] = {
-    MUS_SHOUNEN,
-    MUS_SHOUJO,
-    MUS_SHOUJO,
-    MUS_ROCKET,
-    MUS_SHOUNEN,
-    MUS_SHOUNEN,
-    MUS_ROCKET,
-    MUS_ROCKET,
-    MUS_SHOUNEN,
-    MUS_SHOUJO,
-    MUS_SHOUNEN,
-    MUS_SHOUNEN,
-    MUS_SHOUNEN,
-    MUS_SHOUNEN
+static const u16 sTrainerTowerEncounterMusic[] = {
+    [TRAINER_ENCOUNTER_MUSIC_MALE]        = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_FEMALE]      = MUS_SHOUJO,
+    [TRAINER_ENCOUNTER_MUSIC_GIRL]        = MUS_SHOUJO,
+    [TRAINER_ENCOUNTER_MUSIC_SUSPICIOUS]  = MUS_ROCKET,
+    [TRAINER_ENCOUNTER_MUSIC_INTENSE]     = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_COOL]        = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_AQUA]        = MUS_ROCKET,
+    [TRAINER_ENCOUNTER_MUSIC_MAGMA]       = MUS_ROCKET,
+    [TRAINER_ENCOUNTER_MUSIC_SWIMMER]     = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_TWINS]       = MUS_SHOUJO,
+    [TRAINER_ENCOUNTER_MUSIC_ELITE_FOUR]  = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_HIKER]       = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_INTERVIEWER] = MUS_SHOUNEN,
+    [TRAINER_ENCOUNTER_MUSIC_RICH]        = MUS_SHOUNEN
 };
 
 static const u8 sSingleBattleChallengeMonIdxs[][2] = {
@@ -431,22 +431,22 @@ static const u8 sKnockoutChallengeMonIdxs[][3] = {
     {0x01, 0x04, 0x05}
 };
 
-extern const struct EReaderTrainerHillSetSubstruct gUnknown_84827AC;
-extern const struct TrainerTowerFloor *const gUnknown_84827B4[][8];
+extern const struct EReaderTrainerTowerSetSubstruct gUnknown_84827AC;
+extern const struct TrainerTowerFloor *const gUnknown_84827B4[][MAX_TRAINER_TOWER_FLOORS];
 
-void sub_815D9E8(void)
+void CallTrainerTowerFunc(void)
 {
-    sub_815DC8C();
-    gUnknown_847A230[gSpecialVar_0x8004]();
-    sub_815DD2C();
+    SetUpTrainerTowerDataStruct();
+    sTrainerTowerFunctions[gSpecialVar_0x8004]();
+    FreeTrainerTowerDataStruct();
 }
 
-u8 sub_815DA10(void)
+u8 GetTrainerTowerOpponentClass(void)
 {
     return gFacilityClassToTrainerClass[sTrainerTowerOpponent->facilityClass];
 }
 
-void sub_815DA28(u8 *dest)
+void GetTrainerTowerOpponentName(u8 *dest)
 {
     StringCopyN(dest, sTrainerTowerOpponent->name, 11);
 }
@@ -458,41 +458,39 @@ u8 GetTrainerTowerTrainerFrontSpriteId(void)
 
 void InitTrainerTowerBattleStruct(void)
 {
-    u16 r10;
-    s32 r9;
+    u16 trainerId;
+    int i;
 
-    sub_815DC8C();
+    SetUpTrainerTowerDataStruct();
     sTrainerTowerOpponent = AllocZeroed(sizeof(*sTrainerTowerOpponent));
-    r10 = VarGet(VAR_TEMP_1);
-    StringCopyN(sTrainerTowerOpponent->name, sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10].name, 11);
+    trainerId = VarGet(VAR_TEMP_1);
+    StringCopyN(sTrainerTowerOpponent->name, CURR_FLOOR.trainers[trainerId].name, 11);
 
-    for (r9 = 0; r9 < 6; r9++)
+    for (i = 0; i < 6; i++)
     {
-        sTrainerTowerOpponent->speechWin[r9] = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10].speechWin[r9];
-        sTrainerTowerOpponent->speechLose[r9] = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10].speechLose[r9];
+        sTrainerTowerOpponent->speechWin[i] = CURR_FLOOR.trainers[trainerId].speechWin[i];
+        sTrainerTowerOpponent->speechLose[i] = CURR_FLOOR.trainers[trainerId].speechLose[i];
 
-        if (sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType == 1)
+        if (CURR_FLOOR.challengeType == CHALLENGE_TYPE_DOUBLE)
         {
-            sTrainerTowerOpponent->speechWin2[r9] = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10 + 1].speechWin[r9];
-            sTrainerTowerOpponent->speechLose2[r9] = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10 + 1].speechLose[r9];
+            sTrainerTowerOpponent->speechWin2[i] = CURR_FLOOR.trainers[trainerId + 1].speechWin[i];
+            sTrainerTowerOpponent->speechLose2[i] = CURR_FLOOR.trainers[trainerId + 1].speechLose[i];
         }
     }
 
-    sTrainerTowerOpponent->battleType = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType;
-    sTrainerTowerOpponent->facilityClass = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10].facilityClass;
-    sTrainerTowerOpponent->gender = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r10].gender;
-    SetVBlankCounter1Ptr(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
-    sub_815DD2C();
+    sTrainerTowerOpponent->battleType = CURR_FLOOR.challengeType;
+    sTrainerTowerOpponent->facilityClass = CURR_FLOOR.trainers[trainerId].facilityClass;
+    sTrainerTowerOpponent->gender = CURR_FLOOR.trainers[trainerId].gender;
+    SetVBlankCounter1Ptr(&TRAINER_TOWER.timer);
+    FreeTrainerTowerDataStruct();
 }
 
 void FreeTrainerTowerBattleStruct(void)
 {
-    Free(sTrainerTowerOpponent);
-    sTrainerTowerOpponent = NULL;
+    FREE_AND_SET_NULL(sTrainerTowerOpponent);
 }
 
-void sub_815DBF4(u8 *dest, u8 opponentIdx)
-// TTower_GetBeforeBattleMessage?
+void GetTrainerTowerOpponentWinText(u8 *dest, u8 opponentIdx)
 {
     VarSet(VAR_TEMP_3, opponentIdx);
     TrainerTowerGetOpponentTextColor(sTrainerTowerOpponent->battleType, sTrainerTowerOpponent->facilityClass);
@@ -502,8 +500,7 @@ void sub_815DBF4(u8 *dest, u8 opponentIdx)
         TT_ConvertEasyChatMessageToString(sTrainerTowerOpponent->speechWin2, dest);
 }
 
-void sub_815DC40(u8 *dest, u8 opponentIdx)
-// TTower_GetAfterBattleMessage?
+void GetTrainerTowerOpponentLoseText(u8 *dest, u8 opponentIdx)
 {
     VarSet(VAR_TEMP_3, opponentIdx);
     TrainerTowerGetOpponentTextColor(sTrainerTowerOpponent->battleType, sTrainerTowerOpponent->facilityClass);
@@ -513,23 +510,23 @@ void sub_815DC40(u8 *dest, u8 opponentIdx)
         TT_ConvertEasyChatMessageToString(sTrainerTowerOpponent->speechLose2, dest);
 }
 
-static void sub_815DC8C(void) // fakematching
+static void SetUpTrainerTowerDataStruct(void) // fakematching
 {
-    u32 whichTimer = gSaveBlock1Ptr->unkArrayIdx;
+    u32 challengeType = gSaveBlock1Ptr->towerChallengeId;
     s32 r4;
     const struct TrainerTowerFloor *const * r7;
 
     sTrainerTowerState = AllocZeroed(sizeof(*sTrainerTowerState));
     sTrainerTowerState->floorIdx = gMapHeader.mapLayoutId - 42;
-    if (sub_815D834() == TRUE)
+    if (ReadTrainerTowerAndValidate() == TRUE)
         CEReaderTool_LoadTrainerTower(&sTrainerTowerState->unk_0004);
     else
     {
         struct UnkStruct_203F458 * r0_ = sTrainerTowerState;
-        const struct EReaderTrainerHillSetSubstruct * r1 = &gUnknown_84827AC;
-        memcpy(&r0_->unk_0004, r1, sizeof(struct EReaderTrainerHillSetSubstruct));
-        r7 = gUnknown_84827B4[whichTimer];
-        for (r4 = 0; r4 < 8; r4++)
+        const struct EReaderTrainerTowerSetSubstruct * r1 = &gUnknown_84827AC;
+        memcpy(&r0_->unk_0004, r1, sizeof(struct EReaderTrainerTowerSetSubstruct));
+        r7 = gUnknown_84827B4[challengeType];
+        for (r4 = 0; r4 < MAX_TRAINER_TOWER_FLOORS; r4++)
         {
         #ifndef NONMATCHING
             void * r5;
@@ -547,22 +544,21 @@ static void sub_815DC8C(void) // fakematching
     }
 }
 
-static void sub_815DD2C(void)
+static void FreeTrainerTowerDataStruct(void)
 {
-    Free(sTrainerTowerState);
-    sTrainerTowerState = NULL;
+    FREE_AND_SET_NULL(sTrainerTowerState);
 }
 
-static void sub_815DD44(void)
+static void InitTrainerTowerFloor(void)
 {
-    if (gMapHeader.mapLayoutId - LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_LOBBY > sTrainerTowerState->unk_0004.count)
+    if (gMapHeader.mapLayoutId - LAYOUT_TRAINER_TOWER_LOBBY > sTrainerTowerState->unk_0004.numFloors)
     {
-        gSpecialVar_Result = 3;
-        SetCurrentMapLayout(LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_ROOF);
+        gSpecialVar_Result = 3; // Skip past usable challenge types
+        SetCurrentMapLayout(LAYOUT_TRAINER_TOWER_ROOF);
     }
     else
     {
-        gSpecialVar_Result = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType;
+        gSpecialVar_Result = CURR_FLOOR.challengeType;
         SetCurrentMapLayout(sFloorLayouts[sTrainerTowerState->floorIdx][gSpecialVar_Result]);
         SetTrainerTowerNPCGraphics();
     }
@@ -570,66 +566,70 @@ static void sub_815DD44(void)
 
 static void SetTrainerTowerNPCGraphics(void)
 {
-    s32 r3, r4;
-    u8 r1, r2, r4_;
-    switch (sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType)
+    s32 i, j;
+    u8 trainerGfx1, trainerGfx2, facilityClass;
+    switch (CURR_FLOOR.challengeType)
     {
-    case 0:
-        r2 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[0].facilityClass;
-        for (r3 = 0; r3 < NELEMS(sSingleBattleTrainerInfo); r3++)
+    case CHALLENGE_TYPE_SINGLE:
+        facilityClass = CURR_FLOOR.trainers[0].facilityClass;
+        for (i = 0; i < NELEMS(sSingleBattleTrainerInfo); i++)
         {
-            if (sSingleBattleTrainerInfo[r3].facilityClass == r2)
+            if (sSingleBattleTrainerInfo[i].facilityClass == facilityClass)
                 break;
         }
-        if (r3 != NELEMS(sSingleBattleTrainerInfo))
-            r1 = sSingleBattleTrainerInfo[r3].mapObjGfx;
+
+        if (i != NELEMS(sSingleBattleTrainerInfo))
+            trainerGfx1 = sSingleBattleTrainerInfo[i].objGfx;
         else
-            r1 = 18;
-        VarSet(VAR_OBJ_GFX_ID_1, r1);
+            trainerGfx1 = OBJ_EVENT_GFX_YOUNGSTER;
+
+        VarSet(VAR_OBJ_GFX_ID_1, trainerGfx1);
         break;
-    case 1:
-        r2 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[0].facilityClass;
-        for (r3 = 0; r3 < NELEMS(sDoubleBattleTrainerInfo); r3++)
+    case CHALLENGE_TYPE_DOUBLE:
+        facilityClass = CURR_FLOOR.trainers[0].facilityClass;
+        for (i = 0; i < NELEMS(sDoubleBattleTrainerInfo); i++)
         {
-            if (sDoubleBattleTrainerInfo[r3].facilityClass == r2)
+            if (sDoubleBattleTrainerInfo[i].facilityClass == facilityClass)
                 break;
         }
-        if (r3 != NELEMS(sDoubleBattleTrainerInfo))
+        if (i != NELEMS(sDoubleBattleTrainerInfo))
         {
-            r1  = sDoubleBattleTrainerInfo[r3].mapObjGfx1;
-            r4_ = sDoubleBattleTrainerInfo[r3].mapObjGfx2;
+            trainerGfx1  = sDoubleBattleTrainerInfo[i].objGfx1;
+            trainerGfx2 = sDoubleBattleTrainerInfo[i].objGfx2;
         }
         else
         {
-            r1  = OBJECT_EVENT_GFX_YOUNGSTER;
-            r4_ = OBJECT_EVENT_GFX_YOUNGSTER;
+            trainerGfx1  = OBJ_EVENT_GFX_YOUNGSTER;
+            trainerGfx2 = OBJ_EVENT_GFX_YOUNGSTER;
         }
-        VarSet(VAR_OBJ_GFX_ID_0, r1);
-        VarSet(VAR_OBJ_GFX_ID_3, r4_);
+        VarSet(VAR_OBJ_GFX_ID_0, trainerGfx1);
+        VarSet(VAR_OBJ_GFX_ID_3, trainerGfx2);
         break;
-    case 2:
-        for (r4 = 0; r4 < 3; r4++)
+    case CHALLENGE_TYPE_KNOCKOUT:
+        for (j = 0; j < MAX_TRAINERS_PER_FLOOR; j++)
         {
-            r2 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].facilityClass;
-            for (r3 = 0; r3 < NELEMS(sSingleBattleTrainerInfo); r3++)
+            facilityClass = CURR_FLOOR.trainers[j].facilityClass;
+            for (i = 0; i < NELEMS(sSingleBattleTrainerInfo); i++)
             {
-                if (sSingleBattleTrainerInfo[r3].facilityClass == r2)
+                if (sSingleBattleTrainerInfo[i].facilityClass == facilityClass)
                     break;
             }
-            if (r3 != NELEMS(sSingleBattleTrainerInfo))
-                r1 = sSingleBattleTrainerInfo[r3].mapObjGfx;
+
+            if (i != NELEMS(sSingleBattleTrainerInfo))
+                trainerGfx1 = sSingleBattleTrainerInfo[i].objGfx;
             else
-                r1 = OBJECT_EVENT_GFX_YOUNGSTER;
-            switch (r4)
+                trainerGfx1 = OBJ_EVENT_GFX_YOUNGSTER;
+
+            switch (j)
             {
             case 0:
-                VarSet(VAR_OBJ_GFX_ID_2, r1);
+                VarSet(VAR_OBJ_GFX_ID_2, trainerGfx1);
                 break;
             case 1:
-                VarSet(VAR_OBJ_GFX_ID_0, r1);
+                VarSet(VAR_OBJ_GFX_ID_0, trainerGfx1);
                 break;
             case 2:
-                VarSet(VAR_OBJ_GFX_ID_1, r1);
+                VarSet(VAR_OBJ_GFX_ID_1, trainerGfx1);
                 break;
             }
         }
@@ -652,207 +652,224 @@ static void TT_ConvertEasyChatMessageToString(u16 *ecWords, u8 *dest)
     }
 }
 
-static void sub_815DF54(void)
+static void BufferTowerOpponentSpeech(void)
 {
-    u16 r4 = gSpecialVar_0x8006;
-    u8 r1;
-    u8 r5 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType;
+    u16 trainerId = gSpecialVar_0x8006;
+    u8 facilityClass;
+    u8 challengeType = CURR_FLOOR.challengeType;
     
-    if (r5 != 1)
-        r1 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].facilityClass;
+    if (challengeType != CHALLENGE_TYPE_DOUBLE)
+        facilityClass = CURR_FLOOR.trainers[trainerId].facilityClass;
     else
-        r1 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[0].facilityClass;
+        facilityClass = CURR_FLOOR.trainers[0].facilityClass;
+
     switch (gSpecialVar_0x8005)
     {
-    case 2:
-        TrainerTowerGetOpponentTextColor(r5, r1);
-        TT_ConvertEasyChatMessageToString(sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].speechBefore, gStringVar4);
+    case TRAINER_TOWER_TEXT_INTRO:
+        TrainerTowerGetOpponentTextColor(challengeType, facilityClass);
+        TT_ConvertEasyChatMessageToString(CURR_FLOOR.trainers[trainerId].speechBefore, gStringVar4);
         break;
-    case 3:
-        TrainerTowerGetOpponentTextColor(r5, r1);
-        TT_ConvertEasyChatMessageToString(sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].speechWin, gStringVar4);
+    case TRAINER_TOWER_TEXT_PLAYER_LOST:
+        TrainerTowerGetOpponentTextColor(challengeType, facilityClass);
+        TT_ConvertEasyChatMessageToString(CURR_FLOOR.trainers[trainerId].speechWin, gStringVar4);
         break;
-    case 4:
-        TrainerTowerGetOpponentTextColor(r5, r1);
-        TT_ConvertEasyChatMessageToString(sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].speechLose, gStringVar4);
+    case TRAINER_TOWER_TEXT_PLAYER_WON:
+        TrainerTowerGetOpponentTextColor(challengeType, facilityClass);
+        TT_ConvertEasyChatMessageToString(CURR_FLOOR.trainers[trainerId].speechLose, gStringVar4);
         break;
-    case 5:
-        TT_ConvertEasyChatMessageToString(sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[r4].speechAfter, gStringVar4);
+    case TRAINER_TOWER_TEXT_AFTER:
+        TT_ConvertEasyChatMessageToString(CURR_FLOOR.trainers[trainerId].speechAfter, gStringVar4);
         break;
     }
 }
 
-static void TrainerTowerGetOpponentTextColor(u8 battleType, u8 facilityClass)
+static void TrainerTowerGetOpponentTextColor(u8 challengeType, u8 facilityClass)
 {
-    u16 r5 = FALSE;
-    s32 r4;
-    switch (battleType)
+    u16 gender = MALE;
+    int i;
+    switch (challengeType)
     {
-    case 0:
-    case 2:
-        for (r4 = 0; r4 < NELEMS(sSingleBattleTrainerInfo); r4++)
+    case CHALLENGE_TYPE_SINGLE:
+    case CHALLENGE_TYPE_KNOCKOUT:
+        for (i = 0; i < NELEMS(sSingleBattleTrainerInfo); i++)
         {
-            if (sSingleBattleTrainerInfo[r4].facilityClass == facilityClass)
+            if (sSingleBattleTrainerInfo[i].facilityClass == facilityClass)
                 break;
         }
-        if (r4 != NELEMS(sSingleBattleTrainerInfo))
-            r5 = sSingleBattleTrainerInfo[r4].gender;
+        if (i != NELEMS(sSingleBattleTrainerInfo))
+            gender = sSingleBattleTrainerInfo[i].gender;
         break;
-    case 1:
-        for (r4 = 0; r4 < NELEMS(sDoubleBattleTrainerInfo); r4++)
+    case CHALLENGE_TYPE_DOUBLE:
+        for (i = 0; i < NELEMS(sDoubleBattleTrainerInfo); i++)
         {
-            if (sDoubleBattleTrainerInfo[r4].facilityClass == facilityClass)
+            if (sDoubleBattleTrainerInfo[i].facilityClass == facilityClass)
                 break;
         }
-        if (r4 != NELEMS(sDoubleBattleTrainerInfo))
+        if (i != NELEMS(sDoubleBattleTrainerInfo))
         {
             if (VarGet(VAR_TEMP_3))
-                r5 = sDoubleBattleTrainerInfo[r4].gender2;
+                gender = sDoubleBattleTrainerInfo[i].gender2;
             else
-                r5 = sDoubleBattleTrainerInfo[r4].gender1;
+                gender = sDoubleBattleTrainerInfo[i].gender1;
         }
         break;
     }
     gSpecialVar_PrevTextColor = gSpecialVar_TextColor;
-    gSpecialVar_TextColor = r5;
+    gSpecialVar_TextColor = gender;
 }
 
-static void sub_815E114(void)
+static void CB2_EndTrainerTowerBattle(void)
 {
     SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
-static void sub_815E124(u8 taskId)
+static void Task_DoTrainerTowerBattle(u8 taskId)
 {
     if (BT_IsDone() == TRUE)
     {
-        gMain.savedCallback = sub_815E114;
+        gMain.savedCallback = CB2_EndTrainerTowerBattle;
         CleanupOverworldWindowsAndTilemaps();
         SetMainCallback2(CB2_InitBattle);
         DestroyTask(taskId);
     }
 }
 
-static void sub_815E160(void)
+static void DoTrainerTowerBattle(void)
 {
     gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_TRAINER_TOWER;
-    if (sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType == 1)
+
+    if (CURR_FLOOR.challengeType == CHALLENGE_TYPE_DOUBLE)
         gBattleTypeFlags |= BATTLE_TYPE_DOUBLE;
+
     gTrainerBattleOpponent_A = 0;
     BuildEnemyParty();
-    CreateTask(sub_815E124, 1);
+    CreateTask(Task_DoTrainerTowerBattle, 1);
     PlayMapChosenOrBattleBGM(0);
     BT_StartOnField(BattleSetup_GetBattleTowerBattleTransition());
 }
 
-static void sub_815E1C0(void)
+static void TrainerTowerGetChallengeType(void)
 {
     if (!gSpecialVar_0x8005)
-        gSpecialVar_Result = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType;
+        gSpecialVar_Result = CURR_FLOOR.challengeType;
 }
 
-static void sub_815E1F0(void)
+static void TrainerTowerAddFloorCleared(void)
 {
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8++;
+    TRAINER_TOWER.floorsCleared++;
 }
 
-static void TTSpecial_HasReachedTheRoof(void)
+// So the player can safely go back through defeated floors to use the Poke Center (or exit challenge)
+static void GetFloorAlreadyCleared(void)
 {
     u16 mapLayoutId = gMapHeader.mapLayoutId;
-    if (mapLayoutId - LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_1F == gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8 && mapLayoutId - LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_LOBBY <= sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].floorIdx)
+    if (mapLayoutId - LAYOUT_TRAINER_TOWER_1F == TRAINER_TOWER.floorsCleared 
+     && mapLayoutId - LAYOUT_TRAINER_TOWER_LOBBY <= CURR_FLOOR.floorIdx)
         gSpecialVar_Result = FALSE;
     else
         gSpecialVar_Result = TRUE;
 }
 
-static void sub_815E28C(void)
+static void StartTrainerTowerChallenge(void)
 {
-    gSaveBlock1Ptr->unkArrayIdx = gSpecialVar_0x8005;
-    if (gSaveBlock1Ptr->unkArrayIdx >= NELEMS(gSaveBlock1Ptr->unkArray))
-        gSaveBlock1Ptr->unkArrayIdx = 0;
+    gSaveBlock1Ptr->towerChallengeId = gSpecialVar_0x8005;
+    if (gSaveBlock1Ptr->towerChallengeId >= NUM_TOWER_CHALLENGE_TYPES)
+        gSaveBlock1Ptr->towerChallengeId = 0;
     ValidateOrResetCurTrainerTowerRecord();
-    if (!sub_815D834())
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_5 = TRUE;
+    if (!ReadTrainerTowerAndValidate())
+        TRAINER_TOWER.validated = TRUE;
     else
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_5 = FALSE;
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8 = 0;
-    SetVBlankCounter1Ptr(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0 = 0;
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2 = FALSE;
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_1 = FALSE;
+        TRAINER_TOWER.validated = FALSE;
+    TRAINER_TOWER.floorsCleared = 0;
+    SetVBlankCounter1Ptr(&TRAINER_TOWER.timer);
+    TRAINER_TOWER.timer = 0;
+    TRAINER_TOWER.spokeToOwner = FALSE;
+    TRAINER_TOWER.checkedFinalTime = FALSE;
 }
 
-static void sub_815E394(void)
+static void GetOwnerState(void)
 {
     DisableVBlankCounter1();
     gSpecialVar_Result = 0;
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2)
+
+    if (TRAINER_TOWER.spokeToOwner)
         gSpecialVar_Result++;
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0 && gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_1)
+    if (TRAINER_TOWER.receivedPrize && TRAINER_TOWER.checkedFinalTime)
         gSpecialVar_Result++;
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2 = TRUE;
+
+    TRAINER_TOWER.spokeToOwner = TRUE;
 }
 
-static void sub_815E408(void)
+static void GiveChallengePrize(void)
 {
-    u16 itemId = gUnknown_847A2B4[sTrainerTowerState->unk_0004.floors->prize];
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0)
+    u16 itemId = sPrizeList[sTrainerTowerState->unk_0004.floors->prize];
+
+    if (TRAINER_TOWER.receivedPrize)
+    {
         gSpecialVar_Result = 2;
-    else if (AddBagItem(itemId, 1) == 1)
+    }
+    else if (AddBagItem(itemId, 1) == TRUE)
     {
         CopyItemName(itemId, gStringVar2);
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0 = TRUE;
+        TRAINER_TOWER.receivedPrize = TRUE;
         gSpecialVar_Result = 0;
     }
     else
+    {
         gSpecialVar_Result = 1;
+    }
 }
 
-static void sub_815E4B0(void)
+static void CheckFinalTime(void)
 {
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_1)
+    if (TRAINER_TOWER.checkedFinalTime)
+    {
         gSpecialVar_Result = 2;
-    else if (GetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk4) > gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0)
+    }
+    else if (GetTrainerTowerRecordTime(&TRAINER_TOWER.bestTime) > TRAINER_TOWER.timer)
     {
-        SetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk4, gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
+        SetTrainerTowerRecordTime(&TRAINER_TOWER.bestTime, TRAINER_TOWER.timer);
         gSpecialVar_Result = 0;
     }
     else
+    {
         gSpecialVar_Result = 1;
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_1 = TRUE;
+    }
+
+    TRAINER_TOWER.checkedFinalTime = TRUE;
 }
 
-static void TTSpecial_StartTimer(void)
+static void TrainerTowerResumeTimer(void)
 {
-    if (!gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2)
+    if (!TRAINER_TOWER.spokeToOwner)
     {
-        if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0 >= 215999)
-            gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0 = 215999;
+        if (TRAINER_TOWER.timer >= TRAINER_TOWER_MAX_TIME)
+            TRAINER_TOWER.timer = TRAINER_TOWER_MAX_TIME;
         else
-            SetVBlankCounter1Ptr(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
+            SetVBlankCounter1Ptr(&TRAINER_TOWER.timer);
     }
 }
 
-static void sub_815E5C4(void)
+static void TrainerTowerSetPlayerLost(void)
 {
-    gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_3 = 1;
+    TRAINER_TOWER.hasLost = TRUE;
 }
 
-static void sub_815E5F0(void)
+static void GetTrainerTowerChallengeStatus(void)
 {
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_3)
+    if (TRAINER_TOWER.hasLost)
     {
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_3 = FALSE;
-        gSpecialVar_Result = 0;
+        TRAINER_TOWER.hasLost = FALSE;
+        gSpecialVar_Result = CHALLENGE_STATUS_LOST;
     }
-    else if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_4)
+    else if (TRAINER_TOWER.unkA_4)
     {
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_4 = FALSE;
-        gSpecialVar_Result = 1;
+        TRAINER_TOWER.unkA_4 = FALSE;
+        gSpecialVar_Result = CHALLENGE_STATUS_UNK;
     }
     else
     {
-        gSpecialVar_Result = 2;
+        gSpecialVar_Result = CHALLENGE_STATUS_NORMAL;
     }
 }
 
@@ -861,8 +878,8 @@ static void sub_815E5F0(void)
                                                                                            \
     frames = (src);                                                                        \
                                                                                            \
-    minutes = frames / 3600;                                                               \
-    frames %= 3600;                                                                        \
+    minutes = frames / (60 * 60);                                                          \
+    frames %= (60 * 60);                                                                   \
     seconds = frames / 60;                                                                 \
     frames %= 60;                                                                          \
     centiseconds = frames * 168 / 100;                                                     \
@@ -872,34 +889,34 @@ static void sub_815E5F0(void)
     ConvertIntToDecimalStringN(gStringVar3, centiseconds, STR_CONV_MODE_LEADING_ZEROS, 2); \
 })
 
-static void sub_815E658(void)
+static void GetCurrentTime(void)
 {
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0 >= 215999)
+    if (TRAINER_TOWER.timer >= TRAINER_TOWER_MAX_TIME)
     {
         DisableVBlankCounter1();
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0 = 215999;
+        TRAINER_TOWER.timer = TRAINER_TOWER_MAX_TIME;
     }
 
-    PRINT_TOWER_TIME(gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
+    PRINT_TOWER_TIME(TRAINER_TOWER.timer);
 }
 
-static void sub_815E720(void)
+static void ShowResultsBoard(void)
 {
     u8 windowId;
     s32 i;
 
     ValidateOrResetCurTrainerTowerRecord();
-    windowId = AddWindow(gUnknown_847A218);
+    windowId = AddWindow(sTimeBoardWindowTemplate);
     LoadStdWindowFrameGfx();
     DrawStdWindowFrame(windowId, FALSE);
-    AddTextPrinterParameterized(windowId, 2, gUnknown_83FE982, 0x4A, 0, 0xFF, NULL);
+    AddTextPrinterParameterized(windowId, 2, gText_TimeBoard, 0x4A, 0, 0xFF, NULL);
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++)
     {
-        PRINT_TOWER_TIME(GetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk4));
+        PRINT_TOWER_TIME(GetTrainerTowerRecordTime(&TRAINER_TOWER.bestTime));
 
-        StringExpandPlaceholders(gStringVar4, gUnknown_83FE998);
-        AddTextPrinterParameterized(windowId, 2, gUnknown_83FE9C4[i - 1], 0x18, 0x24 + 0x14 * i, 0xFF, NULL);
+        StringExpandPlaceholders(gStringVar4, gText_XMinYZSec);
+        AddTextPrinterParameterized(windowId, 2, gTrainerTowerChallengeTypeTexts[i - 1], 0x18, 0x24 + 0x14 * i, 0xFF, NULL);
         AddTextPrinterParameterized(windowId, 2, gStringVar4, 0x60, 0x2E + 0x14 * i, 0xFF, NULL);
     }
 
@@ -908,23 +925,24 @@ static void sub_815E720(void)
     VarSet(VAR_TEMP_1, windowId);
 }
 
-static void sub_815E88C(void)
+static void CloseResultsBoard(void)
 {
     u8 windowId = VarGet(VAR_TEMP_1);
     ClearStdWindowAndFrameToTransparent(windowId, TRUE);
     RemoveWindow(windowId);
 }
 
-static void sub_815E8B4(void)
+static void TrainerTowerGetDoublesEligiblity(void)
 {
     gSpecialVar_Result = GetMonsStateToDoubles();
 }
 
-static void sub_815E8CC(void)
+
+static void TrainerTowerGetNumFloors(void)
 {
-    if (sTrainerTowerState->unk_0004.count != sTrainerTowerState->unk_0004.floors[0].floorIdx)
+    if (sTrainerTowerState->unk_0004.numFloors != sTrainerTowerState->unk_0004.floors[0].floorIdx)
     {
-        ConvertIntToDecimalStringN(gStringVar1, sTrainerTowerState->unk_0004.count, STR_CONV_MODE_LEFT_ALIGN, 1);
+        ConvertIntToDecimalStringN(gStringVar1, sTrainerTowerState->unk_0004.numFloors, STR_CONV_MODE_LEFT_ALIGN, 1);
         gSpecialVar_Result = TRUE;
     }
     else
@@ -933,79 +951,78 @@ static void sub_815E8CC(void)
     }
 }
 
-static void sub_815E908(void)
+// Dummied? equivalent to gSpecialVar_Result = FALSE
+// If it were to return TRUE the player would be warped back to the lobby
+static void ShouldWarpToCounter(void)
 {
-    if (gMapHeader.mapLayoutId == LAYOUT_SEVEN_ISLAND_TRAINER_TOWER_LOBBY && VarGet(VAR_MAP_SCENE_TRAINER_TOWER) == 0)
-    {
+    if (gMapHeader.mapLayoutId == LAYOUT_TRAINER_TOWER_LOBBY && VarGet(VAR_MAP_SCENE_TRAINER_TOWER) == 0)
         gSpecialVar_Result = FALSE;
-    }
     else
-    {
         gSpecialVar_Result = FALSE;
-    }
 }
 
-static void sub_815E948(void)
+static void PlayTrainerTowerEncounterMusic(void)
 {
     s32 i;
-    u16 var_4001 = VarGet(VAR_TEMP_1);
-    u8 r1 = sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[var_4001].facilityClass;
+    u16 idx = VarGet(VAR_TEMP_1);
+    u8 facilityClass = CURR_FLOOR.trainers[idx].facilityClass;
 
     for (i = 0; i < NELEMS(sTrainerEncounterMusicLUT); i++)
     {
-        if (sTrainerEncounterMusicLUT[i].unk0 == gFacilityClassToTrainerClass[r1])
+        if (sTrainerEncounterMusicLUT[i].facilityClass == gFacilityClassToTrainerClass[facilityClass])
             break;
     }
+
     if (i != NELEMS(sTrainerEncounterMusicLUT))
     {
-        var_4001 = sTrainerEncounterMusicLUT[i].unk1;
+        idx = sTrainerEncounterMusicLUT[i].musicId;
     }
     else
     {
-        var_4001 = 0;
+        idx = 0;
     }
-    PlayNewMapMusic(gUnknown_847A2D2[var_4001]);
+    PlayNewMapMusic(sTrainerTowerEncounterMusic[idx]);
 }
 
-static void sub_815E9C8(void)
+static void HasSpokenToOwner(void)
 {
-    gSpecialVar_Result = gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_2;
+    gSpecialVar_Result = TRAINER_TOWER.spokeToOwner;
 }
 
 static void BuildEnemyParty(void)
 {
     u16 trainerIdx = VarGet(VAR_TEMP_1);
     s32 level = GetPartyMaxLevel();
-    u8 floorIdx = gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8;
+    u8 floorIdx = TRAINER_TOWER.floorsCleared;
     s32 i;
     u8 monIdx;
 
     ZeroEnemyPartyMons();
 
-    switch (sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].challengeType)
+    switch (CURR_FLOOR.challengeType)
     {
-    case 0:
+    case CHALLENGE_TYPE_SINGLE:
     default:
         for (i = 0; i < 2; i++)
         {
             monIdx = sSingleBattleChallengeMonIdxs[floorIdx][i];
-            sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[trainerIdx].mons[monIdx].level = level;
-            CreateBattleTowerMon(&gEnemyParty[i], &sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[trainerIdx].mons[monIdx]);
+            CURR_FLOOR.trainers[trainerIdx].mons[monIdx].level = level;
+            CreateBattleTowerMon(&gEnemyParty[i], &CURR_FLOOR.trainers[trainerIdx].mons[monIdx]);
         }
         break;
-    case 1:
+    case CHALLENGE_TYPE_DOUBLE:
         monIdx = sDoubleBattleChallengeMonIdxs[floorIdx][0];
-        sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[0].mons[monIdx].level = level;
-        CreateBattleTowerMon(&gEnemyParty[0], &sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[0].mons[monIdx]);
+        CURR_FLOOR.trainers[0].mons[monIdx].level = level;
+        CreateBattleTowerMon(&gEnemyParty[0], &CURR_FLOOR.trainers[0].mons[monIdx]);
 
         monIdx = sDoubleBattleChallengeMonIdxs[floorIdx][1];
-        sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[1].mons[monIdx].level = level;
-        CreateBattleTowerMon(&gEnemyParty[1], &sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[1].mons[monIdx]);
+        CURR_FLOOR.trainers[1].mons[monIdx].level = level;
+        CreateBattleTowerMon(&gEnemyParty[1], &CURR_FLOOR.trainers[1].mons[monIdx]);
         break;
-    case 2:
+    case CHALLENGE_TYPE_KNOCKOUT:
         monIdx = sKnockoutChallengeMonIdxs[floorIdx][trainerIdx];
-        sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[trainerIdx].mons[monIdx].level = level;
-        CreateBattleTowerMon(&gEnemyParty[0], &sTrainerTowerState->unk_0004.floors[sTrainerTowerState->floorIdx].trainers[trainerIdx].mons[monIdx]);
+        CURR_FLOOR.trainers[trainerIdx].mons[monIdx].level = level;
+        CreateBattleTowerMon(&gEnemyParty[0], &CURR_FLOOR.trainers[trainerIdx].mons[monIdx]);
         break;
     }
 }
@@ -1030,11 +1047,11 @@ static s32 GetPartyMaxLevel(void)
 
 static void ValidateOrResetCurTrainerTowerRecord(void)
 {
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 != sTrainerTowerState->unk_0004.id)
+    if (TRAINER_TOWER.unk9 != sTrainerTowerState->unk_0004.id)
     {
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 = sTrainerTowerState->unk_0004.id;
-        SetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk4, 215999);
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0 = FALSE;
+        TRAINER_TOWER.unk9 = sTrainerTowerState->unk_0004.id;
+        SetTrainerTowerRecordTime(&TRAINER_TOWER.bestTime, TRAINER_TOWER_MAX_TIME);
+        TRAINER_TOWER.receivedPrize = FALSE;
     }
 }
 
@@ -1043,22 +1060,22 @@ void PrintTrainerTowerRecords(void)
     s32 i;
     u8 windowId = 0;
 
-    sub_815DC8C();
+    SetUpTrainerTowerDataStruct();
     FillWindowPixelRect(0, 0, 0, 0, 0xd8, 0x90);
     ValidateOrResetCurTrainerTowerRecord();
-    AddTextPrinterParameterized3(0, 2, 0x4a, 0, gUnknown_847A22C, 0, gUnknown_83FE982);
+    AddTextPrinterParameterized3(0, 2, 0x4a, 0, sTextColors, 0, gText_TimeBoard);
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++)
     {
-        PRINT_TOWER_TIME(GetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[i].unk4));
-        StringExpandPlaceholders(gStringVar4, gUnknown_83FE998);
-        AddTextPrinterParameterized3(windowId, 2, 0x18, 0x24 + 0x14 * i, gUnknown_847A22C, 0, gUnknown_83FE9C4[i]);
-        AddTextPrinterParameterized3(windowId, 2, 0x60, 0x24 + 0x14 * i, gUnknown_847A22C, 0, gStringVar4);
+        PRINT_TOWER_TIME(GetTrainerTowerRecordTime(&gSaveBlock1Ptr->trainerTower[i].bestTime));
+        StringExpandPlaceholders(gStringVar4, gText_XMinYZSec);
+        AddTextPrinterParameterized3(windowId, 2, 0x18, 0x24 + 0x14 * i, sTextColors, 0, gTrainerTowerChallengeTypeTexts[i]);
+        AddTextPrinterParameterized3(windowId, 2, 0x60, 0x24 + 0x14 * i, sTextColors, 0, gStringVar4);
     }
 
     PutWindowTilemap(windowId);
     CopyWindowToVram(windowId, 3);
-    sub_815DD2C();
+    FreeTrainerTowerDataStruct();
 }
 
 static u32 GetTrainerTowerRecordTime(u32 *counter)
@@ -1075,8 +1092,8 @@ void ResetTrainerTowerResults(void)
 {
     s32 i;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++)
     {
-        SetTrainerTowerRecordTime(&gSaveBlock1Ptr->unkArray[i].unk4, 215999);
+        SetTrainerTowerRecordTime(&gSaveBlock1Ptr->trainerTower[i].bestTime, TRAINER_TOWER_MAX_TIME);
     }
 }
diff --git a/src/trig.c b/src/trig.c
index c2bca3059..2181ebef7 100644
--- a/src/trig.c
+++ b/src/trig.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "trig.h"
 
 // Values of sin(x*(π/128)) as Q8.8 fixed-point numbers from x = 0 to x = 319
 const s16 gSineTable[] =
diff --git a/src/union_room.c b/src/union_room.c
index f942fb7d3..7bace05ef 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -37,6 +37,7 @@
 #include "trade_scene.h"
 #include "trainer_card.h"
 #include "union_room.h"
+#include "union_room_battle.h"
 #include "union_room_chat.h"
 #include "rfu_union_tool.h"
 #include "union_room_message.h"
@@ -45,13 +46,15 @@
 #include "constants/cable_club.h"
 #include "constants/field_weather.h"
 #include "constants/species.h"
+#include "constants/trainer_card.h"
+#include "constants/union_room.h"
 
 static EWRAM_DATA u8 sUnionRoomPlayerName[12] = {};
-static EWRAM_DATA u8 gUnknown_203B058 = 0;
-static EWRAM_DATA u8 gUnknown_203B059 = 0;
+static EWRAM_DATA u8 sPlayerCurrActivity = 0;
+static EWRAM_DATA u8 sPlayerActivityGroupSize = 0;
 static EWRAM_DATA union UnkUnion_Main sUnionRoomMain = {};
 static EWRAM_DATA u32 sUnref_203B060 = 0;
-EWRAM_DATA struct GFtgtGnameSub gUnknown_203B064 = {};
+EWRAM_DATA struct GFtgtGnameSub gPartnerTgtGnameSub = {};
 EWRAM_DATA u16 gUnionRoomOfferedSpecies = SPECIES_NONE;
 EWRAM_DATA u8 gUnionRoomRequestedMonType = TYPE_NORMAL;
 static EWRAM_DATA struct UnionRoomTrade sUnionRoomTrade = {};
@@ -60,103 +63,103 @@ static struct UnkStruct_Leader * sLeader;
 static struct UnkStruct_Group * sGroup;
 static struct UnkStruct_URoom * sURoom;
 
-static void sub_8115A68(u8 taskId);
-static void sub_81161E4(struct UnkStruct_Leader * leader);
-static bool8 sub_8116444(struct UnkStruct_Leader * leader, u32 a1, u32 a2);
-static void sub_81164C8(u8 windowId, s32 itemId, u8 y);
-static u8 sub_8116524(struct UnkStruct_Main0 * a0);
-static u8 sub_81165E8(struct UnkStruct_Main0 * a0);
-static void sub_8116738(u8 taskId);
-static u32 sub_8116D10(struct UnkStruct_Group * group, s32 id);
-static void sub_8116D60(struct UnkStruct_Group * group, s32 id);
-static void sub_8116E1C(u8 taskId);
-static void sub_8116F94(u8 windowId, s32 itemId, u8 y);
-static u8 sub_8116FE4(void);
-static void sub_8117990(void);
-static void sub_81179A4(void);
-static void sub_8117A0C(u8 taskId);
-static void sub_8117F20(u8 taskId);
-static void sub_81182DC(u8 taskId);
-static void sub_81186E0(u8 taskId);
+static void Task_TryBecomeLinkLeader(u8 taskId);
+static void Leader_DestroyResources(struct UnkStruct_Leader * leader);
+static bool8 Leader_SetStateIfMemberListChanged(struct UnkStruct_Leader * leader, u32 state1, u32 state2);
+static void ItemPrintFunc_PossibleGroupMembers(u8 windowId, s32 itemId, u8 y);
+static u8 LeaderUpdateGroupMembership(struct UnkStruct_Main0 * main0);
+static u8 UnionRoomLeaderField0CompactionAndCount(struct UnkStruct_Main0 * main0);
+static void Task_TryJoinLinkGroup(u8 taskId);
+static u32 IsTryingToTradeWithHoennTooSoon(struct UnkStruct_Group * group, s32 id);
+static void AskToJoinRfuGroup(struct UnkStruct_Group * group, s32 id);
+static void Task_ListenToWireless(u8 taskId);
+static void ListMenuItemPrintFunc_UnionRoomGroups(u8 windowId, s32 itemId, u8 y);
+static u8 GetNewLeaderCandidate(void);
+static void CreateTask_RunScriptAndFadeToActivity(void);
+static void CreateTask_StartActivity(void);
+static void Task_MEvent_Leader(u8 taskId);
+static void Task_CardOrNewsWithFriend(u8 taskId);
+static void Task_CardOrNewsOverWireless(u8 taskId);
+static void Task_RunUnionRoom(u8 taskId);
 static u16 ReadAsU16(const u8 *data);
-static void sub_8119904(struct UnkStruct_URoom * uRoom);
-static bool32 sub_8119944(struct UnkStruct_URoom * uRoom);
-static void sub_81199FC(u8 taskId);
-static u8 sub_8119B94(void);
-static u8 sub_8119E84(struct UnkStruct_Main4 * arg0, struct UnkStruct_Main4 * arg1, u32 arg2);
-static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1);
-static u8 sub_811A054(struct UnkStruct_Main4 * arg0, u32 arg1);
-static u8 sub_811A084(struct UnkStruct_Main4 * arg0, u32 arg1);
-static bool32 sub_811A0B4(const u8 * str);
-static bool32 sub_811A0E0(void);
+static void ReceiveUnionRoomActivityPacket(struct UnkStruct_URoom * uRoom);
+static bool32 UnionRoom_HandleContactFromOtherPlayer(struct UnkStruct_URoom * uRoom);
+static void Task_InitUnionRoom(u8 taskId);
+static u8 HandlePlayerListUpdate(void);
+static u8 CreateTask_SearchForChildOrParent(struct UnkStruct_Main4 * main4, struct UnkStruct_Main4 * arg1, u32 arg2);
+static bool32 GetGnameWonderFlagByLinkGroup(struct GFtgtGname * gname, s16 linkGroup);
+static u8 CreateTask_ListenForPartnersWithCompatibleSerialNos(struct UnkStruct_Main4 * main4, u32 linkGroup);
+static u8 CreateTask_ListenForPartnersWithSerial7F7D(struct UnkStruct_Main4 * main4, u32 linkGroup);
+static bool32 UR_PrintFieldMessage(const u8 * str);
+static bool32 UR_RunTextPrinters_CheckPrinter0Active(void);
 static bool8 PrintOnTextbox(u8 *textState, const u8 *str);
-static s8 sub_811A14C(u8 *dest, bool32 arg1);
-static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate);
-static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * arg6);
-static void sub_811A3F8(void);
-static void sub_811A41C(void);
-static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx);
-static void sub_811A5E4(struct UnkStruct_x20 * arg0, u8 count);
-static void sub_811A650(struct UnkStruct_x1C * arg0, u8 count);
-static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_Shared * arg1);
-static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Shared * arg1);
-static u32 sub_811A748(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1);
-static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1, u8 arg2);
-static void sub_811A81C(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * arg3, u8 arg4, u8 id);
-static void sub_811A910(u8 arg0, u8 arg1, u8 arg2, struct UnkStruct_x20 * arg3, u8 arg4, u8 id);
-static bool32 sub_811A9B8(void);
-static u32 sub_811A9FC(s32 a0);
-static u32 sub_811AA24(struct UnkStruct_x20 * unkX20);
-static s32 sub_811AA5C(struct UnkStruct_Main0 * arg0, u8 arg1, u8 arg2, u32 playerGender);
+static s8 UnionRoomHandleYesNo(u8 *state_p, bool32 no_draw);
+static s32 ListMenuHandler_AllItemsAvailable(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate);
+static s32 TradeBoardMenuHandler(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, u8 *trade_board_win_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * traders);
+static void UR_BlankBg0(void);
+static void JoinGroup_BlankBg0AndEnableScriptContexts(void);
+static void UR_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx);
+static void BlankUnkStruct_x20Array(struct UnkStruct_x20 * x20, u8 count);
+static void BlankUnkStruct_x1CArray(struct UnkStruct_x1C * x1C, u8 count);
+static bool8 AreGnameUnameDifferent(struct UnionGnameUnamePair * arg0, const struct UnionGnameUnamePair * arg1);
+static bool32 AreUnionRoomPlayerGnamesDifferent(struct UnionGnameUnamePair * arg0, struct UnionGnameUnamePair * arg1);
+static u32 Findx20Inx1CArray(struct UnkStruct_x20 * x20, struct UnkStruct_x1C * x1Carr);
+static u8 Appendx1Ctox20(struct UnkStruct_x20 * x20arr, struct UnkStruct_x1C * x1C, u8 count);
+static void PrintUnionRoomGroupOnWindow(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id);
+static void PrintGroupMemberCandidateOnWindowWithColor(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id);
+static bool32 PlayerIsTalkingToUnionRoomAide(void);
+static u32 GetResponseIdx_InviteToURoomActivity(s32 activity);
+static u32 ConvPartnerUnameAndGetWhetherMetAlready(struct UnkStruct_x20 * unkX20);
+static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, u8 overrideGender, u8 playerIdx, u32 playerGender);
 static void nullsub_92(u8 windowId, s32 itemId, u8 y);
-static void sub_811ACA4(u8 windowId, s32 itemId, u8 y);
-static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1);
-static s32 GetUnionRoomPlayerGender(s32 a0, struct UnkStruct_Main0 * a1);
-static s32 sub_811ADD0(u32 type, u32 species);
-static void sub_811AE68(u8 *dst, s32 arg1, u32 playerGender);
-static void sub_811AECC(u8 *dst, u8 arg1);
-static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * arg3);
-static bool32 sub_811B0A4(struct UnkStruct_URoom * arg0);
+static void TradeBoardListMenuItemPrintFunc(u8 windowId, s32 itemId, u8 y);
+static s32 GetIndexOfNthTradeBoardOffer(struct UnkStruct_x20 * x20, s32 n);
+static s32 GetUnionRoomPlayerGender(s32 playerIdx, struct UnkStruct_Main0 * main0);
+static s32 IsRequestedTypeAndSpeciesInPlayerParty(u32 type, u32 species);
+static void GetURoomActivityRejectMsg(u8 *dst, s32 activity, u32 playerGender);
+static void GetURoomActivityStartMsg(u8 *dst, u8 activity);
+static s32 GetChatLeaderActionRequestMessage(u8 *dst, u32 gender, u16 *activity_p, struct UnkStruct_URoom * uroom);
+static bool32 PollPartnerYesNoResponse(struct UnkStruct_URoom * uroom);
 static bool32 HasAtLeastTwoMonsOfLevel30OrLower(void);
 static void ResetUnionRoomTrade(struct UnionRoomTrade * trade);
 static bool32 RegisterTradeMonAndGetIsEgg(u32 monId, struct UnionRoomTrade * trade);
 static void RegisterTradeMon(u32 monId, struct UnionRoomTrade * trade);
 static u32 GetPartyPositionOfRegisteredMon(struct UnionRoomTrade * trade, u8 mpId);
-static void sub_811B258(bool32 a0);
-static void sub_811B298(void);
-static u8 sub_811B2A8(s32 a0);
-static u8 sub_811B2D8(struct UnkStruct_URoom * arg0);
-static void sub_811B31C(u8 *dest, struct UnkStruct_URoom * uRoom, bool8 gender);
+static void HandleCancelTrade(bool32 unlockObjs);
+static void UR_EnableScriptContext2AndFreezeObjectEvents(void);
+static u8 GetSinglePartnerSpriteGenderParam(s32 linkPlayer);
+static u8 GetActivePartnerSpriteGenderParam(struct UnkStruct_URoom * uroom);
+static void ViewURoomPartnerTrainerCard(u8 *dest, struct UnkStruct_URoom * uRoom, bool8 parent_child);
 
 #define _8456CD8(a, b) ((a) | ((b) << 8))
 
-static const u8 *const gUnknown_8456C74[] = {
-    gUnknown_84571AC,
-    gUnknown_8459394,
-    gUnknown_84593A4,
-    gUnknown_84593B4,
-    gUnknown_84593C4,
-    gUnknown_84593D4,
-    gUnknown_84593E4,
-    gUnknown_84593F4,
-    gUnknown_84593DC,
-    gUnknown_8459400,
-    gUnknown_8459410,
-    gUnknown_845941C,
-    gUnknown_845942C,
-    gUnknown_8459434,
-    gUnknown_8459440,
-    gUnknown_84571AC,
-    gUnknown_84571AC,
-    gUnknown_84571AC,
-    gUnknown_84571AC,
-    gUnknown_84571AC,
-    gUnknown_84571AC,
-    gUnknown_84593E4,
-    gUnknown_84593F4
+static const u8 *const sUnionRoomActivityStringPtrs[] = {
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_SingleBattle,
+    gUnionRoomActivity_DoubleBattle,
+    gUnionRoomActivity_MultiBattle,
+    gUnionRoomActivity_PokemonTrades,
+    gUnionRoomActivity_Chat,
+    gUnionRoomActivity_WonderCards,
+    gunionRoomActivity_WonderNews,
+    gUnionRoomActivity_Cards,
+    gUnionRoomActivity_PokemonJump,
+    gUnionRoomActivity_BerryCrush,
+    gUnionRoomActivity_BerryPicking,
+    gUnionRoomActivity_Search,
+    gUnionRoomActivity_SpinTradeJP,
+    gUnionRoomActivity_ItemTradeJP,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_Blank,
+    gUnionRoomActivity_WonderCards,
+    gunionRoomActivity_WonderNews
 };
 
-static const struct WindowTemplate gUnknown_8456CD0 = {
+static const struct WindowTemplate sWindowTemplate_BButtonCancel = {
     .bg = 0,
     .tilemapLeft = 0,
     .tilemapTop = 0,
@@ -166,19 +169,19 @@ static const struct WindowTemplate gUnknown_8456CD0 = {
     .baseBlock = 0x008
 };
 
-static const u32 gUnknown_8456CD8[] = {
-    _8456CD8( 1,  2),
-    _8456CD8( 2,  2),
-    _8456CD8( 3,  4),
-    _8456CD8( 4,  2),
-    _8456CD8( 9, 37),
-    _8456CD8(10, 37),
-    _8456CD8(11, 53),
-    _8456CD8(13, 53),
-    _8456CD8(14, 53)
+static const u32 sLinkGroupToActivityAndCapacity[] = {
+    [LINK_GROUP_SINGLE_BATTLE] = _8456CD8(ACTIVITY_BATTLE,    2),
+    [LINK_GROUP_DOUBLE_BATTLE] = _8456CD8(ACTIVITY_DBLBATTLE, 2),
+    [LINK_GROUP_MULTI_BATTLE]  = _8456CD8(ACTIVITY_MLTBATTLE, 4),
+    [LINK_GROUP_TRADE]         = _8456CD8(ACTIVITY_TRADE,     2),
+    [LINK_GROUP_POKEMON_JUMP]  = _8456CD8(ACTIVITY_PJUMP,     5 | 0x20),
+    [LINK_GROUP_BERRY_CRUSH]   = _8456CD8(ACTIVITY_BCRUSH,    5 | 0x20),
+    [LINK_GROUP_BERRY_PICKING] = _8456CD8(ACTIVITY_BPICK,     5 | 0x30),
+    [LINK_GROUP_WONDER_CARD]   = _8456CD8(ACTIVITY_SPINTRADE, 5 | 0x30),
+    [LINK_GROUP_WONDER_NEWS]   = _8456CD8(ACTIVITY_ITEMTRADE, 5 | 0x30)
 };
 
-static const struct WindowTemplate gUnknown_8456CFC = {
+static const struct WindowTemplate sWindowTemplate_List_PossibleGroupMembers = {
     .bg = 0,
     .tilemapLeft = 1,
     .tilemapTop = 3,
@@ -188,7 +191,7 @@ static const struct WindowTemplate gUnknown_8456CFC = {
     .baseBlock = 0x044
 };
 
-static const struct WindowTemplate gUnknown_8456D04 = {
+static const struct WindowTemplate sWindowTemplate_NumPlayerMode = {
     .bg = 0,
     .tilemapLeft = 16,
     .tilemapTop = 3,
@@ -198,18 +201,18 @@ static const struct WindowTemplate gUnknown_8456D04 = {
     .baseBlock = 0x0C6
 };
 
-const struct ListMenuItem gUnknown_8456D0C[] = {
-    {gUnknown_84571AC, 0},
-    {gUnknown_84571AC, 1},
-    {gUnknown_84571AC, 2},
-    {gUnknown_84571AC, 3},
-    {gUnknown_84571AC, 4}
+const struct ListMenuItem sListMenuItems_PossibleGroupMembers[] = {
+    {gUnionRoomActivity_Blank, 0},
+    {gUnionRoomActivity_Blank, 1},
+    {gUnionRoomActivity_Blank, 2},
+    {gUnionRoomActivity_Blank, 3},
+    {gUnionRoomActivity_Blank, 4}
 };
 
-static const struct ListMenuTemplate gUnknown_8456D34 = {
-    .items = gUnknown_8456D0C,
+static const struct ListMenuTemplate sListMenuTemplate_PossibleGroupMembers = {
+    .items = sListMenuItems_PossibleGroupMembers,
     .moveCursorFunc = NULL,
-    .itemPrintFunc = sub_81164C8,
+    .itemPrintFunc = ItemPrintFunc_PossibleGroupMembers,
     .totalItems = 5,
     .maxShowed = 5,
     .windowId = 0,
@@ -227,7 +230,7 @@ static const struct ListMenuTemplate gUnknown_8456D34 = {
     .cursorKind = 1
 };
 
-static const struct WindowTemplate gUnknown_8456D4C = {
+static const struct WindowTemplate sWindowTemplate_MysteryGiftList = {
     .bg = 0,
     .tilemapLeft = 1,
     .tilemapTop = 3,
@@ -237,7 +240,7 @@ static const struct WindowTemplate gUnknown_8456D4C = {
     .baseBlock = 0x044
 };
 
-static const struct WindowTemplate gUnknown_8456D54 = {
+static const struct WindowTemplate sWindowTemplate_MysteryGiftPlayerNameAndId = {
     .bg = 0,
     .tilemapLeft = 20,
     .tilemapTop = 3,
@@ -247,29 +250,29 @@ static const struct WindowTemplate gUnknown_8456D54 = {
     .baseBlock = 0x0EE
 };
 
-static const struct ListMenuItem gUnknown_8456D5C[] = {
-    {gUnknown_84571AC,  0},
-    {gUnknown_84571AC,  1},
-    {gUnknown_84571AC,  2},
-    {gUnknown_84571AC,  3},
-    {gUnknown_84571AC,  4},
-    {gUnknown_84571AC,  5},
-    {gUnknown_84571AC,  6},
-    {gUnknown_84571AC,  7},
-    {gUnknown_84571AC,  8},
-    {gUnknown_84571AC,  9},
-    {gUnknown_84571AC, 10},
-    {gUnknown_84571AC, 11},
-    {gUnknown_84571AC, 12},
-    {gUnknown_84571AC, 13},
-    {gUnknown_84571AC, 14},
-    {gUnknown_84571AC, 15}
+static const struct ListMenuItem sListMenuItems_UnionRoomGroups[] = {
+    {gUnionRoomActivity_Blank,  0},
+    {gUnionRoomActivity_Blank,  1},
+    {gUnionRoomActivity_Blank,  2},
+    {gUnionRoomActivity_Blank,  3},
+    {gUnionRoomActivity_Blank,  4},
+    {gUnionRoomActivity_Blank,  5},
+    {gUnionRoomActivity_Blank,  6},
+    {gUnionRoomActivity_Blank,  7},
+    {gUnionRoomActivity_Blank,  8},
+    {gUnionRoomActivity_Blank,  9},
+    {gUnionRoomActivity_Blank, 10},
+    {gUnionRoomActivity_Blank, 11},
+    {gUnionRoomActivity_Blank, 12},
+    {gUnionRoomActivity_Blank, 13},
+    {gUnionRoomActivity_Blank, 14},
+    {gUnionRoomActivity_Blank, 15}
 };
 
-static const struct ListMenuTemplate gUnknown_8456DDC = {
-    .items = gUnknown_8456D5C,
+static const struct ListMenuTemplate sListMenuTemplate_UnionRoomGroups = {
+    .items = sListMenuItems_UnionRoomGroups,
     .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
-    .itemPrintFunc = sub_8116F94,
+    .itemPrintFunc = ListMenuItemPrintFunc_UnionRoomGroups,
     .totalItems = 16,
     .maxShowed = 5,
     .windowId = 0,
@@ -287,7 +290,7 @@ static const struct ListMenuTemplate gUnknown_8456DDC = {
     .cursorKind = 0
 };
 
-static const struct WindowTemplate gUnknown_8456DF4 = {
+static const struct WindowTemplate sWindowTemplate_InviteToActivity = {
     .bg = 0,
     .tilemapLeft = 20,
     .tilemapTop = 6,
@@ -297,15 +300,15 @@ static const struct WindowTemplate gUnknown_8456DF4 = {
     .baseBlock = 0x001
 };
 
-static const struct ListMenuItem gUnknown_8456DFC[] = {
-    {gUnknown_8459354,  _8456CD8( 8, 2)},
-    {gUnknown_8459344,  _8456CD8(65, 2)},
-    {gUnknown_845934C,  _8456CD8(69, 2)},
-    {gUnknown_8459360,  _8456CD8(64, 0)}
+static const struct ListMenuItem sListMenuItems_InviteToActivity[] = {
+    {gUnknown_8459354,  _8456CD8( ACTIVITY_CARD, 2)},
+    {gUnknown_8459344,  _8456CD8(ACTIVITY_BATTLE | IN_UNION_ROOM, 2)},
+    {gUnknown_845934C,  _8456CD8(ACTIVITY_CHAT | IN_UNION_ROOM, 2)},
+    {gUnknown_8459360,  _8456CD8(ACTIVITY_NONE | IN_UNION_ROOM, 0)}
 };
 
-static const struct ListMenuTemplate gUnknown_8456E1C = {
-    .items = gUnknown_8456DFC,
+static const struct ListMenuTemplate sListMenuTemplate_InviteToActivity = {
+    .items = sListMenuItems_InviteToActivity,
     .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
     .itemPrintFunc = NULL,
     .totalItems = 4,
@@ -325,7 +328,7 @@ static const struct ListMenuTemplate gUnknown_8456E1C = {
     .cursorKind = 0
 };
 
-static const struct WindowTemplate gUnknown_8456E34 = {
+static const struct WindowTemplate sWindowTemplate_TradeBoardRegisterInfoExit = {
     .bg = 0,
     .tilemapLeft = 18,
     .tilemapTop = 8,
@@ -341,7 +344,7 @@ static const struct ListMenuItem gUnknown_8456E3C[] = {
     {gUnknown_8459360, 3}
 };
 
-static const struct ListMenuTemplate gUnknown_8456E54 = {
+static const struct ListMenuTemplate sListMenuTemplate_TradeBoardRegisterInfoExit = {
     .items = gUnknown_8456E3C,
     .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
     .itemPrintFunc = NULL,
@@ -362,7 +365,7 @@ static const struct ListMenuTemplate gUnknown_8456E54 = {
     .cursorKind = 0
 };
 
-static const struct WindowTemplate gUnknown_8456E6C = {
+static const struct WindowTemplate sWindowTemplate_TypeNames = {
     .bg = 0,
     .tilemapLeft = 20,
     .tilemapTop = 2,
@@ -372,7 +375,7 @@ static const struct WindowTemplate gUnknown_8456E6C = {
     .baseBlock = 0x001
 };
 
-static const struct ListMenuItem gUnknown_8456E74[] = {
+static const struct ListMenuItem sListMenuItems_TypeNames[] = {
     {gTypeNames[TYPE_NORMAL],     TYPE_NORMAL},
     {gTypeNames[TYPE_FIRE],         TYPE_FIRE},
     {gTypeNames[TYPE_WATER],       TYPE_WATER},
@@ -393,8 +396,8 @@ static const struct ListMenuItem gUnknown_8456E74[] = {
     {gUnknown_8459360,           NUMBER_OF_MON_TYPES}
 };
 
-static const struct ListMenuTemplate gUnknown_8456F04 = {
-    .items = gUnknown_8456E74,
+static const struct ListMenuTemplate sListMenuTemplate_TypeNames = {
+    .items = sListMenuItems_TypeNames,
     .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
     .itemPrintFunc = NULL,
     .totalItems = NUMBER_OF_MON_TYPES,
@@ -414,7 +417,7 @@ static const struct ListMenuTemplate gUnknown_8456F04 = {
     .cursorKind = 0
 };
 
-static const struct WindowTemplate gUnknown_8456F1C = {
+static const struct WindowTemplate sTradeBoardWindowTemplate = {
     .bg = 0,
     .tilemapLeft = 1,
     .tilemapTop = 1,
@@ -434,23 +437,23 @@ static const struct WindowTemplate gUnknown_8456F24 = {
     .baseBlock = 0x039
 };
 
-static const struct ListMenuItem gUnknown_8456F2C[] = {
-    {gUnknown_84571AC, -3},
-    {gUnknown_84571AC, 0},
-    {gUnknown_84571AC, 1},
-    {gUnknown_84571AC, 2},
-    {gUnknown_84571AC, 3},
-    {gUnknown_84571AC, 4},
-    {gUnknown_84571AC, 5},
-    {gUnknown_84571AC, 6},
-    {gUnknown_84571AC, 7},
+static const struct ListMenuItem sTradeBoardListMenuItems[] = {
+    {gUnionRoomActivity_Blank, -3},
+    {gUnionRoomActivity_Blank, 0},
+    {gUnionRoomActivity_Blank, 1},
+    {gUnionRoomActivity_Blank, 2},
+    {gUnionRoomActivity_Blank, 3},
+    {gUnionRoomActivity_Blank, 4},
+    {gUnionRoomActivity_Blank, 5},
+    {gUnionRoomActivity_Blank, 6},
+    {gUnionRoomActivity_Blank, 7},
     {gUnknown_8459368, 8}
 };
 
-static const struct ListMenuTemplate gUnknown_8456F7C = {
-    .items = gUnknown_8456F2C,
+static const struct ListMenuTemplate sTradeBoardListMenuTemplate = {
+    .items = sTradeBoardListMenuItems,
     .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
-    .itemPrintFunc = sub_811ACA4,
+    .itemPrintFunc = TradeBoardListMenuItemPrintFunc,
     .totalItems = 10,
     .maxShowed = 5,
     .windowId = 0,
@@ -479,22 +482,22 @@ static const struct WindowTemplate gUnknown_8456F94 = {
 };
 
 static const struct ListMenuItem gUnknown_8456F9C[] = {
-    {gUnknown_84571AC,  0},
-    {gUnknown_84571AC,  1},
-    {gUnknown_84571AC,  2},
-    {gUnknown_84571AC,  3},
-    {gUnknown_84571AC,  4},
-    {gUnknown_84571AC,  5},
-    {gUnknown_84571AC,  6},
-    {gUnknown_84571AC,  7},
-    {gUnknown_84571AC,  8},
-    {gUnknown_84571AC,  9},
-    {gUnknown_84571AC, 10},
-    {gUnknown_84571AC, 11},
-    {gUnknown_84571AC, 12},
-    {gUnknown_84571AC, 13},
-    {gUnknown_84571AC, 14},
-    {gUnknown_84571AC, 15}
+    {gUnionRoomActivity_Blank,  0},
+    {gUnionRoomActivity_Blank,  1},
+    {gUnionRoomActivity_Blank,  2},
+    {gUnionRoomActivity_Blank,  3},
+    {gUnionRoomActivity_Blank,  4},
+    {gUnionRoomActivity_Blank,  5},
+    {gUnionRoomActivity_Blank,  6},
+    {gUnionRoomActivity_Blank,  7},
+    {gUnionRoomActivity_Blank,  8},
+    {gUnionRoomActivity_Blank,  9},
+    {gUnionRoomActivity_Blank, 10},
+    {gUnionRoomActivity_Blank, 11},
+    {gUnionRoomActivity_Blank, 12},
+    {gUnionRoomActivity_Blank, 13},
+    {gUnionRoomActivity_Blank, 14},
+    {gUnionRoomActivity_Blank, 15}
 };
 
 static const struct ListMenuTemplate gUnknown_845701C = {
@@ -518,54 +521,138 @@ static const struct ListMenuTemplate gUnknown_845701C = {
     .cursorKind = 0
 };
 
-static const struct UnkStruct_Shared gUnknown_8457034 = {};
+static const struct UnionGnameUnamePair sUnionGnameUnamePair_Dummy = {};
 
 // starts at gUnknown_082F0474 in pokeemerald, union link groups
 
-ALIGNED(4) static const u8 gUnknown_845704C[] = {0x01, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457050[] = {0x02, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457054[] = {0x03, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457058[] = {0x04, 0xFF};
-ALIGNED(4) static const u8 gUnknown_845705C[] = {0x09, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457060[] = {0x0A, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457064[] = {0x0B, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457068[] = {0x15, 0xFF};
-ALIGNED(4) static const u8 gUnknown_845706C[] = {0x16, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457070[] = {0x40, 0x41, 0x44, 0x45, 0x48, 0x51, 0x52, 0x53, 0x54, 0xFF};
-ALIGNED(4) static const u8 gUnknown_845707C[] = {0x0C, 0xFF};
-ALIGNED(4) static const u8 gUnknown_8457080[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B, 0x15, 0x16, 0x0D, 0xFF};
-ALIGNED(4) static const u8 gUnknown_845708C[] = {0x01, 0x02, 0x03, 0x04, 0x0A, 0xFF};
-
-static const u8 *const gUnknown_8457094[] = {
-    gUnknown_845704C,
-    gUnknown_8457050,
-    gUnknown_8457054,
-    gUnknown_8457058,
-    gUnknown_845705C,
-    gUnknown_8457060,
-    gUnknown_8457064,
-    gUnknown_8457068,
-    gUnknown_845706C,
-    gUnknown_8457070,
-    gUnknown_845707C,
-    gUnknown_8457080,
-    gUnknown_845708C
+ALIGNED(4) static const u8 gUnknown_845704C[] = {
+    ACTIVITY_BATTLE,
+    0xFF
 };
 
-static const u8 gUnknown_84570C8[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B, 0x15, 0x16, 0xF7, 0x00, 0xAF, 0xF7, 0x01, 0xFF, 0x00};
+ALIGNED(4) static const u8 gUnknown_8457050[] = {
+    ACTIVITY_DBLBATTLE,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457054[] = {
+    ACTIVITY_MLTBATTLE,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457058[] = {
+    ACTIVITY_TRADE,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_845705C[] = {
+    ACTIVITY_PJUMP,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457060[] = {
+    ACTIVITY_BCRUSH,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457064[] = {
+    ACTIVITY_BPICK,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457068[] = {
+    ACTIVITY_WCARD2,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_845706C[] = {
+    ACTIVITY_WNEWS2,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457070[] = {
+    ACTIVITY_NONE | IN_UNION_ROOM,
+    ACTIVITY_BATTLE | IN_UNION_ROOM,
+    ACTIVITY_TRADE | IN_UNION_ROOM,
+    ACTIVITY_CHAT | IN_UNION_ROOM,
+    ACTIVITY_CARD | IN_UNION_ROOM,
+    ACTIVITY_ACCEPT | IN_UNION_ROOM,
+    ACTIVITY_DECLINE | IN_UNION_ROOM,
+    ACTIVITY_NPCTALK | IN_UNION_ROOM,
+    ACTIVITY_PLYRTALK | IN_UNION_ROOM,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_845707C[] = {
+    ACTIVITY_SEARCH,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_8457080[] = {
+    ACTIVITY_BATTLE,
+    ACTIVITY_DBLBATTLE,
+    ACTIVITY_MLTBATTLE,
+    ACTIVITY_TRADE,
+    ACTIVITY_PJUMP,
+    ACTIVITY_BCRUSH,
+    ACTIVITY_BPICK,
+    ACTIVITY_WCARD2,
+    ACTIVITY_WNEWS2,
+    ACTIVITY_SPINTRADE,
+    0xFF
+};
+
+ALIGNED(4) static const u8 gUnknown_845708C[] = {
+    ACTIVITY_BATTLE,
+    ACTIVITY_DBLBATTLE,
+    ACTIVITY_MLTBATTLE,
+    ACTIVITY_TRADE,
+    ACTIVITY_BCRUSH,
+    0xFF
+};
+
+static const u8 *const sAcceptedActivityIds[] = {
+    [LINK_GROUP_SINGLE_BATTLE] = gUnknown_845704C,
+    [LINK_GROUP_DOUBLE_BATTLE] = gUnknown_8457050,
+    [LINK_GROUP_MULTI_BATTLE]  = gUnknown_8457054,
+    [LINK_GROUP_TRADE]         = gUnknown_8457058,
+    [LINK_GROUP_POKEMON_JUMP]  = gUnknown_845705C,
+    [LINK_GROUP_BERRY_CRUSH]   = gUnknown_8457060,
+    [LINK_GROUP_BERRY_PICKING] = gUnknown_8457064,
+    [LINK_GROUP_WONDER_CARD]   = gUnknown_8457068,
+    [LINK_GROUP_WONDER_NEWS]   = gUnknown_845706C,
+    [9]                        = gUnknown_8457070,
+    [10]                       = gUnknown_845707C,
+    [11]                       = gUnknown_8457080,
+    [12]                       = gUnknown_845708C
+};
+
+static const u8 sLinkGroupToURoomActivity[] = {
+    [LINK_GROUP_SINGLE_BATTLE] = ACTIVITY_BATTLE,
+    [LINK_GROUP_DOUBLE_BATTLE] = ACTIVITY_DBLBATTLE,
+    [LINK_GROUP_MULTI_BATTLE]  = ACTIVITY_MLTBATTLE,
+    [LINK_GROUP_TRADE]         = ACTIVITY_TRADE,
+    [LINK_GROUP_POKEMON_JUMP]  = ACTIVITY_PJUMP,
+    [LINK_GROUP_BERRY_CRUSH]   = ACTIVITY_BCRUSH,
+    [LINK_GROUP_BERRY_PICKING] = ACTIVITY_BPICK,
+    [LINK_GROUP_WONDER_CARD]   = ACTIVITY_WCARD2,
+    [LINK_GROUP_WONDER_NEWS]   = ACTIVITY_WNEWS2
+};
+
+static const u8 sUnref_84570D1[] = _("{DYNAMIC 00}·{DYNAMIC 01}");
 
 #undef _8456CD8
 
 // These are functions in Emerald but inlined in FireRed
 
-#define IntlConvPartnerUname7(dest, arg1) ({                              \
-    StringCopy7(dest, (arg1).unk.playerName);                             \
-    ConvertInternationalString(dest, (arg1).unk.gname.unk_00.unk_00_0); \
+#define IntlConvPartnerUname7(dest, arg1) ({                            \
+    StringCopy7(dest, (arg1).gname_uname.uname);                           \
+    ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \
 })
 
-#define IntlConvPartnerUname(dest, arg1) ({                               \
-    StringCopy(dest, (arg1).unk.playerName);                              \
-    ConvertInternationalString(dest, (arg1).unk.gname.unk_00.unk_00_0); \
+#define IntlConvPartnerUname(dest, arg1) ({                             \
+    StringCopy(dest, (arg1).gname_uname.uname);                            \
+    ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \
 })
 
 #define CopyTrainerCardData(dest, src, _version) ({ \
@@ -578,47 +665,56 @@ static const u8 gUnknown_84570C8[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B,
     _maxWidth - strWidth;                                          \
 })
 
-static void sub_811586C(u8 windowId, u8 arg1, u8 stringId)
+// capacityCode is a 2-nybble code
+// Bits 0-3: Capacity
+// Bits 4-7: Min required (if 0, must have exactly Capacity players
+static void PrintNumPlayersWaitingForMsg(u8 windowId, u8 capacityCode, u8 count)
 {
     FillWindowPixelBuffer(windowId, PIXEL_FILL(1));
-    switch (arg1 << 8)
+    switch (capacityCode << 8)
     {
     case 0x200:
-        sub_811A444(windowId, 2, gUnknown_845742C[0][stringId - 1], 0, 2, 0);
+        UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[0][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE);
         break;
     case 0x400:
-        sub_811A444(windowId, 2, gUnknown_845742C[1][stringId - 1], 0, 2, 0);
+        UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[1][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE);
         break;
     case 0x2500:
-        sub_811A444(windowId, 2, gUnknown_845742C[2][stringId - 1], 0, 2, 0);
+        UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[2][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE);
         break;
     case 0x3500:
-        sub_811A444(windowId, 2, gUnknown_845742C[3][stringId - 1], 0, 2, 0);
+        UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[3][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE);
         break;
     }
 
     CopyWindowToVram(windowId, 2);
 }
 
-static void sub_8115924(u8 windowId)
+static void PrintPlayerNameAndIdOnWindow(u8 windowId)
 {
     u8 text[12];
     u8 text2[12];
 
-    sub_811A444(windowId, 2, gSaveBlock2Ptr->playerName, 0, 2, 0);
+    UR_AddTextPrinterParameterized(windowId, 2, gSaveBlock2Ptr->playerName, 0, 2, UR_COLOR_DKE_WHT_LTE);
     StringCopy(text2, gUnknown_84571B4);
     ConvertIntToDecimalStringN(text, ReadAsU16(gSaveBlock2Ptr->playerTrainerId), STR_CONV_MODE_LEADING_ZEROS, 5);
     StringAppend(text2, text);
-    sub_811A444(windowId, 0, text2, 0, 0x10, 0);
+    UR_AddTextPrinterParameterized(windowId, 0, text2, 0, 0x10, UR_COLOR_DKE_WHT_LTE);
 }
 
-static void sub_811599C(u8 *dst, u8 caseId)
+static void StringExpandPlaceholders_AwaitingCommFromAnother(u8 *dst, u8 caseId)
 {
     switch (caseId)
     {
-    case 1 ... 4:
-    case 9 ... 11:
-    case 21 ... 22:
+    case ACTIVITY_BATTLE:
+    case ACTIVITY_DBLBATTLE:
+    case ACTIVITY_MLTBATTLE:
+    case ACTIVITY_TRADE:
+    case ACTIVITY_PJUMP:
+    case ACTIVITY_BCRUSH:
+    case ACTIVITY_BPICK:
+    case ACTIVITY_WCARD2:
+    case ACTIVITY_WNEWS2:
         // UB: argument *dst isn't used, instead it always prints to gStringVar4
         StringExpandPlaceholders(gStringVar4, gUnknown_8457234);
         break;
@@ -630,7 +726,7 @@ void TryBecomeLinkLeader(void)
     u8 taskId;
     struct UnkStruct_Leader * dataPtr;
 
-    taskId = CreateTask(sub_8115A68, 0);
+    taskId = CreateTask(Task_TryBecomeLinkLeader, 0);
     sUnionRoomMain.leader = dataPtr = (void*)(gTasks[taskId].data);
     sLeader = dataPtr;
 
@@ -639,7 +735,7 @@ void TryBecomeLinkLeader(void)
     gSpecialVar_Result = 0;
 }
 
-static void sub_8115A68(u8 taskId)
+static void Task_TryBecomeLinkLeader(u8 taskId)
 {
     u32 id, val;
     struct UnkStruct_Leader * data = sUnionRoomMain.leader;
@@ -647,63 +743,63 @@ static void sub_8115A68(u8 taskId)
     switch (data->state)
     {
     case 0:
-        gUnknown_203B058 = gUnknown_8456CD8[gSpecialVar_0x8004];
-        gUnknown_203B059 = gUnknown_8456CD8[gSpecialVar_0x8004] >> 8;
-        SetHostRFUtgtGname(gUnknown_203B058, 0, 0);
-        sub_800B1F4();
+        sPlayerCurrActivity = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004];
+        sPlayerActivityGroupSize = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004] >> 8;
+        SetHostRFUtgtGname(sPlayerCurrActivity, 0, 0);
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBB8C(gUnknown_203B059 & 0xF);
+        InitializeRfuLinkManager_LinkLeader(sPlayerActivityGroupSize & 0xF);
         data->state = 3;
         break;
     case 3:
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        data->field_0 = AllocZeroed(5 * sizeof(struct UnkStruct_x20));
-        data->field_8 = AllocZeroed(5 * sizeof(struct UnkStruct_x20));
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 5);
-        LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].unk.gname, data->field_0->arr[0].unk.playerName);
+        data->field_0 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20));
+        data->field_8 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20));
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_PARTY_SIZE);
+        LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].gname_uname.gname, data->field_0->arr[0].gname_uname.uname);
         data->field_0->arr[0].field_18 = 0;
-        data->field_0->arr[0].field_1A_0 = 1;
+        data->field_0->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
         data->field_0->arr[0].field_1A_1 = 0;
         data->field_0->arr[0].field_1B = 0;
-        data->field_17 = sub_811A054(data->field_4, 0xFF);
-        data->field_10 = AddWindow(&gUnknown_8456CD0);
-        data->listWindowId = AddWindow(&gUnknown_8456CFC);
-        data->field_11 = AddWindow(&gUnknown_8456D04);
+        data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF);
+        data->bButtonCancelWindowId = AddWindow(&sWindowTemplate_BButtonCancel);
+        data->listWindowId = AddWindow(&sWindowTemplate_List_PossibleGroupMembers);
+        data->nPlayerModeWindowId = AddWindow(&sWindowTemplate_NumPlayerMode);
 
-        FillWindowPixelBuffer(data->field_10, PIXEL_FILL(2));
-        sub_811A444(data->field_10, 0, gUnknown_845747C, 8, 2, 4);
-        PutWindowTilemap(data->field_10);
-        CopyWindowToVram(data->field_10, 2);
+        FillWindowPixelBuffer(data->bButtonCancelWindowId, PIXEL_FILL(2));
+        UR_AddTextPrinterParameterized(data->bButtonCancelWindowId, 0, gUnknown_845747C, 8, 2, UR_COLOR_WHT_DKE_LTE);
+        PutWindowTilemap(data->bButtonCancelWindowId);
+        CopyWindowToVram(data->bButtonCancelWindowId, 2);
 
         DrawStdWindowFrame(data->listWindowId, FALSE);
-        gMultiuseListMenuTemplate = gUnknown_8456D34;
+        gMultiuseListMenuTemplate = sListMenuTemplate_PossibleGroupMembers;
         gMultiuseListMenuTemplate.windowId = data->listWindowId;
         data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
 
-        DrawStdWindowFrame(data->field_11, FALSE);
-        PutWindowTilemap(data->field_11);
-        CopyWindowToVram(data->field_11, 2);
+        DrawStdWindowFrame(data->nPlayerModeWindowId, FALSE);
+        PutWindowTilemap(data->nPlayerModeWindowId);
+        CopyWindowToVram(data->nPlayerModeWindowId, 2);
 
         CopyBgTilemapBufferToVram(0);
-        data->field_13 = 1;
+        data->playerCount = 1;
         data->state = 4;
         break;
     case 4:
-        StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]);
-        if ((gUnknown_203B059 >> 4) != 0)
+        StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]);
+        if ((sPlayerActivityGroupSize >> 4) != 0)
         {
-            if (data->field_13 > (gUnknown_203B059 >> 4) - 1 && (gUnknown_203B059 & 0xF) != 0)
+            if (data->playerCount > (sPlayerActivityGroupSize >> 4) - 1 && (sPlayerActivityGroupSize & 0xF) != 0)
                 StringExpandPlaceholders(gStringVar4, gUnknown_8457264);
             else
                 StringExpandPlaceholders(gStringVar4, gUnknown_8457234);
         }
         else
         {
-            sub_811599C(gStringVar4, gUnknown_203B058);
+            StringExpandPlaceholders_AwaitingCommFromAnother(gStringVar4, sPlayerCurrActivity);
         }
 
-        sub_811586C(data->field_11, gUnknown_203B059, data->field_13);
+        PrintNumPlayersWaitingForMsg(data->nPlayerModeWindowId, sPlayerActivityGroupSize, data->playerCount);
         data->state = 5;
         break;
     case 5:
@@ -711,24 +807,24 @@ static void sub_8115A68(u8 taskId)
             data->state = 6;
         break;
     case 6:
-        sub_8116444(data, 7, 10);
+        Leader_SetStateIfMemberListChanged(data, 7, 10);
         if (JOY_NEW(B_BUTTON))
         {
-            if (data->field_13 == 1)
+            if (data->playerCount == 1)
                 data->state = 23;
-            else if ((gUnknown_203B059 & 0xF0) != 0)
+            else if ((sPlayerActivityGroupSize & 0xF0) != 0)
                 data->state = 30;
             else
                 data->state = 19;
         }
-        if ((gUnknown_203B059 >> 4) != 0
-            && data->field_13 > (gUnknown_203B059 >> 4) - 1
-            && (gUnknown_203B059 & 0xF) != 0
+        if ((sPlayerActivityGroupSize >> 4) != 0
+            && data->playerCount > (sPlayerActivityGroupSize >> 4) - 1
+            && (sPlayerActivityGroupSize & 0xF) != 0
             && sub_80FC1CC()
             && JOY_NEW(START_BUTTON))
         {
             data->state = 15;
-            sub_80F8F5C();
+            LinkRfu_StopManagerAndFinalizeSlots();
         }
         if (data->state == 6 && sub_80FA5D4())
         {
@@ -739,20 +835,21 @@ static void sub_8115A68(u8 taskId)
         if (!sub_80FA5D4())
         {
             data->state = 6;
-            data->field_13 = sub_81165E8(data->field_0);
+            data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0);
         }
         break;
     case 10:
-        id = ((gUnknown_203B058 & 0xF) == 2) ? 1 : 0;
+        id = ((sPlayerCurrActivity & 0xF) == 2) ? 1 : 0;
         if (PrintOnTextbox(&data->textState, gUnknown_845767C[id]))
         {
-            data->field_13 = sub_81165E8(data->field_0);
+            data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0);
             RedrawListMenu(data->listTaskId);
             data->state = 4;
         }
         break;
     case 29:
-        id = ((gUnknown_203B059 & 0xF) == 2) ? 0 : 1;
+        // Other player cancelled.
+        id = ((sPlayerActivityGroupSize & 0xF) == 2) ? 0 : 1;
         if (PrintOnTextbox(&data->textState, gUnknown_845767C[id]))
         {
             data->state = 21;
@@ -765,19 +862,19 @@ static void sub_8115A68(u8 taskId)
         }
         break;
     case 11:
-        switch (sub_811A14C(&data->textState, sub_80FA634(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName)))
+        switch (UnionRoomHandleYesNo(&data->textState, TrainerIdAndNameStillInPartnersList(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname)))
         {
         case 0:
             LoadWirelessStatusIndicatorSpriteGfx();
             CreateWirelessStatusIndicatorSprite(0, 0);
             data->field_19 = 5;
-            sub_80FA670(5, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+            SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
             data->state = 12;
             break;
         case 1:
         case -1:
             data->field_19 = 6;
-            sub_80FA670(6, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+            SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
             data->state = 12;
             break;
         case -3:
@@ -786,29 +883,31 @@ static void sub_8115A68(u8 taskId)
         }
         break;
     case 12:
-        val = sub_80FA6FC(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+        val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
         if (val == 1)
         {
+            // Xfer complete
             if (data->field_19 == 5)
             {
-                data->field_0->arr[data->field_13].field_1B = 0;
+                // Sent "OK"
+                data->field_0->arr[data->playerCount].field_1B = 0;
                 RedrawListMenu(data->listTaskId);
-                data->field_13++;
-                if (data->field_13 == (gUnknown_203B059 & 0xF))
+                data->playerCount++;
+                if (data->playerCount == (sPlayerActivityGroupSize & 0xF))
                 {
-                    if ((gUnknown_203B059 & 0xF0) != 0 || data->field_13 == 4)
+                    if ((sPlayerActivityGroupSize & 0xF0) != 0 || data->playerCount == 4)
                     {
                         data->state = 15;
                     }
                     else
                     {
-                        IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_13 - 1]);
+                        IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->playerCount - 1]);
                         StringExpandPlaceholders(gStringVar4, gUnknown_8457554);
                         data->state = 13;
                     }
 
-                    sub_80F8F5C();
-                    sub_811586C(data->field_11, gUnknown_203B059, data->field_13);
+                    LinkRfu_StopManagerAndFinalizeSlots();
+                    PrintNumPlayersWaitingForMsg(data->nPlayerModeWindowId, sPlayerActivityGroupSize, data->playerCount);
                 }
                 else
                 {
@@ -817,9 +916,10 @@ static void sub_8115A68(u8 taskId)
             }
             else
             {
-                sub_80FBD4C(data->field_0->arr[data->field_13].unk.playerName, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId));
-                data->field_0->arr[data->field_13].field_1A_0 = 0;
-                sub_81165E8(data->field_0);
+                // Sent "no"
+                RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId));
+                data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE;
+                UnionRoomLeaderField0CompactionAndCount(data->field_0);
                 RedrawListMenu(data->listTaskId);
                 data->state = 4;
             }
@@ -828,7 +928,8 @@ static void sub_8115A68(u8 taskId)
         }
         else if (val == 2)
         {
-            sub_80FB9E4(0, 0);
+            // Disconnect
+            RfuSetErrorStatus(0, 0);
             data->state = 4;
         }
         break;
@@ -837,22 +938,25 @@ static void sub_8115A68(u8 taskId)
             data->state = 14;
         break;
     case 14:
-        if (++data->field_E > 120)
+        if (++data->delayTimerAfterOk > 120)
             data->state = 17;
         break;
     case 15:
+        // Are these members OK?
         if (PrintOnTextbox(&data->textState, gUnknown_8457514))
             data->state = 16;
         break;
     case 16:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
+            // Yes
             data->state = 17;
             break;
         case 1:
         case -1:
-            if ((gUnknown_203B059 & 0xF0) != 0)
+            // No
+            if ((sPlayerActivityGroupSize & 0xF0) != 0)
                 data->state = 30;
             else
                 data->state = 19;
@@ -864,16 +968,16 @@ static void sub_8115A68(u8 taskId)
             data->state = 20;
         break;
     case 20:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
             data->state = 23;
             break;
         case 1:
         case -1:
-            if ((gUnknown_203B059 & 0xF0) != 0)
+            if ((sPlayerActivityGroupSize & 0xF0) != 0)
                 data->state = 15;
-            else if (data->field_13 == (gUnknown_203B059 & 0xF))
+            else if (data->playerCount == (sPlayerActivityGroupSize & 0xF))
                 data->state = 15;
             else
                 data->state = 4;
@@ -881,13 +985,15 @@ static void sub_8115A68(u8 taskId)
         }
         break;
     case 17:
-        if (!sub_8116444(data, 7, 23))
+        // Go to start
+        // Final membership check
+        if (!Leader_SetStateIfMemberListChanged(data, 7, 23))
             data->state = 18;
         break;
     case 18:
-        if (sub_80F8F40())
+        if (LmanAcceptSlotFlagIsNotZero())
         {
-            if (sub_80F8F7C(FALSE))
+            if (WaitRfuState(FALSE))
             {
                 data->state = 26;
             }
@@ -899,14 +1005,16 @@ static void sub_8115A68(u8 taskId)
         }
         break;
     case 30:
+        // Mode with members will be canceled.
         if (PrintOnTextbox(&data->textState, gUnknown_8457610))
             data->state = 23;
         break;
     case 21:
     case 23:
+        // An error occurred. Please start over from the beginning.
         DestroyWirelessStatusIndicatorSprite();
-        sub_80F8DC0();
-        sub_81161E4(data);
+        LinkRfu_Shutdown();
+        Leader_DestroyResources(data);
         data->state++;
         break;
     case 24:
@@ -920,7 +1028,7 @@ static void sub_8115A68(u8 taskId)
         gSpecialVar_Result = 8;
         break;
     case 26:
-        if (sub_80FBA00())
+        if (RfuIsErrorStatus1or2())
         {
             data->state = 29;
         }
@@ -928,9 +1036,9 @@ static void sub_8115A68(u8 taskId)
         {
             if (gReceivedRemoteLinkPlayers != 0)
             {
-                sub_80FAFE0(1);
-                sub_8117990();
-                sub_81161E4(data);
+                UpdateGameData_GroupLockedIn(TRUE);
+                CreateTask_RunScriptAndFadeToActivity();
+                Leader_DestroyResources(data);
                 DestroyTask(taskId);
             }
         }
@@ -938,196 +1046,196 @@ static void sub_8115A68(u8 taskId)
     }
 }
 
-static void sub_81161E4(struct UnkStruct_Leader * data)
+static void Leader_DestroyResources(struct UnkStruct_Leader * data)
 {
-    ClearWindowTilemap(data->field_11);
-    ClearStdWindowAndFrame(data->field_11, FALSE);
+    ClearWindowTilemap(data->nPlayerModeWindowId);
+    ClearStdWindowAndFrame(data->nPlayerModeWindowId, FALSE);
     DestroyListMenuTask(data->listTaskId, 0, 0);
-    ClearWindowTilemap(data->field_10);
+    ClearWindowTilemap(data->bButtonCancelWindowId);
     ClearStdWindowAndFrame(data->listWindowId, FALSE);
     CopyBgTilemapBufferToVram(0);
-    RemoveWindow(data->field_11);
+    RemoveWindow(data->nPlayerModeWindowId);
     RemoveWindow(data->listWindowId);
-    RemoveWindow(data->field_10);
-    DestroyTask(data->field_17);
+    RemoveWindow(data->bButtonCancelWindowId);
+    DestroyTask(data->listenTaskId);
 
     Free(data->field_8);
     Free(data->field_0);
     Free(data->field_4);
 }
 
-static void sub_8116244(u8 *dst, u8 caseId)
+static void Leader_GetAcceptNewMemberPrompt(u8 *dst, u8 activity)
 {
-    switch (caseId)
+    switch (activity)
     {
-    case 1:
-    case 2:
-    case 4:
+    case ACTIVITY_BATTLE:
+    case ACTIVITY_DBLBATTLE:
+    case ACTIVITY_TRADE:
         StringExpandPlaceholders(dst, gUnknown_84574A0);
         break;
-    case 21:
-    case 22:
+    case ACTIVITY_WCARD2:
+    case ACTIVITY_WNEWS2:
         StringExpandPlaceholders(dst, gUnknown_84574C4);
         break;
-    case 3:
-    case 9:
-    case 10:
-    case 11:
+    case ACTIVITY_MLTBATTLE:
+    case ACTIVITY_PJUMP:
+    case ACTIVITY_BCRUSH:
+    case ACTIVITY_BPICK:
         StringExpandPlaceholders(dst, gUnknown_84574EC);
         break;
     }
 }
 
-static void sub_81162E0(u8 *dst, u8 caseId)
+static void GetYouDeclinedTheOfferMessage(u8 *dst, u8 activity)
 {
-    switch (caseId)
+    switch (activity)
     {
-    case 65:
-    case 68:
+    case ACTIVITY_BATTLE | IN_UNION_ROOM:
+    case ACTIVITY_TRADE | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8457E28);
         break;
-    case 69:
-    case 72:
+    case ACTIVITY_CHAT | IN_UNION_ROOM:
+    case ACTIVITY_CARD | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8457E44);
         break;
     }
 }
 
-static void sub_811631C(u8 *dst, u8 caseId)
+static void GetYouAskedToJoinGroupPleaseWaitMessage(u8 *dst, u8 activity)
 {
-    switch (caseId)
+    switch (activity)
     {
-    case 1:
-    case 2:
-    case 4:
-    case 21:
-    case 22:
+    case ACTIVITY_BATTLE:
+    case ACTIVITY_DBLBATTLE:
+    case ACTIVITY_TRADE:
+    case ACTIVITY_WCARD2:
+    case ACTIVITY_WNEWS2:
         StringExpandPlaceholders(dst, gUnknown_8459238);
         break;
-    case 3:
-    case 9:
-    case 10:
-    case 11:
+    case ACTIVITY_MLTBATTLE:
+    case ACTIVITY_PJUMP:
+    case ACTIVITY_BCRUSH:
+    case ACTIVITY_BPICK:
         StringExpandPlaceholders(dst, gUnknown_8459250);
         break;
     }
 }
 
-static void sub_81163B0(u8 *dst, u8 caseId)
+static void GetGroupLeaderSentAnOKMessage(u8 *dst, u8 caseId)
 {
     switch (caseId)
     {
-    case 1:
-    case 2:
-    case 4:
-    case 21:
-    case 22:
+    case ACTIVITY_BATTLE:
+    case ACTIVITY_DBLBATTLE:
+    case ACTIVITY_TRADE:
+    case ACTIVITY_WCARD2:
+    case ACTIVITY_WNEWS2:
         StringExpandPlaceholders(dst, gUnknown_84576AC);
         break;
-    case 3:
-    case 9:
-    case 10:
-    case 11:
+    case ACTIVITY_MLTBATTLE:
+    case ACTIVITY_PJUMP:
+    case ACTIVITY_BCRUSH:
+    case ACTIVITY_BPICK:
         StringExpandPlaceholders(dst, gUnknown_84576C4);
         break;
     }
 }
 
-static bool8 sub_8116444(struct UnkStruct_Leader * data, u32 arg1, u32 arg2)
+static bool8 Leader_SetStateIfMemberListChanged(struct UnkStruct_Leader * data, u32 state1, u32 state2)
 {
-    switch (sub_8116524(data->field_0))
+    switch (LeaderUpdateGroupMembership(data->field_0))
     {
-    case 1:
+    case UNION_ROOM_SPAWN_IN:
         PlaySE(SE_PC_LOGIN);
         RedrawListMenu(data->listTaskId);
-        IntlConvPartnerUname7(gStringVar2, data->field_0->arr[data->field_13]);
-        sub_8116244(gStringVar4, gUnknown_203B058);
-        data->state = arg1;
+        IntlConvPartnerUname7(gStringVar2, data->field_0->arr[data->playerCount]);
+        Leader_GetAcceptNewMemberPrompt(gStringVar4, sPlayerCurrActivity);
+        data->state = state1;
         break;
-    case 2:
-        sub_80FB9E4(0, 0);
+    case UNION_ROOM_SPAWN_OUT:
+        RfuSetErrorStatus(0, 0);
         RedrawListMenu(data->listTaskId);
-        data->state = arg2;
+        data->state = state2;
         return TRUE;
     }
 
     return FALSE;
 }
 
-static void sub_81164C8(u8 windowId, s32 itemId, u8 y)
+static void ItemPrintFunc_PossibleGroupMembers(u8 windowId, s32 itemId, u8 y)
 {
     struct UnkStruct_Leader * data = sUnionRoomMain.leader;
     u8 var = 0;
 
-    switch (data->field_0->arr[itemId].field_1A_0)
+    switch (data->field_0->arr[itemId].groupScheduledAnim)
     {
-    case 1:
+    case UNION_ROOM_SPAWN_IN:
         if (data->field_0->arr[itemId].field_1B != 0)
-            var = 2;
+            var = UR_COLOR_GRN_WHT_LTG;
         break;
-    case 2:
-        var = 1;
+    case UNION_ROOM_SPAWN_OUT:
+        var = UR_COLOR_RED_WHT_LTR;
         break;
     }
 
-    sub_811A910(windowId, 0, y, &data->field_0->arr[itemId], var, itemId);
+    PrintGroupMemberCandidateOnWindowWithColor(windowId, 0, y, &data->field_0->arr[itemId], var, itemId);
 }
 
-static u8 sub_8116524(struct UnkStruct_Main0 * arg0)
+static u8 LeaderUpdateGroupMembership(struct UnkStruct_Main0 * arg0)
 {
     struct UnkStruct_Leader * data = sUnionRoomMain.leader;
-    u8 ret = 0;
+    u8 ret = UNION_ROOM_SPAWN_NONE;
     u8 i;
     s32 id;
 
-    for (i = 1; i < 5; i++)
+    for (i = 1; i < UROOM_MAX_PARTY_SIZE; i++)
     {
-        u16 var = data->field_0->arr[i].field_1A_0;
-        if (var == 1)
+        u16 var = data->field_0->arr[i].groupScheduledAnim;
+        if (var == UNION_ROOM_SPAWN_IN)
         {
-            id = sub_811A748(&data->field_0->arr[i], data->field_4->arr);
+            id = Findx20Inx1CArray(&data->field_0->arr[i], data->field_4->arr);
             if (id != 0xFF)
             {
-                data->field_0->arr[i].unk = data->field_4->arr[id].unk0;
-                data->field_0->arr[i].field_18 = var;
+                data->field_0->arr[i].gname_uname = data->field_4->arr[id].gname_uname;
+                data->field_0->arr[i].field_18 = 1;
             }
             else
             {
-                data->field_0->arr[i].field_1A_0 = 2;
-                ret = 2;
+                data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_OUT;
+                ret = UNION_ROOM_SPAWN_OUT;
             }
         }
     }
 
-    for (id = 0; id < 4; id++)
-        sub_811A798(data->field_0->arr, &data->field_4->arr[id], 5);
+    for (id = 0; id < RFU_CHILD_MAX; id++)
+        Appendx1Ctox20(data->field_0->arr, &data->field_4->arr[id], UROOM_MAX_PARTY_SIZE);
 
-    if (ret != 2)
+    if (ret != UNION_ROOM_SPAWN_OUT)
     {
-        for (id = 0; id < 5; id++)
+        for (id = 0; id < UROOM_MAX_PARTY_SIZE; id++)
         {
             if (data->field_0->arr[id].field_1B != 0)
-                ret = 1;
+                ret = UNION_ROOM_SPAWN_IN;
         }
     }
 
     return ret;
 }
 
-static u8 sub_81165E8(struct UnkStruct_Main0 * arg0)
+static u8 UnionRoomLeaderField0CompactionAndCount(struct UnkStruct_Main0 * arg0)
 {
     struct UnkStruct_Leader * data = sUnionRoomMain.leader;
     u8 copiedCount;
     s32 i;
     u8 ret;
 
-    for (i = 0; i < 5; i++)
+    for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++)
         data->field_8->arr[i] = data->field_0->arr[i];
 
     copiedCount = 0;
-    for (i = 0; i < 5; i++)
+    for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++)
     {
-        if (data->field_8->arr[i].field_1A_0 == 1)
+        if (data->field_8->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
         {
             data->field_0->arr[copiedCount] = data->field_8->arr[i];
             copiedCount++;
@@ -1135,18 +1243,18 @@ static u8 sub_81165E8(struct UnkStruct_Main0 * arg0)
     }
 
     ret = copiedCount;
-    for (; copiedCount < 5; copiedCount++)
+    for (; copiedCount < UROOM_MAX_PARTY_SIZE; copiedCount++)
     {
-        data->field_0->arr[copiedCount].unk = gUnknown_8457034;
+        data->field_0->arr[copiedCount].gname_uname = sUnionGnameUnamePair_Dummy;
         data->field_0->arr[copiedCount].field_18 = 0;
-        data->field_0->arr[copiedCount].field_1A_0 = 0;
-        data->field_0->arr[copiedCount].field_1A_1 = 0;
+        data->field_0->arr[copiedCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE;
+        data->field_0->arr[copiedCount].field_1A_1 = FALSE;
         data->field_0->arr[copiedCount].field_1B = 0;
     }
 
-    for (i = 0; i < 5; i++)
+    for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++)
     {
-        if (data->field_0->arr[i].field_1A_0 != 1)
+        if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_IN)
             continue;
         if (data->field_0->arr[i].field_1B != 0x40)
             continue;
@@ -1163,7 +1271,7 @@ void TryJoinLinkGroup(void)
     u8 taskId;
     struct UnkStruct_Group * dataPtr;
 
-    taskId = CreateTask(sub_8116738, 0);
+    taskId = CreateTask(Task_TryJoinLinkGroup, 0);
     sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data);
     sGroup = dataPtr;
 
@@ -1172,7 +1280,7 @@ void TryJoinLinkGroup(void)
     gSpecialVar_Result = 0;
 }
 
-static void sub_8116738(u8 taskId)
+static void Task_TryJoinLinkGroup(u8 taskId)
 {
     s32 id;
     struct UnkStruct_Group * data = sUnionRoomMain.group;
@@ -1180,11 +1288,11 @@ static void sub_8116738(u8 taskId)
     switch (data->state)
     {
     case 0:
-        SetHostRFUtgtGname(gUnknown_84570C8[gSpecialVar_0x8004], 0, 0);
-        gUnknown_203B058 = gUnknown_84570C8[gSpecialVar_0x8004];
-        sub_800B1F4();
+        SetHostRFUtgtGname(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, 0);
+        sPlayerCurrActivity = sLinkGroupToURoomActivity[gSpecialVar_0x8004];
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBBD8();
+        InitializeRfuLinkManager_JoinGroup();
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
         data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20));
         data->state = 1;
@@ -1194,34 +1302,34 @@ static void sub_8116738(u8 taskId)
             data->state = 2;
         break;
     case 2:
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 16);
-        data->field_11 = sub_811A054(data->field_4, gSpecialVar_0x8004);
-        data->field_C = AddWindow(&gUnknown_8456CD0);
-        data->listWindowId = AddWindow(&gUnknown_8456D4C);
-        data->field_D = AddWindow(&gUnknown_8456D54);
-
-        FillWindowPixelBuffer(data->field_C, PIXEL_FILL(2));
-        sub_811A444(data->field_C, 0, gUnknown_8458FC8, 8, 2, 4);
-        PutWindowTilemap(data->field_C);
-        CopyWindowToVram(data->field_C, 2);
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, 16);
+        data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, gSpecialVar_0x8004);
+        data->bButtonCancelWindowId = AddWindow(&sWindowTemplate_BButtonCancel);
+        data->listWindowId = AddWindow(&sWindowTemplate_MysteryGiftList);
+        data->playerNameAndIdWindowId = AddWindow(&sWindowTemplate_MysteryGiftPlayerNameAndId);
+
+        FillWindowPixelBuffer(data->bButtonCancelWindowId, PIXEL_FILL(2));
+        UR_AddTextPrinterParameterized(data->bButtonCancelWindowId, 0, gUnknown_8458FC8, 8, 2, UR_COLOR_WHT_DKE_LTE);
+        PutWindowTilemap(data->bButtonCancelWindowId);
+        CopyWindowToVram(data->bButtonCancelWindowId, 2);
 
         DrawStdWindowFrame(data->listWindowId, FALSE);
-        gMultiuseListMenuTemplate = gUnknown_8456DDC;
+        gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups;
         gMultiuseListMenuTemplate.windowId = data->listWindowId;
         data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
 
-        DrawStdWindowFrame(data->field_D, FALSE);
-        PutWindowTilemap(data->field_D);
-        sub_8115924(data->field_D);
-        CopyWindowToVram(data->field_D, 2);
+        DrawStdWindowFrame(data->playerNameAndIdWindowId, FALSE);
+        PutWindowTilemap(data->playerNameAndIdWindowId);
+        PrintPlayerNameAndIdOnWindow(data->playerNameAndIdWindowId);
+        CopyWindowToVram(data->playerNameAndIdWindowId, 2);
 
         CopyBgTilemapBufferToVram(0);
-        data->field_F = 0;
+        data->leaderId = 0;
         data->state = 3;
         break;
     case 3:
-        id = sub_8116FE4();
+        id = GetNewLeaderCandidate();
         switch (id)
         {
         case 1:
@@ -1234,19 +1342,20 @@ static void sub_8116738(u8 taskId)
             {
                 // this unused variable along with the assignment is needed to match
                 u32 unusedVar;
-                unusedVar  = data->field_0->arr[id].unk.gname.unk_0a_0;
+                unusedVar  = data->field_0->arr[id].gname_uname.gname.activity;
 
-                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.gname.unk_0a_7)
+                if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started)
                 {
-                    u32 var = sub_8116D10(data, id);
+                    u32 var = IsTryingToTradeWithHoennTooSoon(data, id);
                     if (var == 0)
                     {
-                        sub_8116D60(data, id);
+                        AskToJoinRfuGroup(data, id);
                         data->state = 5;
                         PlaySE(SE_PN_ON);
                     }
                     else
                     {
+                        // Postgame flags not both set
                         StringCopy(gStringVar4, gUnknown_8457608[var - 1]);
                         data->state = 18;
                         PlaySE(SE_PN_ON);
@@ -1268,30 +1377,38 @@ static void sub_8116738(u8 taskId)
         }
         break;
     case 5:
-        sub_811631C(gStringVar4, gUnknown_203B058);
+        GetYouAskedToJoinGroupPleaseWaitMessage(gStringVar4, sPlayerCurrActivity);
         if (PrintOnTextbox(&data->textState, gStringVar4))
         {
-            IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_F]);
+            IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->leaderId]);
             data->state = 6;
         }
         break;
     case 6:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0;
-            sub_80FB9E4(0, 0);
-            switch (gUnknown_203B058)
+            sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity;
+            RfuSetErrorStatus(0, 0);
+            switch (sPlayerCurrActivity)
             {
-            case 1 ... 5:
-            case 9 ... 11:
-            case 13 ... 14:
-            case 21 ... 22:
+            case ACTIVITY_BATTLE:
+            case ACTIVITY_DBLBATTLE:
+            case ACTIVITY_MLTBATTLE:
+            case ACTIVITY_TRADE:
+            case ACTIVITY_CHAT:
+            case ACTIVITY_PJUMP:
+            case ACTIVITY_BCRUSH:
+            case ACTIVITY_BPICK:
+            case ACTIVITY_SPINTRADE:
+            case ACTIVITY_ITEMTRADE:
+            case ACTIVITY_WCARD2:
+            case ACTIVITY_WNEWS2:
                 data->state = 20;
                 break;
             }
         }
 
-        switch (sub_80FB9F4())
+        switch (RfuGetErrorStatus())
         {
         case 1:
             data->state = 12;
@@ -1302,31 +1419,32 @@ static void sub_8116738(u8 taskId)
             data->state = 14;
             break;
         case 5:
-            sub_81163B0(gStringVar4, gUnknown_203B058);
+            GetGroupLeaderSentAnOKMessage(gStringVar4, sPlayerCurrActivity);
             if (PrintOnTextbox(&data->textState, gStringVar4))
             {
-                sub_80FB9E4(7, 0);
-                StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]);
+                RfuSetErrorStatus(7, 0);
+                StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]);
                 StringExpandPlaceholders(gStringVar4, gUnknown_8457700);
             }
             break;
         case 7:
-            if (data->field_15 > 0xF0)
+            // Wait 4 seconds
+            if (data->delayBeforePrint > 240)
             {
                 if (PrintOnTextbox(&data->textState, gStringVar4))
                 {
-                    sub_80FB9E4(12, 0);
-                    data->field_15 = 0;
+                    RfuSetErrorStatus(12, 0);
+                    data->delayBeforePrint = 0;
                 }
             }
             else
             {
-                data->field_15++;
+                data->delayBeforePrint++;
             }
             break;
         }
 
-        if (!sub_80FB9F4() && JOY_NEW(B_BUTTON))
+        if (!RfuGetErrorStatus() && JOY_NEW(B_BUTTON))
             data->state = 7;
         break;
     case 7:
@@ -1334,10 +1452,10 @@ static void sub_8116738(u8 taskId)
             data->state = 8;
         break;
     case 8:
-        switch (sub_811A14C(&data->textState, sub_80FB9F4()))
+        switch (UnionRoomHandleYesNo(&data->textState, RfuGetErrorStatus()))
         {
         case 0:
-            sub_80FA6BC();
+            LinkRfuNIsend8();
             data->state = 9;
             RedrawListMenu(data->listTaskId);
             break;
@@ -1353,7 +1471,7 @@ static void sub_8116738(u8 taskId)
         }
         break;
     case 9:
-        if (sub_80FB9F4())
+        if (RfuGetErrorStatus())
             data->state = 6;
         break;
     case 10:
@@ -1361,23 +1479,23 @@ static void sub_8116738(u8 taskId)
     case 14:
     case 18:
     case 20:
-        ClearWindowTilemap(data->field_D);
-        ClearStdWindowAndFrame(data->field_D, FALSE);
+        ClearWindowTilemap(data->playerNameAndIdWindowId);
+        ClearStdWindowAndFrame(data->playerNameAndIdWindowId, FALSE);
         DestroyListMenuTask(data->listTaskId, 0, 0);
-        ClearWindowTilemap(data->field_C);
+        ClearWindowTilemap(data->bButtonCancelWindowId);
         ClearStdWindowAndFrame(data->listWindowId, FALSE);
         CopyBgTilemapBufferToVram(0);
-        RemoveWindow(data->field_D);
+        RemoveWindow(data->playerNameAndIdWindowId);
         RemoveWindow(data->listWindowId);
-        RemoveWindow(data->field_C);
-        DestroyTask(data->field_11);
+        RemoveWindow(data->bButtonCancelWindowId);
+        DestroyTask(data->listenTaskId);
         Free(data->field_0);
         Free(data->field_4);
         data->state++;
         break;
     case 13:
         DestroyWirelessStatusIndicatorSprite();
-        if (PrintOnTextbox(&data->textState, gUnknown_8457754[sub_80FB9F4()]))
+        if (PrintOnTextbox(&data->textState, gUnknown_8457754[RfuGetErrorStatus()]))
         {
             gSpecialVar_Result = 6;
             data->state = 23;
@@ -1390,7 +1508,7 @@ static void sub_8116738(u8 taskId)
         break;
     case 15:
         DestroyWirelessStatusIndicatorSprite();
-        if (PrintOnTextbox(&data->textState, gUnknown_8457754[sub_80FB9F4()]))
+        if (PrintOnTextbox(&data->textState, gUnknown_8457754[RfuGetErrorStatus()]))
         {
             gSpecialVar_Result = 8;
             data->state = 23;
@@ -1405,25 +1523,25 @@ static void sub_8116738(u8 taskId)
         break;
     case 23:
         DestroyTask(taskId);
-        sub_811A41C();
-        sub_80F8DC0();
+        JoinGroup_BlankBg0AndEnableScriptContexts();
+        LinkRfu_Shutdown();
         break;
     case 21:
-        sub_8117990();
+        CreateTask_RunScriptAndFadeToActivity();
         DestroyTask(taskId);
         break;
     }
 }
 
-static u32 sub_8116D10(struct UnkStruct_Group * arg0, s32 id)
+static u32 IsTryingToTradeWithHoennTooSoon(struct UnkStruct_Group * arg0, s32 id)
 {
     struct UnkStruct_x20 * structPtr = &arg0->field_0->arr[id];
 
-    if (gUnknown_203B058 == 4 && structPtr->unk.gname.unk_00.unk_01_2 != VERSION_FIRE_RED && structPtr->unk.gname.unk_00.unk_01_2 != VERSION_LEAF_GREEN)
+    if (sPlayerCurrActivity == ACTIVITY_TRADE && structPtr->gname_uname.gname.unk_00.version != VERSION_FIRE_RED && structPtr->gname_uname.gname.unk_00.version != VERSION_LEAF_GREEN)
     {
         if (!(gSaveBlock2Ptr->specialSaveWarpFlags & CHAMPION_SAVEWARP))
             return 1;
-        else if (structPtr->unk.gname.unk_00.isChampion)
+        else if (structPtr->gname_uname.gname.unk_00.isChampion)
             return 0;
     }
     else
@@ -1434,23 +1552,23 @@ static u32 sub_8116D10(struct UnkStruct_Group * arg0, s32 id)
     return 2;
 }
 
-static void sub_8116D60(struct UnkStruct_Group * data, s32 id)
+static void AskToJoinRfuGroup(struct UnkStruct_Group * data, s32 id)
 {
-    data->field_F = id;
+    data->leaderId = id;
     LoadWirelessStatusIndicatorSpriteGfx();
     CreateWirelessStatusIndicatorSprite(0, 0);
     RedrawListMenu(data->listTaskId);
-    IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_F]);
-    sub_80FB008(gUnknown_84570C8[gSpecialVar_0x8004], 0, 1);
-    sub_80FBF54(data->field_0->arr[data->field_F].unk.playerName, ReadAsU16(data->field_0->arr[data->field_F].unk.gname.unk_00.playerTrainerId));
+    IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->leaderId]);
+    UpdateGameDataWithActivitySpriteGendersFlag(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, TRUE);
+    CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId));
 }
 
-u8 sub_8116DE0(void)
+u8 CreateTask_ListenToWireless(void)
 {
     u8 taskId;
     struct UnkStruct_Group * dataPtr;
 
-    taskId = CreateTask(sub_8116E1C, 0);
+    taskId = CreateTask(Task_ListenToWireless, 0);
     sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data);
 
     dataPtr->state = 0;
@@ -1461,7 +1579,7 @@ u8 sub_8116DE0(void)
     return taskId;
 }
 
-static void sub_8116E1C(u8 taskId)
+static void Task_ListenToWireless(u8 taskId)
 {
     struct UnkStruct_Group * data = sUnionRoomMain.group;
 
@@ -1469,53 +1587,53 @@ static void sub_8116E1C(u8 taskId)
     {
     case 0:
         SetHostRFUtgtGname(0, 0, 0);
-        sub_800B1F4();
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBBD8();
+        InitializeRfuLinkManager_JoinGroup();
         sub_80FB128(TRUE);
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
         data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20));
         data->state = 2;
         break;
     case 2:
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 16);
-        data->field_11 = sub_811A054(data->field_4, 0xFF);
-        data->field_F = 0;
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, 16);
+        data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF);
+        data->leaderId = 0;
         data->state = 3;
         break;
     case 3:
-        if (sub_8116FE4() == 1)
+        if (GetNewLeaderCandidate() == 1)
             PlaySE(SE_PC_LOGIN);
         if (gTasks[taskId].data[15] == 0xFF)
             data->state = 10;
         break;
     case 10:
-        DestroyTask(data->field_11);
+        DestroyTask(data->listenTaskId);
         Free(data->field_0);
         Free(data->field_4);
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
         data->state++;
         break;
     case 11:
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
         DestroyTask(taskId);
         break;
     }
 }
 
-static bool32 sub_8116F28(u32 arg0, u32 id)
+static bool32 IsPartnerActivityAcceptable(u32 activity, u32 group)
 {
-    if (id == 0xFF)
+    if (group == 0xFF)
         return TRUE;
 
-    if (id <= NELEMS(gUnknown_8457094)) // UB: <= may access data outside the array
+    if (group <= NELEMS(sAcceptedActivityIds)) // UB: <= may access data outside the array
     {
-        const u8 *bytes = gUnknown_8457094[id];
+        const u8 *bytes = sAcceptedActivityIds[group];
 
         while ((*(bytes) != 0xFF))
         {
-            if ((*bytes) == arg0)
+            if ((*bytes) == activity)
                 return TRUE;
             bytes++;
         }
@@ -1524,30 +1642,30 @@ static bool32 sub_8116F28(u32 arg0, u32 id)
     return FALSE;
 }
 
-static u8 sub_8116F5C(struct UnkStruct_Group * data, u32 id)
+static u8 URoomGroupListGetTextColor(struct UnkStruct_Group * data, u32 id)
 {
-    if (data->field_0->arr[id].field_1A_0 == 1)
+    if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
     {
-        if (data->field_0->arr[id].unk.gname.unk_0a_7)
-            return 3;
-        else if (data->field_0->arr[id].field_1A_1 != 0)
-            return 1;
+        if (data->field_0->arr[id].gname_uname.gname.started)
+            return UR_COLOR_WHT_WHT_LTE;
+        else if (data->field_0->arr[id].field_1A_1)
+            return UR_COLOR_RED_WHT_LTR;
         else if (data->field_0->arr[id].field_1B != 0)
-            return 2;
+            return UR_COLOR_GRN_WHT_LTG;
     }
 
-    return 0;
+    return UR_COLOR_DKE_WHT_LTE;
 }
 
-static void sub_8116F94(u8 windowId, s32 itemId, u8 y)
+static void ListMenuItemPrintFunc_UnionRoomGroups(u8 windowId, s32 itemId, u8 y)
 {
     struct UnkStruct_Group * data = sUnionRoomMain.group;
-    u8 var = sub_8116F5C(data, itemId);
+    u8 color_idx = URoomGroupListGetTextColor(data, itemId);
 
-    sub_811A81C(windowId, 8, y, &data->field_0->arr[itemId], var, itemId);
+    PrintUnionRoomGroupOnWindow(windowId, 8, y, &data->field_0->arr[itemId], color_idx, itemId);
 }
 
-static u8 sub_8116FE4(void)
+static u8 GetNewLeaderCandidate(void)
 {
     struct UnkStruct_Group * data = sUnionRoomMain.group;
     u8 ret = 0;
@@ -1556,17 +1674,17 @@ static u8 sub_8116FE4(void)
 
     for (i = 0; i < 16; i++)
     {
-        if (data->field_0->arr[i].field_1A_0 != 0)
+        if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_NONE)
         {
-            id = sub_811A748(&data->field_0->arr[i], data->field_4->arr);
+            id = Findx20Inx1CArray(&data->field_0->arr[i], data->field_4->arr);
             if (id != 0xFF)
             {
-                if (data->field_0->arr[i].field_1A_0 == 1)
+                if (data->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
                 {
-                    if (sub_811A6DC(&data->field_0->arr[i].unk, &data->field_4->arr[id].unk0))
+                    if (AreUnionRoomPlayerGnamesDifferent(&data->field_0->arr[i].gname_uname, &data->field_4->arr[id].gname_uname))
                     {
-                        data->field_0->arr[i].unk = data->field_4->arr[id].unk0;
-                        data->field_0->arr[i].field_1B = 0x40;
+                        data->field_0->arr[i].gname_uname = data->field_4->arr[id].gname_uname;
+                        data->field_0->arr[i].field_1B = 64;
                         ret = 1;
                     }
                     else
@@ -1581,8 +1699,8 @@ static u8 sub_8116FE4(void)
                 }
                 else
                 {
-                    data->field_0->arr[i].field_1A_0 = 1;
-                    data->field_0->arr[i].field_1B = 0x40;
+                    data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
+                    data->field_0->arr[i].field_1B = 64;
                     ret = 1;
                 }
 
@@ -1590,12 +1708,12 @@ static u8 sub_8116FE4(void)
             }
             else
             {
-                if (data->field_0->arr[i].field_1A_0 != 2)
+                if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_OUT)
                 {
                     data->field_0->arr[i].field_18++;
                     if (data->field_0->arr[i].field_18 >= 300)
                     {
-                        data->field_0->arr[i].field_1A_0 = 2;
+                        data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_OUT;
                         ret = 2;
                     }
                 }
@@ -1603,29 +1721,29 @@ static u8 sub_8116FE4(void)
         }
     }
 
-    for (id = 0; id < 4; id++)
+    for (id = 0; id < RFU_CHILD_MAX; id++)
     {
-        if (sub_811A798(data->field_0->arr, &data->field_4->arr[id], 16) != 0xFF)
+        if (Appendx1Ctox20(data->field_0->arr, &data->field_4->arr[id], 16) != 0xFF)
             ret = 1;
     }
 
     return ret;
 }
 
-static void sub_8117100(u8 taskId)
+static void Task_CallCB2ReturnFromLinkTrade(u8 taskId)
 {
     CB2_ReturnFromLinkTrade();
     DestroyTask(taskId);
 }
 
-u8 sub_8117118(void)
+u8 UnionRoom_CreateTask_CallCB2ReturnFromLinkTrade(void)
 {
-    u8 taskId = CreateTask(sub_8117100, 0);
+    u8 taskId = CreateTask(Task_CallCB2ReturnFromLinkTrade, 0);
 
     return taskId;
 }
 
-static void sub_8117130(u8 taskId)
+static void Task_StartUnionRoomTrade(u8 taskId)
 {
     u32 monId = GetPartyPositionOfRegisteredMon(&sUnionRoomTrade, GetMultiplayerId());
 
@@ -1665,7 +1783,7 @@ static void sub_8117130(u8 taskId)
     }
 }
 
-static void sub_8117280(u8 taskId)
+static void Task_ExchangeCards(u8 taskId)
 {
     switch (gTasks[taskId].data[0])
     {
@@ -1689,11 +1807,11 @@ static void sub_8117280(u8 taskId)
             if (GetLinkPlayerCount() == 2)
             {
                 recvBuff = gBlockRecvBuffer[GetMultiplayerId() ^ 1];
-                sub_81446D0(recvBuff[48]);
+                MEventHandleReceivedWonderCard(recvBuff[sizeof(struct TrainerCard) / 2]);
             }
             else
             {
-                sub_81446C4();
+                ResetReceivedWonderCardFlag();
             }
 
             ResetBlockReceivedFlags();
@@ -1703,16 +1821,16 @@ static void sub_8117280(u8 taskId)
     }
 }
 
-static void sub_8117354(void)
+static void CB2_ShowCard(void)
 {
     switch (gMain.state)
     {
     case 0:
-        CreateTask(sub_8117280, 5);
+        CreateTask(Task_ExchangeCards, 5);
         gMain.state++;
         break;
     case 1:
-        if (!FuncIsActiveTask(sub_8117280))
+        if (!FuncIsActiveTask(Task_ExchangeCards))
             ShowTrainerCardInLink(GetMultiplayerId() ^ 1, CB2_ReturnToField);
         break;
     }
@@ -1723,7 +1841,7 @@ static void sub_8117354(void)
     BuildOamBuffer();
 }
 
-void sub_81173C0(u16 battleFlags)
+void StartUnionRoomBattle(u16 battleFlags)
 {
     HealPlayerParty();
     SavePlayerParty();
@@ -1731,12 +1849,12 @@ void sub_81173C0(u16 battleFlags)
     gLinkPlayers[0].linkType = LINKTYPE_BATTLE;
     gLinkPlayers[GetMultiplayerId()].id = GetMultiplayerId();
     gLinkPlayers[GetMultiplayerId() ^ 1].id = GetMultiplayerId() ^ 1;
-    gMain.savedCallback = sub_8081668;
+    gMain.savedCallback = CB2_ReturnFromCableClubBattle;
     gBattleTypeFlags = battleFlags;
     PlayBattleBGM();
 }
 
-static void sub_8117440(u16 linkService, u16 x, u16 y)
+static void SetCableClubStateAndWarpCurrentMap(u16 linkService, u16 x, u16 y)
 {
     VarSet(VAR_CABLE_CLUB_STATE, linkService);
     SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, x, y);
@@ -1744,7 +1862,7 @@ static void sub_8117440(u16 linkService, u16 x, u16 y)
     WarpIntoMap();
 }
 
-static void sub_81174B4(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService)
+static void SetCableClubStateAndWarpToNewMap(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService)
 {
     gSpecialVar_0x8004 = linkService;
     VarSet(VAR_CABLE_CLUB_STATE, linkService);
@@ -1755,17 +1873,17 @@ static void sub_81174B4(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService)
     WarpIntoMap();
 }
 
-static void sub_8117534(void)
+static void CB2_TransitionToCableClub(void)
 {
     switch (gMain.state)
     {
     case 0:
-        CreateTask(sub_8117280, 5);
+        CreateTask(Task_ExchangeCards, 5);
         gMain.state++;
         break;
     case 1:
-        if (!FuncIsActiveTask(sub_8117280))
-            SetMainCallback2(sub_8056788);
+        if (!FuncIsActiveTask(Task_ExchangeCards))
+            SetMainCallback2(CB2_ReturnToFieldCableClub);
         break;
     }
 
@@ -1775,101 +1893,106 @@ static void sub_8117534(void)
     BuildOamBuffer();
 }
 
-static void sub_8117594(void *arg0, bool32 arg1)
+static void CreateTrainerCardInBuffer(void *dest, bool32 setWonderCard)
 {
-    TrainerCard_GenerateCardForLinkPlayer((struct TrainerCard * )arg0);
-    if (arg1)
-        *((u16 *)(arg0 + sizeof(struct TrainerCard))) = GetWonderCardFlagId();
+    TrainerCard_GenerateCardForLinkPlayer((struct TrainerCard * )dest);
+    if (setWonderCard)
+        *((u16 *)(dest + sizeof(struct TrainerCard))) = GetWonderCardFlagId();
     else
-        *((u16 *)(arg0 + sizeof(struct TrainerCard))) = 0;
+        *((u16 *)(dest + sizeof(struct TrainerCard))) = 0;
 }
 
-static void sub_81175BC(u8 taskId)
+static void Task_StartActivity(u8 taskId)
 {
-    sub_81446C4();
-    switch (gUnknown_203B058)
+    ResetReceivedWonderCardFlag();
+    switch (sPlayerCurrActivity)
     {
-    case 1 ... 4:
-    case 9 ... 11:
-    case 13:
-    case 14:
+    case ACTIVITY_BATTLE:
+    case ACTIVITY_DBLBATTLE:
+    case ACTIVITY_MLTBATTLE:
+    case ACTIVITY_TRADE:
+    case ACTIVITY_PJUMP:
+    case ACTIVITY_BCRUSH:
+    case ACTIVITY_BPICK:
+    case ACTIVITY_SPINTRADE:
+    case ACTIVITY_ITEMTRADE:
         RecordMixTrainerNames();
         break;
     }
 
-    switch (gUnknown_203B058)
+    switch (sPlayerCurrActivity)
     {
-    case 65:
-    case 81:
+    case ACTIVITY_BATTLE | IN_UNION_ROOM:
+    case ACTIVITY_ACCEPT | IN_UNION_ROOM:
         CleanupOverworldWindowsAndTilemaps();
-        gMain.savedCallback = sub_811C1C8;
+        gMain.savedCallback = CB2_UnionRoomBattle;
         InitChooseHalfPartyForBattle(2);
         break;
-    case 1:
+    case ACTIVITY_BATTLE:
         CleanupOverworldWindowsAndTilemaps();
-        sub_8117594(gBlockSendBuffer, TRUE);
+        CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
         HealPlayerParty();
         SavePlayerParty();
         LoadPlayerBag();
-        sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_SINGLE_BATTLE);
-        SetMainCallback2(sub_8117534);
+        SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_SINGLE_BATTLE);
+        SetMainCallback2(CB2_TransitionToCableClub);
         break;
-    case 2:
+    case ACTIVITY_DBLBATTLE:
         CleanupOverworldWindowsAndTilemaps();
         HealPlayerParty();
         SavePlayerParty();
         LoadPlayerBag();
-        sub_8117594(gBlockSendBuffer, TRUE);
-        sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_DOUBLE_BATTLE);
-        SetMainCallback2(sub_8117534);
+        CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
+        SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_DOUBLE_BATTLE);
+        SetMainCallback2(CB2_TransitionToCableClub);
         break;
-    case 3:
+    case ACTIVITY_MLTBATTLE:
         CleanupOverworldWindowsAndTilemaps();
         HealPlayerParty();
         SavePlayerParty();
         LoadPlayerBag();
-        sub_8117594(gBlockSendBuffer, TRUE);
-        sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_4P), MAP_NUM(BATTLE_COLOSSEUM_4P), 5, 8, USING_MULTI_BATTLE);
-        SetMainCallback2(sub_8117534);
+        CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
+        SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_4P), MAP_NUM(BATTLE_COLOSSEUM_4P), 5, 8, USING_MULTI_BATTLE);
+        SetMainCallback2(CB2_TransitionToCableClub);
         break;
-    case 4:
-        sub_8117594(gBlockSendBuffer, TRUE);
+    case ACTIVITY_TRADE:
+        CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
         CleanupOverworldWindowsAndTilemaps();
-        sub_81174B4(MAP_GROUP(TRADE_CENTER), MAP_NUM(TRADE_CENTER), 5, 8, USING_TRADE_CENTER);
-        SetMainCallback2(sub_8117534);
+        SetCableClubStateAndWarpToNewMap(MAP_GROUP(TRADE_CENTER), MAP_NUM(TRADE_CENTER), 5, 8, USING_TRADE_CENTER);
+        SetMainCallback2(CB2_TransitionToCableClub);
         break;
-    case 68:
-        CreateTask(sub_8117130, 0);
+    case ACTIVITY_TRADE | IN_UNION_ROOM:
+        CreateTask(Task_StartUnionRoomTrade, 0);
         break;
-    case 5:
-    case 69:
+    case ACTIVITY_CHAT:
+    case ACTIVITY_CHAT | IN_UNION_ROOM:
         if (GetMultiplayerId() == 0)
         {
-            sub_80F8CFC();
+            LinkRfu_CreateConnectionAsParent();
         }
         else
         {
-            sub_80F8D14();
-            SetHostRFUtgtGname(69, 0, 1);
+            LinkRfu_StopManagerBeforeEnteringChat();
+            SetHostRFUtgtGname(ACTIVITY_CHAT | IN_UNION_ROOM, 0, 1);
         }
         EnterUnionRoomChat();
         break;
-    case 8:
-    case 72:
-        sub_8117594(gBlockSendBuffer, FALSE);
-        SetMainCallback2(sub_8117354);
+    case ACTIVITY_CARD:
+    case ACTIVITY_CARD | IN_UNION_ROOM:
+        CreateTrainerCardInBuffer(gBlockSendBuffer, FALSE);
+        SetMainCallback2(CB2_ShowCard);
         break;
-    case 9:
-        sub_8117440(USING_MINIGAME, 5, 1);
-        sub_8147AA8(GetCursorSelectionMonId(), CB2_LoadMap);
+    case ACTIVITY_PJUMP:
+        SetCableClubStateAndWarpCurrentMap(USING_MINIGAME, 5, 1);
+        StartPokemonJump(GetCursorSelectionMonId(), CB2_LoadMap);
         break;
-    case 10:
-        sub_8117440(USING_BERRY_CRUSH, 9, 1);
-        sub_814B754(CB2_LoadMap);
+    case ACTIVITY_BCRUSH:
+        SetCableClubStateAndWarpCurrentMap(USING_BERRY_CRUSH, 9, 1);
+        StartBerryCrush(CB2_LoadMap);
         break;
-    case 11:
-        sub_8117440(USING_MINIGAME, 5, 1);
-        sub_81507FC(GetCursorSelectionMonId(), CB2_LoadMap);
+    case ACTIVITY_BPICK:
+        SetCableClubStateAndWarpCurrentMap(USING_MINIGAME, 5, 1);
+        StartDodrioBerryPicking(GetCursorSelectionMonId(), CB2_LoadMap);
         break;
     }
 
@@ -1878,7 +2001,7 @@ static void sub_81175BC(u8 taskId)
     ScriptContext2_Disable();
 }
 
-static void sub_8117900(u8 taskId)
+static void Task_RunScriptAndFadeToActivity(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     u16 *sendBuff = (u16*)(gBlockSendBuffer);
@@ -1900,7 +2023,7 @@ static void sub_8117900(u8 taskId)
     case 2:
         if (!gPaletteFade.active)
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             data[0]++;
         }
         break;
@@ -1908,38 +2031,38 @@ static void sub_8117900(u8 taskId)
         if (IsLinkTaskFinished())
         {
             DestroyTask(taskId);
-            sub_81179A4();
+            CreateTask_StartActivity();
         }
         break;
     }
 }
 
-static void sub_8117990(void)
+static void CreateTask_RunScriptAndFadeToActivity(void)
 {
-    CreateTask(sub_8117900, 0);
+    CreateTask(Task_RunScriptAndFadeToActivity, 0);
 }
 
-static void sub_81179A4(void)
+static void CreateTask_StartActivity(void)
 {
-    u8 taskId = CreateTask(sub_81175BC, 0);
+    u8 taskId = CreateTask(Task_StartActivity, 0);
     gTasks[taskId].data[0] = 0;
 }
 
-void MEvent_CreateTask_Leader(u32 arg0)
+void MEvent_CreateTask_Leader(u32 activity)
 {
     u8 taskId;
     struct UnkStruct_Leader * dataPtr;
 
-    taskId = CreateTask(sub_8117A0C, 0);
+    taskId = CreateTask(Task_MEvent_Leader, 0);
     sUnionRoomMain.leader = dataPtr = (void*)(gTasks[taskId].data);
 
     dataPtr->state = 0;
     dataPtr->textState = 0;
-    dataPtr->field_18 = arg0;
+    dataPtr->activity = activity;
     gSpecialVar_Result = 0;
 }
 
-static void sub_8117A0C(u8 taskId)
+static void Task_MEvent_Leader(u8 taskId)
 {
     struct UnkStruct_Leader * data = sUnionRoomMain.leader;
     struct WindowTemplate winTemplate;
@@ -1948,43 +2071,43 @@ static void sub_8117A0C(u8 taskId)
     switch (data->state)
     {
     case 0:
-        gUnknown_203B058 = data->field_18;
-        gUnknown_203B059 = 2;
-        SetHostRFUtgtGname(data->field_18, 0, 0);
-        sub_80FAF74(FALSE, FALSE);
-        sub_800B1F4();
+        sPlayerCurrActivity = data->activity;
+        sPlayerActivityGroupSize = 2;
+        SetHostRFUtgtGname(data->activity, 0, 0);
+        SetGnameBufferWonderFlags(FALSE, FALSE);
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBB8C(2);
+        InitializeRfuLinkManager_LinkLeader(2);
         data->state = 1;
         break;
     case 1:
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        data->field_0 = AllocZeroed(5 * sizeof(struct UnkStruct_x20));
-        data->field_8 = AllocZeroed(5 * sizeof(struct UnkStruct_x20));
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 5);
-        LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].unk.gname, data->field_0->arr[0].unk.playerName);
+        data->field_0 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20));
+        data->field_8 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20));
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_PARTY_SIZE);
+        LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].gname_uname.gname, data->field_0->arr[0].gname_uname.uname);
         data->field_0->arr[0].field_18 = 0;
-        data->field_0->arr[0].field_1A_0 = 1;
-        data->field_0->arr[0].field_1A_1 = 0;
+        data->field_0->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
+        data->field_0->arr[0].field_1A_1 = FALSE;
         data->field_0->arr[0].field_1B = 0;
-        data->field_17 = sub_811A054(data->field_4, 0xFF);
+        data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF);
 
-        winTemplate = gUnknown_8456CFC;
+        winTemplate = sWindowTemplate_List_PossibleGroupMembers;
         winTemplate.baseBlock = GetMysteryGiftBaseBlock();
         data->listWindowId = AddWindow(&winTemplate);
         MG_DrawTextBorder(data->listWindowId);
-        gMultiuseListMenuTemplate = gUnknown_8456D34;
+        gMultiuseListMenuTemplate = sListMenuTemplate_PossibleGroupMembers;
         gMultiuseListMenuTemplate.windowId = data->listWindowId;
         data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
 
         CopyBgTilemapBufferToVram(0);
-        data->field_13 = 1;
+        data->playerCount = 1;
         data->state = 2;
         break;
     case 2:
-        StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]);
-        sub_811599C(gStringVar4, gUnknown_203B058);
+        StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]);
+        StringExpandPlaceholders_AwaitingCommFromAnother(gStringVar4, sPlayerCurrActivity);
         data->state = 3;
         break;
     case 3:
@@ -1992,7 +2115,7 @@ static void sub_8117A0C(u8 taskId)
         data->state = 4;
         break;
     case 4:
-        sub_8116444(data, 5, 6);
+        Leader_SetStateIfMemberListChanged(data, 5, 6);
         if (JOY_NEW(B_BUTTON))
         {
             data->state = 13;
@@ -2000,9 +2123,10 @@ static void sub_8117A0C(u8 taskId)
         }
         break;
     case 6:
+        // The link with your friend has been dropped...
         if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_84577F8))
         {
-            data->field_13 = sub_81165E8(data->field_0);
+            data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0);
             RedrawListMenu(data->listTaskId);
             data->state = 2;
         }
@@ -2011,44 +2135,44 @@ static void sub_8117A0C(u8 taskId)
         data->state = 7;
         break;
     case 7:
-        switch (mevent_message_print_and_prompt_yes_no(&data->textState, (u16 *)&data->field_14, FALSE, gStringVar4))
+        switch (mevent_message_print_and_prompt_yes_no(&data->textState, (u16 *)&data->messageWindowId, FALSE, gStringVar4))
         {
         case 0:
             LoadWirelessStatusIndicatorSpriteGfx();
             CreateWirelessStatusIndicatorSprite(0, 0);
-            data->field_0->arr[data->field_13].field_1B = 0;
+            data->field_0->arr[data->playerCount].field_1B = 0;
             RedrawListMenu(data->listTaskId);
             data->field_19 = 5;
-            sub_80FA670(5, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+            SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
             data->state = 8;
             break;
         case 1:
         case -1:
             data->field_19 = 6;
-            sub_80FA670(6, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+            SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
             data->state = 8;
             break;
         }
         break;
     case 8:
-        val = sub_80FA6FC(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName);
+        val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname);
         if (val == 1)
         {
             if (data->field_19 == 5)
             {
-                data->field_0->arr[data->field_13].field_1B = 0;
+                data->field_0->arr[data->playerCount].field_1B = 0;
                 RedrawListMenu(data->listTaskId);
-                data->field_13++;
-                IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_13 - 1]);
+                data->playerCount++;
+                IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->playerCount - 1]);
                 StringExpandPlaceholders(gStringVar4, gUnknown_8457554);
                 data->state = 9;
-                sub_80F8F5C();
+                LinkRfu_StopManagerAndFinalizeSlots();
             }
             else
             {
-                sub_80FBD4C(data->field_0->arr[data->field_13].unk.playerName, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId));
-                data->field_0->arr[data->field_13].field_1A_0 = 0;
-                sub_81165E8(data->field_0);
+                RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId));
+                data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE;
+                UnionRoomLeaderField0CompactionAndCount(data->field_0);
                 RedrawListMenu(data->listTaskId);
                 data->state = 2;
             }
@@ -2057,7 +2181,7 @@ static void sub_8117A0C(u8 taskId)
         }
         else if (val == 2)
         {
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             data->state = 2;
         }
         break;
@@ -2066,17 +2190,17 @@ static void sub_8117A0C(u8 taskId)
         data->state = 10;
         break;
     case 10:
-        if (++data->field_E > 120)
+        if (++data->delayTimerAfterOk > 120)
             data->state = 11;
         break;
     case 11:
-        if (!sub_8116444(data, 5, 6))
+        if (!Leader_SetStateIfMemberListChanged(data, 5, 6))
             data->state = 12;
         break;
     case 12:
-        if (sub_80F8F40())
+        if (LmanAcceptSlotFlagIsNotZero())
         {
-            sub_80F8F7C(FALSE);
+            WaitRfuState(FALSE);
             data->state = 15;
         }
         else
@@ -2086,17 +2210,18 @@ static void sub_8117A0C(u8 taskId)
         break;
     case 13:
         DestroyWirelessStatusIndicatorSprite();
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
         DestroyListMenuTask(data->listTaskId, 0, 0);
         CopyBgTilemapBufferToVram(0);
         RemoveWindow(data->listWindowId);
-        DestroyTask(data->field_17);
+        DestroyTask(data->listenTaskId);
         Free(data->field_8);
         Free(data->field_0);
         Free(data->field_4);
         data->state++;
         break;
     case 14:
+        // Please start over from the beginning.
         if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_84571B8))
         {
             DestroyTask(taskId);
@@ -2104,13 +2229,13 @@ static void sub_8117A0C(u8 taskId)
         }
         break;
     case 15:
-        if (sub_80FB9F4() == 1 || sub_80FB9F4() == 2)
+        if (RfuGetErrorStatus() == 1 || RfuGetErrorStatus() == 2)
         {
             data->state = 13;
         }
         else if (gReceivedRemoteLinkPlayers != 0)
         {
-            sub_80FAFE0(1);
+            UpdateGameData_GroupLockedIn(TRUE);
             data->state++;
         }
         break;
@@ -2118,11 +2243,11 @@ static void sub_8117A0C(u8 taskId)
         DestroyListMenuTask(data->listTaskId, 0, 0);
         CopyBgTilemapBufferToVram(0);
         RemoveWindow(data->listWindowId);
-        DestroyTask(data->field_17);
+        DestroyTask(data->listenTaskId);
         Free(data->field_8);
         Free(data->field_0);
         Free(data->field_4);
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         data->state++;
         break;
     case 17:
@@ -2132,22 +2257,22 @@ static void sub_8117A0C(u8 taskId)
     }
 }
 
-void MEvent_CreateTask_CardOrNewsWithFriend(u32 arg0)
+void MEvent_CreateTask_CardOrNewsWithFriend(u32 activity)
 {
     u8 taskId;
     struct UnkStruct_Group * dataPtr;
 
-    taskId = CreateTask(sub_8117F20, 0);
+    taskId = CreateTask(Task_CardOrNewsWithFriend, 0);
     sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data);
     sGroup = dataPtr;
 
     dataPtr->state = 0;
     dataPtr->textState = 0;
-    dataPtr->field_12 = arg0 - 21;
+    dataPtr->cardOrNews = activity - ACTIVITY_WCARD2; // 0: Card; 1: News
     gSpecialVar_Result = 0;
 }
 
-static void sub_8117F20(u8 taskId)
+static void Task_CardOrNewsWithFriend(u8 taskId)
 {
     s32 id;
     struct WindowTemplate winTemplate1, winTemplate2;
@@ -2156,10 +2281,10 @@ static void sub_8117F20(u8 taskId)
     switch (data->state)
     {
     case 0:
-        SetHostRFUtgtGname(data->field_12 + 21, 0, 0);
-        sub_800B1F4();
+        SetHostRFUtgtGname(data->cardOrNews + ACTIVITY_WCARD2, 0, 0);
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBBD8();
+        InitializeRfuLinkManager_JoinGroup();
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
         data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20));
         data->state = 1;
@@ -2169,33 +2294,33 @@ static void sub_8117F20(u8 taskId)
         data->state = 2;
         break;
     case 2:
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 16);
-        data->field_11 = sub_811A054(data->field_4, data->field_12 + 7);
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, 16);
+        data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, data->cardOrNews + LINK_GROUP_WONDER_CARD);
 
-        winTemplate1 = gUnknown_8456D4C;
+        winTemplate1 = sWindowTemplate_MysteryGiftList;
         winTemplate1.baseBlock = GetMysteryGiftBaseBlock();
         data->listWindowId = AddWindow(&winTemplate1);
 
-        data->field_D = AddWindow(&gUnknown_8456D54);
+        data->playerNameAndIdWindowId = AddWindow(&sWindowTemplate_MysteryGiftPlayerNameAndId);
 
         MG_DrawTextBorder(data->listWindowId);
-        gMultiuseListMenuTemplate = gUnknown_8456DDC;
+        gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups;
         gMultiuseListMenuTemplate.windowId = data->listWindowId;
         data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
 
-        MG_DrawTextBorder(data->field_D);
-        FillWindowPixelBuffer(data->field_D, PIXEL_FILL(1));
-        PutWindowTilemap(data->field_D);
-        sub_8115924(data->field_D);
-        CopyWindowToVram(data->field_D, 2);
+        MG_DrawTextBorder(data->playerNameAndIdWindowId);
+        FillWindowPixelBuffer(data->playerNameAndIdWindowId, PIXEL_FILL(1));
+        PutWindowTilemap(data->playerNameAndIdWindowId);
+        PrintPlayerNameAndIdOnWindow(data->playerNameAndIdWindowId);
+        CopyWindowToVram(data->playerNameAndIdWindowId, 2);
 
         CopyBgTilemapBufferToVram(0);
-        data->field_F = 0;
+        data->leaderId = 0;
         data->state = 3;
         break;
     case 3:
-        id = sub_8116FE4();
+        id = GetNewLeaderCandidate();
         switch (id)
         {
         case 1:
@@ -2209,16 +2334,16 @@ static void sub_8117F20(u8 taskId)
             {
                 // this unused variable along with the assignment is needed to match
                 u32 unusedVar;
-                unusedVar  = data->field_0->arr[id].unk.gname.unk_0a_0;
+                unusedVar  = data->field_0->arr[id].gname_uname.gname.activity;
 
-                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.gname.unk_0a_7)
+                if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started)
                 {
-                    data->field_F = id;
+                    data->leaderId = id;
                     LoadWirelessStatusIndicatorSpriteGfx();
                     CreateWirelessStatusIndicatorSprite(0, 0);
                     RedrawListMenu(data->listTaskId);
-                    IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]);
-                    sub_80FBF54(data->field_0->arr[data->field_F].unk.playerName, ReadAsU16(data->field_0->arr[data->field_F].unk.gname.unk_00.playerTrainerId));
+                    IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]);
+                    CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId));
                     PlaySE(SE_PN_ON);
                     data->state = 4;
                 }
@@ -2236,17 +2361,17 @@ static void sub_8117F20(u8 taskId)
         break;
     case 4:
         AddTextPrinterToWindow1(gUnknown_8459238);
-        IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]);
+        IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]);
         data->state = 5;
         break;
     case 5:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0;
+            sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity;
             data->state = 10;
         }
 
-        switch (sub_80FB9F4())
+        switch (RfuGetErrorStatus())
         {
         case 1:
         case 2:
@@ -2255,7 +2380,7 @@ static void sub_8117F20(u8 taskId)
             break;
         case 5:
             AddTextPrinterToWindow1(gUnknown_84576AC);
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             break;
         }
         break;
@@ -2264,19 +2389,19 @@ static void sub_8117F20(u8 taskId)
     case 10:
         DestroyListMenuTask(data->listTaskId, 0, 0);
         CopyBgTilemapBufferToVram(0);
-        RemoveWindow(data->field_D);
+        RemoveWindow(data->playerNameAndIdWindowId);
         RemoveWindow(data->listWindowId);
-        DestroyTask(data->field_11);
+        DestroyTask(data->listenTaskId);
         Free(data->field_0);
         Free(data->field_4);
         data->state++;
         break;
     case 9:
-        if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_8457838[sub_80FB9F4()]))
+        if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_8457838[RfuGetErrorStatus()]))
         {
             DestroyWirelessStatusIndicatorSprite();
             DestroyTask(taskId);
-            sub_80F8DC0();
+            LinkRfu_Shutdown();
             gSpecialVar_Result = 5;
         }
         break;
@@ -2284,12 +2409,12 @@ static void sub_8117F20(u8 taskId)
         DestroyWirelessStatusIndicatorSprite();
         AddTextPrinterToWindow1(gUnknown_84571B8);
         DestroyTask(taskId);
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
         gSpecialVar_Result = 5;
         break;
     case 11:
         data->state++;
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         break;
     case 12:
         if (IsLinkTaskFinished())
@@ -2298,22 +2423,22 @@ static void sub_8117F20(u8 taskId)
     }
 }
 
-void MEvent_CreateTask_CardOrNewsOverWireless(u32 arg0)
+void MEvent_CreateTask_CardOrNewsOverWireless(u32 activity)
 {
     u8 taskId;
     struct UnkStruct_Group * dataPtr;
 
-    taskId = CreateTask(sub_81182DC, 0);
+    taskId = CreateTask(Task_CardOrNewsOverWireless, 0);
     sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data);
     sGroup = dataPtr;
 
     dataPtr->state = 0;
     dataPtr->textState = 0;
-    dataPtr->field_12 = arg0 - 21;
+    dataPtr->cardOrNews = activity - ACTIVITY_WCARD2; // 0: Card; 1: News
     gSpecialVar_Result = 0;
 }
 
-static void sub_81182DC(u8 taskId)
+static void Task_CardOrNewsOverWireless(u8 taskId)
 {
     s32 id;
     struct WindowTemplate winTemplate;
@@ -2323,9 +2448,9 @@ static void sub_81182DC(u8 taskId)
     {
     case 0:
         SetHostRFUtgtGname(0, 0, 0);
-        sub_800B1F4();
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBBD8();
+        InitializeRfuLinkManager_JoinGroup();
         data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
         data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20));
         data->state = 1;
@@ -2335,29 +2460,29 @@ static void sub_81182DC(u8 taskId)
         data->state = 2;
         break;
     case 2:
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A5E4(data->field_0->arr, 16);
-        data->field_11 = sub_811A084(data->field_4, data->field_12 + 7);
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x20Array(data->field_0->arr, 16);
+        data->listenTaskId = CreateTask_ListenForPartnersWithSerial7F7D(data->field_4, data->cardOrNews + LINK_GROUP_WONDER_CARD);
 
         if (data->field_13 != 0)
         {
-            winTemplate = gUnknown_8456D4C;
+            winTemplate = sWindowTemplate_MysteryGiftList;
             winTemplate.baseBlock = GetMysteryGiftBaseBlock();
             data->listWindowId = AddWindow(&winTemplate);
 
             MG_DrawTextBorder(data->listWindowId);
-            gMultiuseListMenuTemplate = gUnknown_8456DDC;
+            gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups;
             gMultiuseListMenuTemplate.windowId = data->listWindowId;
             data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
 
             CopyBgTilemapBufferToVram(0);
         }
 
-        data->field_F = 0;
+        data->leaderId = 0;
         data->state = 3;
         break;
     case 3:
-        id = sub_8116FE4();
+        id = GetNewLeaderCandidate();
         switch (id)
         {
         case 1:
@@ -2369,17 +2494,17 @@ static void sub_81182DC(u8 taskId)
         case 0:
             if (data->field_13 != 0)
                 id = ListMenu_ProcessInput(data->listTaskId);
-            if (data->field_14 > 120)
+            if (data->refreshTimer > 120)
             {
-                if (data->field_0->arr[0].field_1A_0 == 1 && !data->field_0->arr[0].unk.gname.unk_0a_7)
+                if (data->field_0->arr[0].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[0].gname_uname.gname.started)
                 {
-                    if (sub_8119FB0(&data->field_0->arr[0].unk.gname, data->field_12 + 7))
+                    if (GetGnameWonderFlagByLinkGroup(&data->field_0->arr[0].gname_uname.gname, data->cardOrNews + LINK_GROUP_WONDER_CARD))
                     {
-                        data->field_F = 0;
-                        data->field_14 = 0;
+                        data->leaderId = 0;
+                        data->refreshTimer = 0;
                         LoadWirelessStatusIndicatorSpriteGfx();
                         CreateWirelessStatusIndicatorSprite(0, 0);
-                        sub_80FBF54(data->field_0->arr[0].unk.playerName, ReadAsU16(data->field_0->arr[0].unk.gname.unk_00.playerTrainerId));
+                        CreateTask_RfuReconnectWithParent(data->field_0->arr[0].gname_uname.uname, ReadAsU16(data->field_0->arr[0].gname_uname.gname.unk_00.playerTrainerId));
                         PlaySE(SE_PN_ON);
                         data->state = 4;
                     }
@@ -2393,25 +2518,25 @@ static void sub_81182DC(u8 taskId)
             else if (JOY_NEW(B_BUTTON))
             {
                 data->state = 6;
-                data->field_14 = 0;
+                data->refreshTimer = 0;
             }
-            data->field_14++;
+            data->refreshTimer++;
             break;
         }
         break;
     case 4:
         AddTextPrinterToWindow1(gUnknown_845928C);
-        IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]);
+        IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]);
         data->state = 5;
         break;
     case 5:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0;
+            sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity;
             data->state = 12;
         }
 
-        switch (sub_80FB9F4())
+        switch (RfuGetErrorStatus())
         {
         case 1:
         case 2:
@@ -2420,7 +2545,7 @@ static void sub_81182DC(u8 taskId)
             break;
         case 5:
             AddTextPrinterToWindow1(gUnknown_845777C);
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             break;
         }
         break;
@@ -2434,7 +2559,7 @@ static void sub_81182DC(u8 taskId)
             CopyBgTilemapBufferToVram(0);
             RemoveWindow(data->listWindowId);
         }
-        DestroyTask(data->field_11);
+        DestroyTask(data->listenTaskId);
         Free(data->field_0);
         Free(data->field_4);
         data->state++;
@@ -2444,7 +2569,7 @@ static void sub_81182DC(u8 taskId)
         {
             DestroyWirelessStatusIndicatorSprite();
             DestroyTask(taskId);
-            sub_80F8DC0();
+            LinkRfu_Shutdown();
             gSpecialVar_Result = 5;
         }
         break;
@@ -2453,22 +2578,22 @@ static void sub_81182DC(u8 taskId)
         {
             DestroyWirelessStatusIndicatorSprite();
             DestroyTask(taskId);
-            sub_80F8DC0();
+            LinkRfu_Shutdown();
             gSpecialVar_Result = 5;
         }
         break;
     case 11:
-        if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_845933C[data->field_12]))
+        if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_845933C[data->cardOrNews]))
         {
             DestroyWirelessStatusIndicatorSprite();
             DestroyTask(taskId);
-            sub_80F8DC0();
+            LinkRfu_Shutdown();
             gSpecialVar_Result = 5;
         }
         break;
     case 13:
         data->state++;
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         break;
     case 14:
         if (IsLinkTaskFinished())
@@ -2482,7 +2607,7 @@ void UnionRoomSpecial(void)
     struct UnkStruct_URoom * dataPtr;
 
     ClearAndInitHostRFUtgtGname();
-    CreateTask(sub_81186E0, 10);
+    CreateTask(Task_RunUnionRoom, 10);
 
     // dumb line needed to match
     sUnionRoomMain.uRoom = sUnionRoomMain.uRoom;
@@ -2497,7 +2622,7 @@ void UnionRoomSpecial(void)
     dataPtr->field_12 = 0;
 
     gSpecialVar_Result = 0;
-    sub_8107D38(0xD0, 1);
+    ListMenuLoadStdPalAt(0xD0, 1);
 }
 
 static u16 ReadAsU16(const u8 *ptr)
@@ -2505,7 +2630,7 @@ static u16 ReadAsU16(const u8 *ptr)
     return (ptr[1] << 8) | (ptr[0]);
 }
 
-static void sub_8118664(u32 nextState, const u8 *src)
+static void UnionRoom_ScheduleFieldMessageWithFollowupState(u32 nextState, const u8 *src)
 {
     struct UnkStruct_URoom * data = sUnionRoomMain.uRoom;
 
@@ -2515,7 +2640,7 @@ static void sub_8118664(u32 nextState, const u8 *src)
         StringExpandPlaceholders(gStringVar4, src);
 }
 
-static void sub_811868C(const u8 *src)
+static void UnionRoom_ScheduleFieldMessageAndExit(const u8 *src)
 {
     struct UnkStruct_URoom * data = sUnionRoomMain.uRoom;
 
@@ -2524,17 +2649,17 @@ static void sub_811868C(const u8 *src)
         StringExpandPlaceholders(gStringVar4, src);
 }
 
-static void sub_81186B0(struct UnkStruct_URoom * data)
+static void BackUpURoomField0ToDecompressionBuffer(struct UnkStruct_URoom * data)
 {
-    memcpy(&gDecompressionBuffer[0x3F00], data->field_0, 8 * sizeof(struct UnkStruct_x20));
+    memcpy(&gDecompressionBuffer[0x3F00], data->field_0, UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20));
 }
 
-static void sub_81186C8(struct UnkStruct_URoom * data)
+static void RestoreURoomField0FromDecompressionBuffer(struct UnkStruct_URoom * data)
 {
-    memcpy(data->field_0, &gDecompressionBuffer[0x3F00], 8 * sizeof(struct UnkStruct_x20));
+    memcpy(data->field_0, &gDecompressionBuffer[0x3F00], UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20));
 }
 
-static void sub_81186E0(u8 taskId)
+static void Task_RunUnionRoom(u8 taskId)
 {
     u32 id = 0;
     s32 var5 = 0;
@@ -2545,53 +2670,53 @@ static void sub_81186E0(u8 taskId)
     switch (data->state)
     {
     case 0:
-        data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        data->field_C = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        data->field_0 = AllocZeroed(8 * sizeof(struct UnkStruct_x20));
+        data->field_4 = AllocZeroed(RFU_CHILD_MAX * sizeof(struct UnkStruct_x1C));
+        data->field_C = AllocZeroed(RFU_CHILD_MAX * sizeof(struct UnkStruct_x1C));
+        data->field_0 = AllocZeroed(UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20));
         data->field_8 = AllocZeroed(sizeof(struct UnkStruct_x20));
-        sub_811A5E4(data->field_0->arr, 8);
-        gUnknown_203B058 = 0x40;
-        data->field_20 = sub_8119E84(data->field_C, data->field_4, 9);
+        BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_GROUP_COUNT);
+        sPlayerCurrActivity = IN_UNION_ROOM;
+        data->field_20 = CreateTask_SearchForChildOrParent(data->field_C, data->field_4, LINK_GROUP_UNION_ROOM_RESUME);
         ZeroUnionObjWork(data->unionObjs);
-        sub_811BB68();
+        MakeGroupAssemblyAreasPassable();
         data->state = 1;
         break;
     case 1:
-        sub_811BAAC(data->spriteIds, taskData[0]);
+        CreateGroupMemberObjectsInvisible(data->spriteIds, taskData[0]);
         if (++taskData[0] == 8)
             data->state = 2;
         break;
     case 2:
-        SetHostRFUtgtGname(0x40, 0, 0);
-        sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
-        sub_800B1F4();
+        SetHostRFUtgtGname(IN_UNION_ROOM, 0, 0);
+        RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBC00();
-        sub_811A5E4(&data->field_8->arr[0], 1);
-        sub_811A650(data->field_4->arr, 4);
-        sub_811A650(data->field_C->arr, 4);
+        InitializeRfuLinkManager_EnterUnionRoom();
+        BlankUnkStruct_x20Array(&data->field_8->arr[0], 1);
+        BlankUnkStruct_x1CArray(data->field_4->arr, 4);
+        BlankUnkStruct_x1CArray(data->field_C->arr, 4);
         gSpecialVar_Result = 0;
         data->state = 3;
         break;
     case 3:
         if ((GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_REGISTER
-             || GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_TRADE)
+          || GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_TRADE)
             && sUnionRoomTrade.field_0 != 0)
         {
             id = GetCursorSelectionMonId();
             switch (sUnionRoomTrade.field_0)
             {
             case 1:
-                sub_80FB008(0x54, 0, 1);
+                UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
                 if (id >= PARTY_SIZE)
                 {
                     ResetUnionRoomTrade(&sUnionRoomTrade);
-                    sub_80FAFA0(0, 0, 0);
-                    sub_811868C(gUnknown_8458D54);
+                    RfuUpdatePlayerGnameStateAndSend(0, 0, 0);
+                    UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D54);
                 }
                 else if (!RegisterTradeMonAndGetIsEgg(GetCursorSelectionMonId(), &sUnionRoomTrade))
                 {
-                    sub_8118664(0x34, gUnknown_8458CD4);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(52, gURText_PleaseChooseTypeOfMon);
                 }
                 else
                 {
@@ -2599,16 +2724,16 @@ static void sub_81186E0(u8 taskId)
                 }
                 break;
             case 2:
-                sub_81186C8(data);
+                RestoreURoomField0FromDecompressionBuffer(data);
                 taskData[1] = sUnionRoomTrade.field_8;
                 if (id >= PARTY_SIZE)
                 {
-                    sub_811868C(gUnknown_8458D9C);
+                    UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D9C);
                 }
                 else
                 {
-                    sub_80FB008(0x54, 0, 1);
-                    gUnknown_203B058 = 0x44;
+                    UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
+                    sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM;
                     RegisterTradeMon(GetCursorSelectionMonId(), &sUnionRoomTrade);
                     data->state = 51;
                 }
@@ -2626,7 +2751,7 @@ static void sub_81186E0(u8 taskId)
         {
             if (gSpecialVar_Result == 9)
             {
-                sub_80FB008(0x54, 0, 1);
+                UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
                 PlaySE(SE_PC_LOGIN);
                 StringCopy(gStringVar1, gSaveBlock2Ptr->playerName);
                 data->state = 42;
@@ -2634,7 +2759,7 @@ static void sub_81186E0(u8 taskId)
             }
             else if (gSpecialVar_Result == 11)
             {
-                sub_80FB008(0x54, 0, 1);
+                UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
                 data->state = 23;
                 gSpecialVar_Result = 0;
             }
@@ -2650,98 +2775,98 @@ static void sub_81186E0(u8 taskId)
         {
             if (JOY_NEW(A_BUTTON))
             {
-                if (sub_811BF00(data->field_0, &taskData[0], &taskData[1], data->spriteIds))
+                if (RfuUnionTool_GetGroupAndMemberInFrontOfPlayer(data->field_0, &taskData[0], &taskData[1], data->spriteIds))
                 {
                     PlaySE(SE_SELECT);
-                    sub_811B298();
+                    UR_EnableScriptContext2AndFreezeObjectEvents();
                     data->state = 24;
                     break;
                 }
-                else if (sub_811A9B8())
+                else if (PlayerIsTalkingToUnionRoomAide())
                 {
-                    sub_80FB008(0x54, 0, 1);
+                    UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
                     PlaySE(SE_PC_LOGIN);
-                    sub_811B298();
+                    UR_EnableScriptContext2AndFreezeObjectEvents();
                     StringCopy(gStringVar1, gSaveBlock2Ptr->playerName);
                     data->state = 45;
                     break;
                 }
             }
 
-            switch (sub_8119B94())
+            switch (HandlePlayerListUpdate())
             {
             case 1:
                 PlaySE(SE_TOY_C);
             case 2:
-                sub_811BECC(data);
+                ScheduleUnionRoomPlayerRefresh(data);
                 break;
             case 4:
                 data->state = 11;
-                sub_811B298();
-                sub_80FAFA0(0, 0, 0);
-                sub_80FB008(0x53, sub_811B2D8(data), 0);
+                UR_EnableScriptContext2AndFreezeObjectEvents();
+                RfuUpdatePlayerGnameStateAndSend(0, 0, 0);
+                UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_NPCTALK | IN_UNION_ROOM, GetActivePartnerSpriteGenderParam(data), FALSE);
                 break;
             }
-            sub_811BEDC(data);
+            HandleUnionRoomPlayerRefresh(data);
         }
         break;
     case 23:
         if (!FuncIsActiveTask(Task_StartMenuHandleInput))
         {
-            sub_80FB008(0x40, 0, 0);
+            UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE);
             data->state = 4;
         }
         break;
     case 24:
-        sub_811A0E0();
+        UR_RunTextPrinters_CheckPrinter0Active();
         playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-        sub_80FB008(0x54, 0, 1);
-        switch (sub_811AA5C(data->field_0, taskData[0], taskData[1], playerGender))
+        UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
+        switch (UnionRoomGetPlayerInteractionResponse(data->field_0, taskData[0], taskData[1], playerGender))
         {
         case 0:
             data->state = 26;
             break;
         case 1:
-            sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, gUnknown_203B058);
+            sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity);
             data->field_12 = id; // Should be just 0, but won't match any other way.
             data->state = 25;
             break;
         case 2:
-            sub_8118664(0x13, gStringVar4);
+            UnionRoom_ScheduleFieldMessageWithFollowupState(19, gStringVar4);
             break;
         }
         break;
     case 25:
-        sub_811A0E0();
-        switch (sub_80FB9F4())
+        UR_RunTextPrinters_CheckPrinter0Active();
+        switch (RfuGetErrorStatus())
         {
         case 4:
-            sub_811B258(TRUE);
+            HandleCancelTrade(TRUE);
             data->state = 4;
             break;
         case 1:
         case 2:
-            if (sub_80FBB0C() == TRUE)
-                sub_811868C(gUnknown_8457F90);
+            if (IsUnionRoomListenTaskActive() == TRUE)
+                UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8457F90);
             else
-                sub_8118664(30, gUnknown_8457F90);
+                UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_8457F90);
 
-            gUnknown_203B058 = 0x40;
+            sPlayerCurrActivity = IN_UNION_ROOM;
             break;
         }
 
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            sub_8117594(gBlockSendBuffer, TRUE);
-            CreateTask(sub_8117280, 5);
+            CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
+            CreateTask(Task_ExchangeCards, 5);
             data->state = 38;
         }
         break;
     case 38:
-        if (!FuncIsActiveTask(sub_8117280))
+        if (!FuncIsActiveTask(Task_ExchangeCards))
         {
-            if (gUnknown_203B058 == 0x44)
-                sub_8118664(31, gUnknown_84578BC);
+            if (sPlayerCurrActivity == (ACTIVITY_TRADE | IN_UNION_ROOM))
+                UnionRoom_ScheduleFieldMessageWithFollowupState(31, gUnknown_84578BC);
             else
                 data->state = 5;
         }
@@ -2749,18 +2874,18 @@ static void sub_81186E0(u8 taskId)
     case 30:
         if (gReceivedRemoteLinkPlayers == 0)
         {
-            sub_811B258(FALSE);
-            sub_811C028(taskData[0], taskData[1], data->field_0);
+            HandleCancelTrade(FALSE);
+            UpdateUnionGroupMemberFacing(taskData[0], taskData[1], data->field_0);
             data->state = 2;
         }
         break;
     case 5:
-        id = sub_811AA24(&data->field_0->arr[taskData[1]]);
+        id = ConvPartnerUnameAndGetWhetherMetAlready(&data->field_0->arr[taskData[1]]);
         playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-        sub_8118664(6, gUnknown_8457B04[id][playerGender]);
+        UnionRoom_ScheduleFieldMessageWithFollowupState(6, gURText_FriendPromptsForActivity[id][playerGender]);
         break;
     case 6:
-        var5 = sub_811A218(&data->textState, &data->field_1B, &data->field_1C, &gUnknown_8456DF4, &gUnknown_8456E1C);
+        var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->topListMenuWindowId, &data->topListMenuListMenuId, &sWindowTemplate_InviteToActivity, &sListMenuTemplate_InviteToActivity);
         if (var5 != -1)
         {
             if (gReceivedRemoteLinkPlayers == 0)
@@ -2769,27 +2894,27 @@ static void sub_81186E0(u8 taskId)
             }
             else
             {
-                data->field_98 = 0;
+                data->partnerYesNoResponse = 0;
                 playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-                if (var5 == -2 || var5 == 0x40)
+                if (var5 == -2 || var5 == IN_UNION_ROOM)
                 {
-                    data->field_4C[0] = 0x40;
-                    sub_80F9E2C(data->field_4C);
+                    data->playerSendBuffer[0] = IN_UNION_ROOM;
+                    RfuPrepareSend0x2f00(data->playerSendBuffer);
                     StringCopy(gStringVar4, gUnknown_845842C[gLinkPlayers[0].gender]);
                     data->state = 32;
                 }
                 else
                 {
-                    gUnknown_203B058 = var5;
-                    gUnknown_203B059 = (u32)(var5) >> 8;
-                    if (gUnknown_203B058 == 0x41 && !HasAtLeastTwoMonsOfLevel30OrLower())
+                    sPlayerCurrActivity = var5;
+                    sPlayerActivityGroupSize = (u32)(var5) >> 8;
+                    if (sPlayerCurrActivity == (ACTIVITY_BATTLE | IN_UNION_ROOM) && !HasAtLeastTwoMonsOfLevel30OrLower())
                     {
-                        sub_8118664(5, gUnknown_845847C);
+                        UnionRoom_ScheduleFieldMessageWithFollowupState(5, gUnknown_845847C);
                     }
                     else
                     {
-                        data->field_4C[0] = gUnknown_203B058 | 0x40;
-                        sub_80F9E2C(data->field_4C);
+                        data->playerSendBuffer[0] = sPlayerCurrActivity | IN_UNION_ROOM;
+                        RfuPrepareSend0x2f00(data->playerSendBuffer);
                         data->state = 27;
                     }
                 }
@@ -2801,24 +2926,24 @@ static void sub_81186E0(u8 taskId)
         data->state = 36;
         break;
     case 27:
-        sub_811B0A4(data);
+        PollPartnerYesNoResponse(data);
         playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-        id = sub_811A9FC(data->field_4C[0] & 0x3F);
-        if (PrintOnTextbox(&data->textState, gUnknown_84580F4[playerGender][id]))
+        id = GetResponseIdx_InviteToURoomActivity(data->playerSendBuffer[0] & 0x3F);
+        if (PrintOnTextbox(&data->textState, gResponseToURoomActivityInviteStringPtrs[playerGender][id]))
         {
             taskData[3] = 0;
             data->state = 29;
         }
         break;
     case 32:
-        sub_800AAC0();
+        Link_TryStartSend5FFF();
         data->state = 36;
         break;
     case 31:
-        data->field_4C[0] = 0x44;
-        data->field_4C[1] = sUnionRoomTrade.species;
-        data->field_4C[2] = sUnionRoomTrade.level;
-        sub_80F9E2C(data->field_4C);
+        data->playerSendBuffer[0] = ACTIVITY_TRADE | IN_UNION_ROOM;
+        data->playerSendBuffer[1] = sUnionRoomTrade.species;
+        data->playerSendBuffer[2] = sUnionRoomTrade.level;
+        RfuPrepareSend0x2f00(data->playerSendBuffer);
         data->state = 29;
         break;
     case 29:
@@ -2829,12 +2954,12 @@ static void sub_81186E0(u8 taskId)
         }
         else
         {
-            sub_811B0A4(data);
-            if (data->field_98 == 0x51)
+            PollPartnerYesNoResponse(data);
+            if (data->partnerYesNoResponse == (ACTIVITY_ACCEPT | IN_UNION_ROOM))
             {
-                if (gUnknown_203B058 == 8)
+                if (sPlayerCurrActivity == ACTIVITY_CARD)
                 {
-                    sub_811B31C(gStringVar4, data, FALSE);
+                    ViewURoomPartnerTrainerCard(gStringVar4, data, MODE_CHILD);
                     data->state = 40;
                 }
                 else
@@ -2842,27 +2967,27 @@ static void sub_81186E0(u8 taskId)
                     data->state = 13;
                 }
             }
-            else if (data->field_98 == 0x52)
+            else if (data->partnerYesNoResponse == (ACTIVITY_DECLINE | IN_UNION_ROOM))
             {
                 data->state = 32;
-                sub_811AE68(gStringVar4, gUnknown_203B058 | 0x40, gLinkPlayers[0].gender);
-                gUnknown_203B058 = 0;
+                GetURoomActivityRejectMsg(gStringVar4, sPlayerCurrActivity | IN_UNION_ROOM, gLinkPlayers[0].gender);
+                sPlayerCurrActivity = 0;
             }
         }
         break;
 
     case 7:
-        id = sub_811AA24(&data->field_0->arr[taskData[1]]);
+        id = ConvPartnerUnameAndGetWhetherMetAlready(&data->field_0->arr[taskData[1]]);
         playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-        sub_8118664(6, gUnknown_8457B04[id][playerGender]);
+        UnionRoom_ScheduleFieldMessageWithFollowupState(6, gURText_FriendPromptsForActivity[id][playerGender]);
         break;
     case 40:
         if (PrintOnTextbox(&data->textState, gStringVar4))
         {
             data->state = 41;
-            sub_800AB9C();
-            data->field_98 = 0;
-            data->field_9A[0] = 0;
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
+            data->partnerYesNoResponse = 0;
+            data->recvActivityRequest[0] = 0;
         }
         break;
     case 41:
@@ -2882,13 +3007,13 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 19:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
             CopyBgTilemapBufferToVram(0);
-            gUnknown_203B058 = 0x45;
-            sub_80FB008(0x45, 0, 1);
-            sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, gUnknown_203B058);
+            sPlayerCurrActivity = ACTIVITY_CHAT | IN_UNION_ROOM;
+            UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, 0, TRUE);
+            sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity);
             data->field_12 = taskData[1];
             data->state = 20;
             taskData[3] = 0;
@@ -2896,7 +3021,7 @@ static void sub_81186E0(u8 taskId)
         case 1:
         case -1:
             playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-            sub_811868C(gUnknown_8458548[playerGender]);
+            UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458548[playerGender]);
             break;
         }
         break;
@@ -2908,20 +3033,20 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 21:
-        switch (sub_80FB9F4())
+        switch (RfuGetErrorStatus())
         {
         case 4:
-            sub_811B258(TRUE);
+            HandleCancelTrade(TRUE);
             data->state = 4;
             break;
         case 1:
         case 2:
             playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-            sub_80FB008(0x54, 0, 1);
-            if (sub_80FBB0C() == TRUE)
-                sub_811868C(gUnknown_84585E8[playerGender]);
+            UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
+            if (IsUnionRoomListenTaskActive() == TRUE)
+                UnionRoom_ScheduleFieldMessageAndExit(gUnknown_84585E8[playerGender]);
             else
-                sub_8118664(30, gUnknown_84585E8[playerGender]);
+                UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_84585E8[playerGender]);
             break;
         case 3:
             data->state = 22;
@@ -2930,14 +3055,14 @@ static void sub_81186E0(u8 taskId)
         taskData[3]++;
         break;
     case 22:
-        if (sub_80FBA00())
+        if (RfuIsErrorStatus1or2())
         {
             playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0);
-            sub_80FB008(0x54, 0, 1);
-            if (sub_80FBB0C() == TRUE)
-                sub_811868C(gUnknown_84585E8[playerGender]);
+            UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE);
+            if (IsUnionRoomListenTaskActive() == TRUE)
+                UnionRoom_ScheduleFieldMessageAndExit(gUnknown_84585E8[playerGender]);
             else
-                sub_8118664(30, gUnknown_84585E8[playerGender]);
+                UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_84585E8[playerGender]);
         }
         if (gReceivedRemoteLinkPlayers != 0)
             data->state = 16;
@@ -2946,24 +3071,24 @@ static void sub_81186E0(u8 taskId)
         PlaySE(SE_PINPON);
         sub_80F8FA0();
         data->state = 12;
-        data->field_9A[0] = 0;
+        data->recvActivityRequest[0] = 0;
         break;
     case 12:
-        if (sub_80FBA00())
+        if (RfuIsErrorStatus1or2())
         {
-            sub_811B258(FALSE);
+            HandleCancelTrade(FALSE);
             data->state = 2;
         }
         else if (gReceivedRemoteLinkPlayers != 0)
         {
-            sub_8117594(gBlockSendBuffer, TRUE);
-            CreateTask(sub_8117280, 5);
+            CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE);
+            CreateTask(Task_ExchangeCards, 5);
             data->state = 39;
         }
         break;
     case 39:
-        sub_8119904(data);
-        if (!FuncIsActiveTask(sub_8117280))
+        ReceiveUnionRoomActivityPacket(data);
+        if (!FuncIsActiveTask(Task_ExchangeCards))
         {
             data->state = 33;
             StringCopy(gStringVar1, gLinkPlayers[1].name);
@@ -2972,13 +3097,13 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 33:
-        sub_8119904(data);
+        ReceiveUnionRoomActivityPacket(data);
         if (PrintOnTextbox(&data->textState, gStringVar4))
             data->state = 34;
         break;
     case 34:
-        sub_8119904(data);
-        if (sub_8119944(data) && JOY_NEW(B_BUTTON))
+        ReceiveUnionRoomActivityPacket(data);
+        if (UnionRoom_HandleContactFromOtherPlayer(data) && JOY_NEW(B_BUTTON))
         {
             sub_80FBD6C(1);
             StringCopy(gStringVar4, gUnknown_8457E60);
@@ -2986,80 +3111,82 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 35:
-        sub_8118664(9, gStringVar4);
+        // You said yes
+        UnionRoom_ScheduleFieldMessageWithFollowupState(9, gStringVar4);
         break;
     case 9:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
-            data->field_4C[0] = 0x51;
-            if (gUnknown_203B058 == 0x45)
-                sub_80FB008(gUnknown_203B058 | 0x40, sub_811B2A8(1), 0);
+            data->playerSendBuffer[0] = ACTIVITY_ACCEPT | IN_UNION_ROOM;
+            if (sPlayerCurrActivity == (ACTIVITY_CHAT | IN_UNION_ROOM))
+                UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), FALSE);
             else
-                sub_80FB008(gUnknown_203B058 | 0x40, sub_811B2A8(1), 1);
+                UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), TRUE);
 
             data->field_8->arr[0].field_1B = 0;
             taskData[3] = 0;
-            if (gUnknown_203B058 == 0x41)
+            if (sPlayerCurrActivity == (ACTIVITY_BATTLE | IN_UNION_ROOM))
             {
                 if (!HasAtLeastTwoMonsOfLevel30OrLower())
                 {
-                    data->field_4C[0] = 0x52;
-                    sub_80F9E2C(data->field_4C);
+                    data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM;
+                    RfuPrepareSend0x2f00(data->playerSendBuffer);
                     data->state = 10;
                     StringCopy(gStringVar4, gUnknown_84584C0);
                 }
                 else
                 {
-                    sub_80F9E2C(data->field_4C);
+                    RfuPrepareSend0x2f00(data->playerSendBuffer);
                     data->state = 13;
                 }
             }
-            else if (gUnknown_203B058 == 0x48)
+            else if (sPlayerCurrActivity == (ACTIVITY_CARD | IN_UNION_ROOM))
             {
-                sub_80F9E2C(data->field_4C);
-                sub_811B31C(gStringVar4, data, 1);
+                RfuPrepareSend0x2f00(data->playerSendBuffer);
+                ViewURoomPartnerTrainerCard(gStringVar4, data, MODE_PARENT);
                 data->state = 40;
             }
             else
             {
-                sub_80F9E2C(data->field_4C);
+                RfuPrepareSend0x2f00(data->playerSendBuffer);
                 data->state = 13;
             }
             break;
         case 1:
         case -1:
-            data->field_4C[0] = 0x52;
-            sub_80F9E2C(data->field_4C);
+            data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM;
+            RfuPrepareSend0x2f00(data->playerSendBuffer);
             data->state = 10;
-            sub_81162E0(gStringVar4, gUnknown_203B058);
+            GetYouDeclinedTheOfferMessage(gStringVar4, sPlayerCurrActivity);
             break;
         }
         break;
     case 10:
-        sub_800AAC0();
+        Link_TryStartSend5FFF();
         data->state = 36;
         break;
     case 36:
+        // You said no
         if (gReceivedRemoteLinkPlayers == 0)
         {
-            gUnknown_203B058 = 0x40;
-            sub_8118664(0x25, gStringVar4);
-            memset(data->field_4C, 0, sizeof(data->field_4C));
-            data->field_9A[0] = 0;
-            data->field_98 = 0;
+            sPlayerCurrActivity = IN_UNION_ROOM;
+            UnionRoom_ScheduleFieldMessageWithFollowupState(37, gStringVar4);
+            memset(data->playerSendBuffer, 0, sizeof(data->playerSendBuffer));
+            data->recvActivityRequest[0] = 0;
+            data->partnerYesNoResponse = 0;
         }
         break;
     case 37:
         data->state = 2;
-        sub_811B258(FALSE);
+        HandleCancelTrade(FALSE);
         break;
     case 13:
-        sub_811AECC(gStringVar4, gUnknown_203B058 | 0x40);
-        sub_8118664(14, gStringVar4);
+        GetURoomActivityStartMsg(gStringVar4, sPlayerCurrActivity | IN_UNION_ROOM);
+        UnionRoom_ScheduleFieldMessageWithFollowupState(14, gStringVar4);
         break;
     case 14:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         data->state = 15;
         break;
     case 15:
@@ -3072,7 +3199,7 @@ static void sub_81186E0(u8 taskId)
         Free(data->field_C);
         Free(data->field_4);
         DestroyTask(data->field_20);
-        sub_811BB40(data->spriteIds);
+        DestroyGroupMemberObjects(data->spriteIds);
         data->state = 17;
         break;
     case 17:
@@ -3082,30 +3209,30 @@ static void sub_81186E0(u8 taskId)
     case 18:
         if (!UpdatePaletteFade())
         {
-            sub_811BA78();
+            DeleteUnionObjWorkAndStopTask();
             DestroyTask(taskId);
             Free(sUnionRoomMain.uRoom);
-            sub_81179A4();
+            CreateTask_StartActivity();
         }
         break;
     case 42:
-        if (sub_80F9800()->species == SPECIES_NONE)
+        if (GetHostRFUtgtGname()->species == SPECIES_NONE)
         {
             data->state = 43;
         }
         else
         {
-            if (sub_80F9800()->species == SPECIES_EGG)
+            if (GetHostRFUtgtGname()->species == SPECIES_EGG)
             {
                 StringCopy(gStringVar4, gUnknown_8458DE8);
             }
             else
             {
-                StringCopy(gStringVar1, gSpeciesNames[sub_80F9800()->species]);
-                ConvertIntToDecimalStringN(gStringVar2, sub_80F9800()->level, STR_CONV_MODE_LEFT_ALIGN, 3);
+                StringCopy(gStringVar1, gSpeciesNames[GetHostRFUtgtGname()->species]);
+                ConvertIntToDecimalStringN(gStringVar2, GetHostRFUtgtGname()->level, STR_CONV_MODE_LEFT_ALIGN, 3);
                 StringExpandPlaceholders(gStringVar4, gUnknown_8458DBC);
             }
-            sub_8118664(44, gStringVar4);
+            UnionRoom_ScheduleFieldMessageWithFollowupState(44, gStringVar4);
         }
         break;
     case 43:
@@ -3113,23 +3240,23 @@ static void sub_81186E0(u8 taskId)
             data->state = 47;
         break;
     case 47:
-        var5 = sub_811A218(&data->textState, &data->field_1D, &data->field_1E, &gUnknown_8456E34, &gUnknown_8456E54);
+        var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardDetailsWindowId, &sWindowTemplate_TradeBoardRegisterInfoExit, &sListMenuTemplate_TradeBoardRegisterInfoExit);
         if (var5 != -1)
         {
             if (var5 == -2 || var5 == 3)
             {
                 data->state = 4;
-                sub_811B258(TRUE);
+                HandleCancelTrade(TRUE);
             }
             else
             {
                 switch (var5)
                 {
                 case 1: // REGISTER
-                    sub_8118664(53, gUnknown_8458D1C);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(53, gUnknown_8458D1C);
                     break;
                 case 2: // INFO
-                    sub_8118664(47, gUnknown_8458B44);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(47, gUnknown_8458B44);
                     break;
                 }
             }
@@ -3149,7 +3276,7 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 52:
-        var5 = sub_811A218(&data->textState, &data->field_1D, &data->field_1E, &gUnknown_8456E6C, &gUnknown_8456F04);
+        var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardDetailsWindowId, &sWindowTemplate_TypeNames, &sListMenuTemplate_TypeNames);
         if (var5 != -1)
         {
             switch (var5)
@@ -3157,8 +3284,8 @@ static void sub_81186E0(u8 taskId)
             case -2:
             case 18:
                 ResetUnionRoomTrade(&sUnionRoomTrade);
-                sub_80FAFA0(0, 0, 0);
-                sub_811868C(gUnknown_8458D54);
+                RfuUpdatePlayerGnameStateAndSend(0, 0, 0);
+                UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D54);
                 break;
             default:
                 sUnionRoomTrade.type = var5;
@@ -3168,18 +3295,18 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 55:
-        sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
-        sub_811868C(gUnknown_8458D78);
+        RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
+        UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D78);
         break;
     case 44:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
             data->state = 56;
             break;
         case 1:
         case -1:
-            sub_811B258(TRUE);
+            HandleCancelTrade(TRUE);
             data->state = 4;
             break;
         }
@@ -3187,9 +3314,9 @@ static void sub_81186E0(u8 taskId)
     case 56:
         if (PrintOnTextbox(&data->textState, gUnknown_8458E10))
         {
-            sub_80FAFA0(0, 0, 0);
+            RfuUpdatePlayerGnameStateAndSend(0, 0, 0);
             ResetUnionRoomTrade(&sUnionRoomTrade);
-            sub_811B258(TRUE);
+            HandleCancelTrade(TRUE);
             data->state = 4;
         }
         break;
@@ -3198,38 +3325,38 @@ static void sub_81186E0(u8 taskId)
             data->state = 46;
         break;
     case 46:
-        sub_811A3F8();
+        UR_BlankBg0();
         data->state = 48;
         break;
     case 48:
-        var5 = sub_811A2EC(&data->textState, &data->field_1D, &data->field_4A, &data->field_1E, &gUnknown_8456F24, &gUnknown_8456F7C, data->field_0);
+        var5 = TradeBoardMenuHandler(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardListMenuId, &data->tradeBoardDetailsWindowId, &gUnknown_8456F24, &sTradeBoardListMenuTemplate, data->field_0);
         if (var5 != -1)
         {
             switch (var5)
             {
             case -2:
             case 8:
-                sub_811B258(TRUE);
+                HandleCancelTrade(TRUE);
                 DestroyHelpMessageWindow_();
                 data->state = 4;
                 break;
             default:
-                switch (sub_811ADD0(data->field_0->arr[var5].unk.gname.type, data->field_0->arr[var5].unk.gname.species))
+                switch (IsRequestedTypeAndSpeciesInPlayerParty(data->field_0->arr[var5].gname_uname.gname.type, data->field_0->arr[var5].gname_uname.gname.species))
                 {
-                case 0:
+                case UR_TRADE_MATCH:
                     IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]);
-                    sub_8118664(49, gUnknown_8458E70);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(49, gUnknown_8458E70);
                     taskData[1] = var5;
                     break;
-                case 1:
+                case UR_TRADE_NOTYPE:
                     IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]);
-                    StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].unk.gname.type]);
-                    sub_8118664(46, gUnknown_8458ED0);
+                    StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(46, gUnknown_8458ED0);
                     break;
-                case 2:
+                case UR_TRADE_NOEGG:
                     IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]);
-                    StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].unk.gname.type]);
-                    sub_8118664(46, gUnknown_8458F04);
+                    StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]);
+                    UnionRoom_ScheduleFieldMessageWithFollowupState(46, gUnknown_8458F04);
                     break;
                 }
                 break;
@@ -3237,14 +3364,14 @@ static void sub_81186E0(u8 taskId)
         }
         break;
     case 49:
-        switch (sub_811A14C(&data->textState, FALSE))
+        switch (UnionRoomHandleYesNo(&data->textState, FALSE))
         {
         case 0:
             data->state = 50;
             break;
         case -1:
         case 1:
-            sub_811B258(TRUE);
+            HandleCancelTrade(TRUE);
             data->state = 4;
             break;
         }
@@ -3253,27 +3380,27 @@ static void sub_81186E0(u8 taskId)
         if (PrintOnTextbox(&data->textState, gUnknown_8458D1C))
         {
             sUnionRoomTrade.field_0 = 2;
-            memcpy(&gUnknown_203B064, &data->field_0->arr[taskData[1]].unk.gname.unk_00, sizeof(gUnknown_203B064));
-            gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].unk.gname.type;
-            gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].unk.gname.species;
+            memcpy(&gPartnerTgtGnameSub, &data->field_0->arr[taskData[1]].gname_uname.gname.unk_00, sizeof(gPartnerTgtGnameSub));
+            gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].gname_uname.gname.type;
+            gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].gname_uname.gname.species;
             gFieldCallback = sub_807DCE4;
             ChooseMonForTradingBoard(PARTY_MENU_TYPE_UNION_ROOM_TRADE, CB2_ReturnToField);
-            sub_81186B0(data);
+            BackUpURoomField0ToDecompressionBuffer(data);
             sUnionRoomTrade.field_8 = taskData[1];
         }
         break;
     case 51:
-        gUnknown_203B058 = 0x44;
-        sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, 0x44);
+        sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM;
+        sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, ACTIVITY_TRADE | IN_UNION_ROOM);
         IntlConvPartnerUname(gStringVar1, data->field_0->arr[taskData[1]]);
-        sub_811A0B4(gUnknown_8457A34[2]);
+        UR_PrintFieldMessage(gURText_PleaseWaitMsgs[2]);
         data->state = 25;
         break;
     case 26:
         if (PrintOnTextbox(&data->textState, gStringVar4))
         {
-            sub_811B258(TRUE);
-            sub_811C028(taskData[0], taskData[1], data->field_0);
+            HandleCancelTrade(TRUE);
+            UpdateUnionGroupMemberFacing(taskData[0], taskData[1], data->field_0);
             data->state = 4;
         }
         break;
@@ -3290,38 +3417,38 @@ void var_800D_set_xB(void)
         gSpecialVar_Result = 11;
 }
 
-static void sub_8119904(struct UnkStruct_URoom * arg0)
+static void ReceiveUnionRoomActivityPacket(struct UnkStruct_URoom * uroom)
 {
-    if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == 0x2F00)
+    if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == RFU_COMMAND_0x2f00)
     {
-        arg0->field_9A[0] = gRecvCmds[1][1];
-        if (gRecvCmds[1][1] == 0x44)
+        uroom->recvActivityRequest[0] = gRecvCmds[1][1];
+        if (gRecvCmds[1][1] == (ACTIVITY_TRADE | IN_UNION_ROOM))
         {
-            arg0->field_9A[1] = gRecvCmds[1][2];
-            arg0->field_9A[2] = gRecvCmds[1][3];
+            uroom->recvActivityRequest[1] = gRecvCmds[1][2];
+            uroom->recvActivityRequest[2] = gRecvCmds[1][3];
         }
     }
 }
 
-static bool32 sub_8119944(struct UnkStruct_URoom * arg0)
+static bool32 UnionRoom_HandleContactFromOtherPlayer(struct UnkStruct_URoom * uroom)
 {
-    if (arg0->field_9A[0] != 0)
+    if (uroom->recvActivityRequest[0] != 0)
     {
-        s32 var = sub_811AF6C(gStringVar4, gLinkPlayers[1].gender, &arg0->field_9A[0], arg0);
+        s32 var = GetChatLeaderActionRequestMessage(gStringVar4, gLinkPlayers[1].gender, &uroom->recvActivityRequest[0], uroom);
         if (var == 0)
         {
             return TRUE;
         }
         else if (var == 1)
         {
-            arg0->state = 35;
-            gUnknown_203B058 = arg0->field_9A[0];
+            uroom->state = 35;
+            sPlayerCurrActivity = uroom->recvActivityRequest[0];
             return FALSE;
         }
         else if (var == 2)
         {
-            arg0->state = 36;
-            sub_800AAC0();
+            uroom->state = 36;
+            Link_TryStartSend5FFF();
             return FALSE;
         }
     }
@@ -3336,7 +3463,7 @@ void InitUnionRoom(void)
     sUnionRoomPlayerName[0] = EOS;
     if (gQuestLogState == 2 || gQuestLogState == 3)
         return;
-    CreateTask(sub_81199FC, 0);
+    CreateTask(Task_InitUnionRoom, 0);
     sUnionRoomMain.uRoom = sUnionRoomMain.uRoom; // Needed to match.
     sUnionRoomMain.uRoom = ptr = AllocZeroed(sizeof(struct UnkStruct_URoom));
     sURoom = sUnionRoomMain.uRoom;
@@ -3347,7 +3474,7 @@ void InitUnionRoom(void)
     sUnionRoomPlayerName[0] = EOS;
 }
 
-static void sub_81199FC(u8 taskId)
+static void Task_InitUnionRoom(u8 taskId)
 {
     s32 i;
     u8 text[32];
@@ -3359,27 +3486,27 @@ static void sub_81199FC(u8 taskId)
         structPtr->state = 1;
         break;
     case 1:
-        SetHostRFUtgtGname(0xC, 0, 0);
-        sub_800B1F4();
+        SetHostRFUtgtGname(ACTIVITY_SEARCH, 0, 0);
+        SetWirelessCommType1();
         OpenLink();
-        sub_80FBC00();
-        sub_80FB128(1);
+        InitializeRfuLinkManager_EnterUnionRoom();
+        sub_80FB128(TRUE);
         structPtr->state = 2;
         break;
     case 2:
         structPtr->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        sub_811A650(structPtr->field_4->arr, 4);
+        BlankUnkStruct_x1CArray(structPtr->field_4->arr, 4);
         structPtr->field_C = AllocZeroed(4 * sizeof(struct UnkStruct_x1C));
-        sub_811A650(structPtr->field_C->arr, 4);
-        structPtr->field_0 = AllocZeroed(8 * sizeof(struct UnkStruct_x20));
-        sub_811A5E4(structPtr->field_0->arr, 8);
+        BlankUnkStruct_x1CArray(structPtr->field_C->arr, 4);
+        structPtr->field_0 = AllocZeroed(UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20));
+        BlankUnkStruct_x20Array(structPtr->field_0->arr, UROOM_MAX_GROUP_COUNT);
         structPtr->field_8 = AllocZeroed(sizeof(struct UnkStruct_x20));
-        sub_811A5E4(&structPtr->field_8->arr[0], 1);
-        structPtr->field_20 = sub_8119E84(structPtr->field_C, structPtr->field_4, 10);
+        BlankUnkStruct_x20Array(&structPtr->field_8->arr[0], 1);
+        structPtr->field_20 = CreateTask_SearchForChildOrParent(structPtr->field_C, structPtr->field_4, LINK_GROUP_UNION_ROOM_INIT);
         structPtr->state = 3;
         break;
     case 3:
-        switch (sub_8119B94())
+        switch (HandlePlayerListUpdate())
         {
         case 1:
         case 2:
@@ -3387,10 +3514,10 @@ static void sub_81199FC(u8 taskId)
             {
                 for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++)
                 {
-                    if (structPtr->field_0->arr[i].field_1A_0 == 1)
+                    if (structPtr->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
                     {
                         IntlConvPartnerUname(text, structPtr->field_0->arr[i]);
-                        if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].unk.gname.unk_00.playerTrainerId), text))
+                        if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].gname_uname.gname.unk_00.playerTrainerId), text))
                         {
                             StringCopy(sUnionRoomPlayerName, text);
                             break;
@@ -3410,7 +3537,7 @@ static void sub_81199FC(u8 taskId)
         Free(structPtr->field_4);
         DestroyTask(structPtr->field_20);
         Free(sUnionRoomMain.uRoom);
-        sub_80F8DC0();
+        LinkRfu_Shutdown();
         DestroyTask(taskId);
         break;
     }
@@ -3430,36 +3557,41 @@ bool16 BufferUnionRoomPlayerName(void)
     }
 }
 
-static u8 sub_8119B94(void)
+static u8 HandlePlayerListUpdate(void)
 {
     s32 i;
     u8 j;
     struct UnkStruct_URoom * structPtr = sUnionRoomMain.uRoom;
     s32 r7 = 0;
 
-    for (i = 0; i < 4; i++)
+    // If someone new joined, register them in field_8
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (sub_811A694(&structPtr->field_C->arr[i].unk0, &gUnknown_8457034) == TRUE)
+        if (AreGnameUnameDifferent(&structPtr->field_C->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy) == TRUE)
         {
-            structPtr->field_8->arr[0].unk = structPtr->field_C->arr[i].unk0;
+            structPtr->field_8->arr[0].gname_uname = structPtr->field_C->arr[i].gname_uname;
             structPtr->field_8->arr[0].field_18 = 0;
-            structPtr->field_8->arr[0].field_1A_0 = 1;
+            structPtr->field_8->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
             structPtr->field_8->arr[0].field_1B = 1;
             return 4;
         }
     }
-    for (j = 0; j < 8; j++)
+
+    // Handle changes to existing player statuses
+    for (j = 0; j < UROOM_MAX_GROUP_COUNT; j++)
     {
-        if (structPtr->field_0->arr[j].field_1A_0 != 0)
+        if (structPtr->field_0->arr[j].groupScheduledAnim != UNION_ROOM_SPAWN_NONE)
         {
-            i = sub_811A748(&structPtr->field_0->arr[j], &structPtr->field_4->arr[0]);
+            i = Findx20Inx1CArray(&structPtr->field_0->arr[j], &structPtr->field_4->arr[0]);
             if (i != 0xFF)
             {
-                if (structPtr->field_0->arr[j].field_1A_0 == 1)
+                if (structPtr->field_0->arr[j].groupScheduledAnim == UNION_ROOM_SPAWN_IN)
                 {
-                    if (sub_811A6DC(&structPtr->field_0->arr[j].unk, &structPtr->field_4->arr[i].unk0))
+                    // New join in queue
+                    if (AreUnionRoomPlayerGnamesDifferent(&structPtr->field_0->arr[j].gname_uname, &structPtr->field_4->arr[i].gname_uname))
                     {
-                        structPtr->field_0->arr[j].unk = structPtr->field_4->arr[i].unk0;
+                        // Just joined, copy their names
+                        structPtr->field_0->arr[j].gname_uname = structPtr->field_4->arr[i].gname_uname;
                         structPtr->field_0->arr[j].field_1B = 0x40;
                         r7 = 1;
                     }
@@ -3472,116 +3604,121 @@ static u8 sub_8119B94(void)
                 }
                 else
                 {
-                    structPtr->field_0->arr[j].field_1A_0 = 1;
+                    // New join, queue them
+                    structPtr->field_0->arr[j].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
                     structPtr->field_0->arr[j].field_1B = 0;
                     r7 = 2;
                 }
                 structPtr->field_0->arr[j].field_18 = 0;
             }
-            else if (structPtr->field_0->arr[j].field_1A_0 != 2)
+            else if (structPtr->field_0->arr[j].groupScheduledAnim != UNION_ROOM_SPAWN_OUT)
             {
+                // Person may have disconnected. Give them 10 seconds.
                 structPtr->field_0->arr[j].field_18++;
                 if (structPtr->field_0->arr[j].field_18 >= 600)
                 {
-                    structPtr->field_0->arr[j].field_1A_0 = 2;
+                    structPtr->field_0->arr[j].groupScheduledAnim = UNION_ROOM_SPAWN_OUT;
                     r7 = 2;
                 }
             }
-            else if (structPtr->field_0->arr[j].field_1A_0 == 2)
+            else if (structPtr->field_0->arr[j].groupScheduledAnim == UNION_ROOM_SPAWN_OUT)
             {
+                // Person dropped. Wait 15 seconds, then remove them.
                 structPtr->field_0->arr[j].field_18++;
                 if (structPtr->field_0->arr[j].field_18 >= 900)
                 {
-                    sub_811A5E4(&structPtr->field_0->arr[j], 1);
+                    BlankUnkStruct_x20Array(&structPtr->field_0->arr[j], 1);
                 }
             }
         }
     }
-    for (i = 0; i < 4; i++)
+
+    // Update the players list
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (sub_811A798(&structPtr->field_0->arr[0], &structPtr->field_4->arr[i], 8) != 0xFF)
+        if (Appendx1Ctox20(&structPtr->field_0->arr[0], &structPtr->field_4->arr[i], UROOM_MAX_GROUP_COUNT) != 0xFF)
             r7 = 1;
     }
 
     return r7;
 }
 
-static void sub_8119D34(u8 taskId)
+static void Task_SearchForChildOrParent(u8 taskId)
 {
     s32 i, j;
-    struct UnkStruct_Shared sp0;
+    struct UnionGnameUnamePair gname_uname;
     struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data;
-    bool8 r4;
+    bool8 parent_child;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        r4 = sub_80FCC3C(&sp0.gname, sp0.playerName, i);
-        if (!sub_8116F28(sp0.gname.unk_0a_0, gTasks[taskId].data[4]))
+        parent_child = LinkRfu_GetNameIfCompatible(&gname_uname.gname, gname_uname.uname, i);
+        if (!IsPartnerActivityAcceptable(gname_uname.gname.activity, gTasks[taskId].data[4]))
         {
-            sp0 = gUnknown_8457034;
+            gname_uname = sUnionGnameUnamePair_Dummy;
         }
-        if (sp0.gname.unk_00.unk_00_0 == 1)
+        if (gname_uname.gname.unk_00.language == LANGUAGE_JAPANESE)
         {
-            sp0 = gUnknown_8457034;
+            gname_uname = sUnionGnameUnamePair_Dummy;
         }
-        if (!r4)
+        if (parent_child == MODE_CHILD)
         {
             for (j = 0; j < i; j++)
             {
-                if (!sub_811A694(&ptr[1]->arr[j].unk0, &sp0))
+                if (!AreGnameUnameDifferent(&ptr[1]->arr[j].gname_uname, &gname_uname))
                 {
-                    sp0 = gUnknown_8457034;
+                    gname_uname = sUnionGnameUnamePair_Dummy;
                 }
             }
-            ptr[1]->arr[i].unk0 = sp0;
-            ptr[1]->arr[i].unk18 = sub_811A694(&ptr[1]->arr[i].unk0, &gUnknown_8457034);
+            ptr[1]->arr[i].gname_uname = gname_uname;
+            ptr[1]->arr[i].active = AreGnameUnameDifferent(&ptr[1]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy);
         }
         else
         {
-            ptr[0]->arr[i].unk0 = sp0;
-            ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034);
+            ptr[0]->arr[i].gname_uname = gname_uname;
+            ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy);
         }
     }
 }
 
-static u8 sub_8119E84(struct UnkStruct_Main4 * a0, struct UnkStruct_Main4 * a1, u32 a2)
+static u8 CreateTask_SearchForChildOrParent(struct UnkStruct_Main4 * main4_parent, struct UnkStruct_Main4 * main4_child, u32 linkGroup)
 {
-    u8 taskId = CreateTask(sub_8119D34, 0);
+    u8 taskId = CreateTask(Task_SearchForChildOrParent, 0);
     struct UnkStruct_Main4 ** data = (void *)gTasks[taskId].data;
-    data[0] = a0;
-    data[1] = a1;
-    gTasks[taskId].data[4] = a2;
+    data[0] = main4_parent;
+    data[1] = main4_child;
+    gTasks[taskId].data[4] = linkGroup;
     return taskId;
 }
 
-static void sub_8119EB8(u8 taskId)
+static void Task_ListenForPartnersWithCompatibleSerialNos(u8 taskId)
 {
     s32 i, j;
     struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        sub_80FCC3C(&ptr[0]->arr[i].unk0.gname, ptr[0]->arr[i].unk0.playerName, i);
-        if (!sub_8116F28(ptr[0]->arr[i].unk0.gname.unk_0a_0, gTasks[taskId].data[2]))
+        LinkRfu_GetNameIfCompatible(&ptr[0]->arr[i].gname_uname.gname, ptr[0]->arr[i].gname_uname.uname, i);
+        if (!IsPartnerActivityAcceptable(ptr[0]->arr[i].gname_uname.gname.activity, gTasks[taskId].data[2]))
         {
-            ptr[0]->arr[i].unk0 = gUnknown_8457034;
+            ptr[0]->arr[i].gname_uname = sUnionGnameUnamePair_Dummy;
         }
         for (j = 0; j < i; j++)
         {
-            if (!sub_811A694(&ptr[0]->arr[j].unk0, &ptr[0]->arr[i].unk0))
+            if (!AreGnameUnameDifferent(&ptr[0]->arr[j].gname_uname, &ptr[0]->arr[i].gname_uname))
             {
-                ptr[0]->arr[i].unk0 = gUnknown_8457034;
+                ptr[0]->arr[i].gname_uname = sUnionGnameUnamePair_Dummy;
             }
         }
-        ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034);
+        ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy);
     }
 }
 
-static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1)
+static bool32 GetGnameWonderFlagByLinkGroup(struct GFtgtGname * gname, s16 linkGroup)
 {
-    if (arg1 == 7)
+    if (linkGroup == LINK_GROUP_WONDER_CARD)
     {
-        if (!arg0->unk_00.unk_00_5)
+        if (!gname->unk_00.hasCard)
         {
             return FALSE;
         }
@@ -3590,9 +3727,9 @@ static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1)
             return TRUE;
         }
     }
-    else if (arg1 == 8)
+    else if (linkGroup == LINK_GROUP_WONDER_NEWS)
     {
-        if (!arg0->unk_00.unk_00_4)
+        if (!gname->unk_00.hasNews)
         {
             return FALSE;
         }
@@ -3607,40 +3744,40 @@ static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1)
     }
 }
 
-static void sub_8119FD8(u8 taskId)
+static void Task_ListenForPartnersWithSerial7F7D(u8 taskId)
 {
     s32 i;
     struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (sub_80FCCF4(&ptr[0]->arr[i].unk0.gname, ptr[0]->arr[i].unk0.playerName, i))
+        if (LinkRfu_GetNameIfSerial7F7D(&ptr[0]->arr[i].gname_uname.gname, ptr[0]->arr[i].gname_uname.uname, i))
         {
-            sub_8119FB0(&ptr[0]->arr[i].unk0.gname, gTasks[taskId].data[2]);
+            GetGnameWonderFlagByLinkGroup(&ptr[0]->arr[i].gname_uname.gname, gTasks[taskId].data[2]);
         }
-        ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034);
+        ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy);
     }
 }
 
-static u8 sub_811A054(struct UnkStruct_Main4 * a0, u32 a1)
+static u8 CreateTask_ListenForPartnersWithCompatibleSerialNos(struct UnkStruct_Main4 * main4, u32 linkGroup)
 {
-    u8 taskId = CreateTask(sub_8119EB8, 0);
+    u8 taskId = CreateTask(Task_ListenForPartnersWithCompatibleSerialNos, 0);
     struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data;
-    ptr[0] = a0;
-    gTasks[taskId].data[2] = a1;
+    ptr[0] = main4;
+    gTasks[taskId].data[2] = linkGroup;
     return taskId;
 }
 
-static u8 sub_811A084(struct UnkStruct_Main4 * a0, u32 a1)
+static u8 CreateTask_ListenForPartnersWithSerial7F7D(struct UnkStruct_Main4 * main4, u32 linkGroup)
 {
-    u8 taskId = CreateTask(sub_8119FD8, 0);
+    u8 taskId = CreateTask(Task_ListenForPartnersWithSerial7F7D, 0);
     struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data;
-    ptr[0] = a0;
-    gTasks[taskId].data[2] = a1;
+    ptr[0] = main4;
+    gTasks[taskId].data[2] = linkGroup;
     return taskId;
 }
 
-static bool32 sub_811A0B4(const u8 *src)
+static bool32 UR_PrintFieldMessage(const u8 *src)
 {
     LoadStdWindowFrameGfx();
     DrawDialogueFrame(0, 1);
@@ -3649,7 +3786,7 @@ static bool32 sub_811A0B4(const u8 *src)
     return FALSE;
 }
 
-static bool32 sub_811A0E0(void)
+static bool32 UR_RunTextPrinters_CheckPrinter0Active(void)
 {
     if (!RunTextPrinters_CheckPrinter0Active())
     {
@@ -3683,31 +3820,31 @@ static bool8 PrintOnTextbox(u8 *textState, const u8 *str)
     return FALSE;
 }
 
-static s8 sub_811A14C(u8 *arg0, bool32 arg1)
+static s8 UnionRoomHandleYesNo(u8 *state_p, bool32 no_draw)
 {
     s8 r1;
 
-    switch (*arg0)
+    switch (*state_p)
     {
     case 0:
-        if (arg1)
+        if (no_draw)
         {
             return -3;
         }
         DisplayYesNoMenuDefaultYes();
-        (*arg0)++;
+        (*state_p)++;
         break;
     case 1:
-        if (arg1)
+        if (no_draw)
         {
             DestroyYesNoMenu();
-            *arg0 = 0;
+            *state_p = 0;
             return -3;
         }
         r1 = Menu_ProcessInputNoWrapClearOnChoose();
         if (r1 == -1 || r1 == 0 || r1 == 1)
         {
-            *arg0 = 0;
+            *state_p = 0;
             return r1;
         }
         break;
@@ -3715,54 +3852,54 @@ static s8 sub_811A14C(u8 *arg0, bool32 arg1)
     return -2;
 }
 
-static u8 sub_811A1AC(const struct WindowTemplate * template)
+static u8 CreateTradeBoardWindow(const struct WindowTemplate * template)
 {
     u8 windowId = AddWindow(template);
     DrawStdWindowFrame(windowId, FALSE);
     FillWindowPixelBuffer(windowId, PIXEL_FILL(15));
-    sub_811A444(windowId, 0, gUnknown_8459378, 8, 1, 6);
+    UR_AddTextPrinterParameterized(windowId, 0, gUnknown_8459378, 8, 1, UR_COLOR_DN5_DN6_LTB);
     PutWindowTilemap(windowId);
     CopyWindowToVram(windowId, 2);
     return windowId;
 }
 
-static void sub_811A1FC(u8 windowId)
+static void DeleteTradeBoardWindow(u8 windowId)
 {
     ClearStdWindowAndFrame(windowId, TRUE);
     RemoveWindow(windowId);
 }
 
-static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate)
+static s32 ListMenuHandler_AllItemsAvailable(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate)
 {
-    s32 r1, r8;
+    s32 input;
 
-    switch (*arg0)
+    switch (*state_p)
     {
     case 0:
-        *arg1 = AddWindow(winTemplate);
-        DrawStdWindowFrame(*arg1, FALSE);
+        *win_id_p = AddWindow(winTemplate);
+        DrawStdWindowFrame(*win_id_p, FALSE);
         gMultiuseListMenuTemplate = *menuTemplate;
-        gMultiuseListMenuTemplate.windowId = *arg1;
-        *arg2 = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
-        CopyWindowToVram(*arg1, TRUE);
-        (*arg0)++;
+        gMultiuseListMenuTemplate.windowId = *win_id_p;
+        *list_menu_id_p = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0);
+        CopyWindowToVram(*win_id_p, TRUE);
+        (*state_p)++;
         break;
     case 1:
-        r8 = ListMenu_ProcessInput(*arg2);
+        input = ListMenu_ProcessInput(*list_menu_id_p);
         if (JOY_NEW(A_BUTTON))
         {
-            DestroyListMenuTask(*arg2, NULL, NULL);
-            ClearStdWindowAndFrame(*arg1, TRUE);
-            RemoveWindow(*arg1);
-            *arg0 = 0;
-            return r8;
+            DestroyListMenuTask(*list_menu_id_p, NULL, NULL);
+            ClearStdWindowAndFrame(*win_id_p, TRUE);
+            RemoveWindow(*win_id_p);
+            *state_p = 0;
+            return input;
         }
         else if (JOY_NEW(B_BUTTON))
         {
-            DestroyListMenuTask(*arg2, NULL, NULL);
-            ClearStdWindowAndFrame(*arg1, TRUE);
-            RemoveWindow(*arg1);
-            *arg0 = 0;
+            DestroyListMenuTask(*list_menu_id_p, NULL, NULL);
+            ClearStdWindowAndFrame(*win_id_p, TRUE);
+            RemoveWindow(*win_id_p);
+            *state_p = 0;
             return -2;
         }
         break;
@@ -3771,46 +3908,46 @@ static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate
     return -1;
 }
 
-static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * arg6)
+static s32 TradeBoardMenuHandler(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, u8 *trade_board_win_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * traders)
 {
     s32 input;
     s32 r4;
 
-    switch (*arg0)
+    switch (*state_p)
     {
     case 0:
-        *arg3 = sub_811A1AC(&gUnknown_8456F1C);
-        *arg1 = AddWindow(winTemplate);
-        DrawStdWindowFrame(*arg1, FALSE);
+        *trade_board_win_id_p = CreateTradeBoardWindow(&sTradeBoardWindowTemplate);
+        *win_id_p = AddWindow(winTemplate);
+        DrawStdWindowFrame(*win_id_p, FALSE);
         gMultiuseListMenuTemplate = *menuTemplate;
-        gMultiuseListMenuTemplate.windowId = *arg1;
-        *arg2 = ListMenuInit(&gMultiuseListMenuTemplate, 0, 1);
-        CopyWindowToVram(*arg1, TRUE);
-        (*arg0)++;
+        gMultiuseListMenuTemplate.windowId = *win_id_p;
+        *list_menu_id_p = ListMenuInit(&gMultiuseListMenuTemplate, 0, 1);
+        CopyWindowToVram(*win_id_p, TRUE);
+        (*state_p)++;
         break;
     case 1:
-        input = ListMenu_ProcessInput(*arg2);
+        input = ListMenu_ProcessInput(*list_menu_id_p);
         if (JOY_NEW(A_BUTTON | B_BUTTON))
         {
-            if (input == 8 || JOY_NEW(B_BUTTON))
+            if (input == UROOM_MAX_GROUP_COUNT || JOY_NEW(B_BUTTON))
             {
-                DestroyListMenuTask(*arg2, NULL, NULL);
-                ClearStdWindowAndFrame(*arg1, TRUE);
-                RemoveWindow(*arg1);
-                sub_811A1FC(*arg3);
-                *arg0 = 0;
+                DestroyListMenuTask(*list_menu_id_p, NULL, NULL);
+                ClearStdWindowAndFrame(*win_id_p, TRUE);
+                RemoveWindow(*win_id_p);
+                DeleteTradeBoardWindow(*trade_board_win_id_p);
+                *state_p = 0;
                 return -2;
             }
             else
             {
-                r4 = sub_811AD7C(arg6->arr, input);
+                r4 = GetIndexOfNthTradeBoardOffer(traders->arr, input);
                 if (r4 >= 0)
                 {
-                    DestroyListMenuTask(*arg2, NULL, NULL);
-                    ClearStdWindowAndFrame(*arg1, TRUE);
-                    RemoveWindow(*arg1);
-                    sub_811A1FC(*arg3);
-                    *arg0 = 0;
+                    DestroyListMenuTask(*list_menu_id_p, NULL, NULL);
+                    ClearStdWindowAndFrame(*win_id_p, TRUE);
+                    RemoveWindow(*win_id_p);
+                    DeleteTradeBoardWindow(*trade_board_win_id_p);
+                    *state_p = 0;
                     return r4;
                 }
                 else
@@ -3825,20 +3962,20 @@ static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct Wind
     return -1;
 }
 
-static void sub_811A3F8(void)
+static void UR_BlankBg0(void)
 {
     FillBgTilemapBufferRect(0, 0, 0, 0, 32, 32, 0);
     CopyBgTilemapBufferToVram(0);
 }
 
-static void sub_811A41C(void)
+static void JoinGroup_BlankBg0AndEnableScriptContexts(void)
 {
     FillBgTilemapBufferRect(0, 0, 0, 0, 32, 32, 0);
     CopyBgTilemapBufferToVram(0);
     EnableBothScriptContexts();
 }
 
-static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx)
+static void UR_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx)
 {
     struct TextPrinterTemplate printerTemplate;
 
@@ -3854,100 +3991,100 @@ static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 co
     gTextFlags.useAlternateDownArrow = FALSE;
     switch (colorIdx)
     {
-    case 0:
+    case UR_COLOR_DKE_WHT_LTE:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 2;
-        printerTemplate.bgColor = 1;
-        printerTemplate.shadowColor = 3;
+        printerTemplate.fgColor = TEXT_COLOR_DARK_GREY;
+        printerTemplate.bgColor = TEXT_COLOR_WHITE;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY;
         break;
-    case 1:
+    case UR_COLOR_RED_WHT_LTR:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 4;
-        printerTemplate.bgColor = 1;
-        printerTemplate.shadowColor = 5;
+        printerTemplate.fgColor = TEXT_COLOR_RED;
+        printerTemplate.bgColor = TEXT_COLOR_WHITE;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_RED;
         break;
-    case 2:
+    case UR_COLOR_GRN_WHT_LTG:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 6;
-        printerTemplate.bgColor = 1;
-        printerTemplate.shadowColor = 7;
+        printerTemplate.fgColor = TEXT_COLOR_GREEN;
+        printerTemplate.bgColor = TEXT_COLOR_WHITE;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREEN;
         break;
-    case 3:
+    case UR_COLOR_WHT_WHT_LTE:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 1;
-        printerTemplate.bgColor = 1;
-        printerTemplate.shadowColor = 3;
+        printerTemplate.fgColor = TEXT_COLOR_WHITE;
+        printerTemplate.bgColor = TEXT_COLOR_WHITE;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY;
         break;
-    case 4:
+    case UR_COLOR_WHT_DKE_LTE:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 1;
-        printerTemplate.bgColor = 2;
-        printerTemplate.shadowColor = 3;
+        printerTemplate.fgColor = TEXT_COLOR_WHITE;
+        printerTemplate.bgColor = TEXT_COLOR_DARK_GREY;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY;
         break;
-    case 5:
+    case UR_COLOR_GRN_DN6_LTB:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 7;
-        printerTemplate.bgColor = 15;
-        printerTemplate.shadowColor = 9;
+        printerTemplate.fgColor = TEXT_COLOR_LIGHT_GREEN;
+        printerTemplate.bgColor = TEXT_DYNAMIC_COLOR_6;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_BLUE;
         break;
-    case 6:
+    case UR_COLOR_DN5_DN6_LTB:
         printerTemplate.letterSpacing = 0;
         printerTemplate.lineSpacing = 0;
-        printerTemplate.fgColor = 14;
-        printerTemplate.bgColor = 15;
-        printerTemplate.shadowColor = 9;
+        printerTemplate.fgColor = TEXT_DYNAMIC_COLOR_5;
+        printerTemplate.bgColor = TEXT_DYNAMIC_COLOR_6;
+        printerTemplate.shadowColor = TEXT_COLOR_LIGHT_BLUE;
         break;
     }
 
     AddTextPrinter(&printerTemplate, 0xFF, NULL);
 }
 
-static void sub_811A5E4(struct UnkStruct_x20 * arg0, u8 count)
+static void BlankUnkStruct_x20Array(struct UnkStruct_x20 * x20arr, u8 count)
 {
     s32 i;
 
     for (i = 0; i < count; i++)
     {
-        arg0[i].unk = gUnknown_8457034;
-        arg0[i].field_18 = 0xFF;
-        arg0[i].field_1A_0 = 0;
-        arg0[i].field_1A_1 = 0;
-        arg0[i].field_1B = 0;
+        x20arr[i].gname_uname = sUnionGnameUnamePair_Dummy;
+        x20arr[i].field_18 = 0xFF;
+        x20arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_NONE;
+        x20arr[i].field_1A_1 = FALSE;
+        x20arr[i].field_1B = 0;
     }
 }
 
-static void sub_811A650(struct UnkStruct_x1C * arg0, u8 count)
+static void BlankUnkStruct_x1CArray(struct UnkStruct_x1C * x1Carr, u8 count)
 {
     s32 i;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        arg0[i].unk0 = gUnknown_8457034;
-        arg0[i].unk18 = 0;
+        x1Carr[i].gname_uname = sUnionGnameUnamePair_Dummy;
+        x1Carr[i].active = FALSE;
     }
 }
 
-static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_Shared * arg1)
+static bool8 AreGnameUnameDifferent(struct UnionGnameUnamePair * left, const struct UnionGnameUnamePair * right)
 {
     s32 i;
 
     for (i = 0; i < 2; i++)
     {
-        if (arg0->gname.unk_00.playerTrainerId[i] != arg1->gname.unk_00.playerTrainerId[i])
+        if (left->gname.unk_00.playerTrainerId[i] != right->gname.unk_00.playerTrainerId[i])
         {
             return TRUE;
         }
     }
 
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < RFU_USER_NAME_LENGTH; i++)
     {
-        if (arg0->playerName[i] != arg1->playerName[i])
+        if (left->uname[i] != right->uname[i])
         {
             return TRUE;
         }
@@ -3956,34 +4093,34 @@ static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_
     return FALSE;
 }
 
-static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Shared * arg1)
+static bool32 AreUnionRoomPlayerGnamesDifferent(struct UnionGnameUnamePair * left, struct UnionGnameUnamePair * right)
 {
     s32 i;
 
-    if (arg0->gname.unk_0a_0 != arg1->gname.unk_0a_0)
+    if (left->gname.activity != right->gname.activity)
     {
         return TRUE;
     }
 
-    if (arg0->gname.unk_0a_7 != arg1->gname.unk_0a_7)
+    if (left->gname.started != right->gname.started)
     {
         return TRUE;
     }
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (arg0->gname.unk_04[i] != arg1->gname.unk_04[i])
+        if (left->gname.child_sprite_gender[i] != right->gname.child_sprite_gender[i])
         {
             return TRUE;
         }
     }
 
-    if (arg0->gname.species != arg1->gname.species)
+    if (left->gname.species != right->gname.species)
     {
         return TRUE;
     }
 
-    if (arg0->gname.type != arg1->gname.type)
+    if (left->gname.type != right->gname.type)
     {
         return TRUE;
     }
@@ -3991,38 +4128,38 @@ static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Share
     return FALSE;
 }
 
-static u32 sub_811A748(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1)
+static u32 Findx20Inx1CArray(struct UnkStruct_x20 * x20, struct UnkStruct_x1C * x1Carr)
 {
     u8 result = 0xFF;
     s32 i;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (arg1[i].unk18 && !sub_811A694(&arg0->unk, &arg1[i].unk0))
+        if (x1Carr[i].active && !AreGnameUnameDifferent(&x20->gname_uname, &x1Carr[i].gname_uname))
         {
             result = i;
-            arg1[i].unk18 = FALSE;
+            x1Carr[i].active = FALSE;
         }
     }
 
     return result;
 }
 
-static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1, u8 arg2)
+static u8 Appendx1Ctox20(struct UnkStruct_x20 * x20arr, struct UnkStruct_x1C * x1C, u8 count)
 {
     s32 i;
 
-    if (arg1->unk18)
+    if (x1C->active)
     {
-        for (i = 0; i < arg2; i++)
+        for (i = 0; i < count; i++)
         {
-            if (arg0[i].field_1A_0 == 0)
+            if (x20arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_NONE)
             {
-                arg0[i].unk = arg1->unk0;
-                arg0[i].field_18 = 0;
-                arg0[i].field_1A_0 = 1;
-                arg0[i].field_1B = 64;
-                arg1->unk18 = FALSE;
+                x20arr[i].gname_uname = x1C->gname_uname;
+                x20arr[i].field_18 = 0;
+                x20arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_IN;
+                x20arr[i].field_1B = 0x40;
+                x1C->active = FALSE;
                 return i;
             }
         }
@@ -4031,47 +4168,47 @@ static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1,
     return 0xFF;
 }
 
-static void sub_811A81C(u8 arg0, u8 arg1, u8 arg2, struct UnkStruct_x20 * arg3, u8 arg4, u8 id)
+static void PrintUnionRoomGroupOnWindow(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id)
 {
-    u8 r2;
-    u8 sp0[6];
-    u8 sp10[30];
+    u8 activity;
+    u8 id_str[6];
+    u8 uname[30];
 
     ConvertIntToDecimalStringN(gStringVar4, id + 1, STR_CONV_MODE_LEADING_ZEROS, 2);
     StringAppend(gStringVar4, gUnknown_84571B0);
-    sub_811A444(arg0, 0, gStringVar4, arg1, arg2, 0);
-    arg1 += 18;
-    r2 = arg3->unk.gname.unk_0a_0;
-    if (arg3->field_1A_0 == 1 && !(r2 & 0x40))
+    UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, UR_COLOR_DKE_WHT_LTE);
+    x += 18;
+    activity = group->gname_uname.gname.activity;
+    if (group->groupScheduledAnim == UNION_ROOM_SPAWN_IN && !(activity & IN_UNION_ROOM))
     {
-        IntlConvPartnerUname(sp10, *arg3);
-        sub_811A444(arg0, 2, sp10, arg1, arg2, arg4);
-        ConvertIntToDecimalStringN(sp0, arg3->unk.gname.unk_00.playerTrainerId[0] | (arg3->unk.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5);
+        IntlConvPartnerUname(uname, *group);
+        UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx);
+        ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5);
         StringCopy(gStringVar4, gUnknown_84571B4);
-        StringAppend(gStringVar4, sp0);
-        arg1 += 77;
-        sub_811A444(arg0, 0, gStringVar4, arg1, arg2, arg4);
+        StringAppend(gStringVar4, id_str);
+        x += 77;
+        UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, colorIdx);
     }
 }
 
-static void sub_811A910(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * arg3, u8 arg4, u8 id)
+static void PrintGroupMemberCandidateOnWindowWithColor(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id)
 {
-    u8 sp0[6];
-    u8 sp10[30];
+    u8 id_str[6];
+    u8 uname[30];
 
-    if (arg3->field_1A_0 == 1)
+    if (group->groupScheduledAnim == UNION_ROOM_SPAWN_IN)
     {
-        IntlConvPartnerUname(sp10, *arg3);
-        sub_811A444(windowId, 2, sp10, x, y, arg4);
-        ConvertIntToDecimalStringN(sp0, arg3->unk.gname.unk_00.playerTrainerId[0] | (arg3->unk.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5);
+        IntlConvPartnerUname(uname, *group);
+        UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx);
+        ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5);
         StringCopy(gStringVar4, gUnknown_84571B4);
-        StringAppend(gStringVar4, sp0);
+        StringAppend(gStringVar4, id_str);
         x += 71;
-        sub_811A444(windowId, 0, gStringVar4, x, y, arg4);
+        UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, colorIdx);
     }
 }
 
-static bool32 sub_811A9B8(void)
+static bool32 PlayerIsTalkingToUnionRoomAide(void)
 {
     s16 x, y;
     GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
@@ -4091,72 +4228,77 @@ static bool32 sub_811A9B8(void)
     return FALSE;
 }
 
-static u32 sub_811A9FC(s32 arg0)
+static u32 GetResponseIdx_InviteToURoomActivity(s32 activity)
 {
-    switch (arg0)
+    switch (activity)
     {
-    case 5:
+    case ACTIVITY_CHAT:
         return 1;
-    case 4:
+    case ACTIVITY_TRADE:
         return 2;
-    case 8:
+    case ACTIVITY_CARD:
         return 3;
-    case 3:
+    case ACTIVITY_MLTBATTLE:
     default:
         return 0;
     }
 }
 
-static u32 sub_811AA24(struct UnkStruct_x20 * arg0)
+static u32 ConvPartnerUnameAndGetWhetherMetAlready(struct UnkStruct_x20 * x20)
 {
     u8 sp0[30];
-    IntlConvPartnerUname(sp0, *arg0);
-    return PlayerHasMetTrainerBefore(ReadAsU16(arg0->unk.gname.unk_00.playerTrainerId), sp0);
+    IntlConvPartnerUname(sp0, *x20);
+    return PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), sp0);
 }
 
-static s32 sub_811AA5C(struct UnkStruct_Main0 * arg0, u8 arg1, u8 arg2, u32 playerGender)
+static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, u8 overrideGender, u8 playerIdx, u32 playerGender)
 {
-    bool32 r2;
+    bool32 metBefore;
 
-    struct UnkStruct_x20 * r5 = &arg0->arr[arg2];
+    struct UnkStruct_x20 * x20 = &main0->arr[playerIdx];
 
-    if (!r5->unk.gname.unk_0a_7 && arg1 == 0)
+    if (!x20->gname_uname.gname.started && overrideGender == 0)
     {
-        IntlConvPartnerUname(gStringVar1, *r5);
-        r2 = PlayerHasMetTrainerBefore(ReadAsU16(r5->unk.gname.unk_00.playerTrainerId), gStringVar1);
-        if (r5->unk.gname.unk_0a_0 == 0x45)
+        IntlConvPartnerUname(gStringVar1, *x20);
+        metBefore = PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), gStringVar1);
+        if (x20->gname_uname.gname.activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
         {
-            StringExpandPlaceholders(gStringVar4, gUnknown_8457F80[r2][playerGender]);
+            StringExpandPlaceholders(gStringVar4, gUnknown_8457F80[metBefore][playerGender]);
             return 2;
         }
         else
         {
-            sub_811A0B4(gUnknown_8457A34[r2]);
+            UR_PrintFieldMessage(gURText_PleaseWaitMsgs[metBefore]);
             return 1;
         }
     }
     else
     {
-        IntlConvPartnerUname(gStringVar1, *r5);
-        if (arg1 != 0)
+        IntlConvPartnerUname(gStringVar1, *x20);
+        if (overrideGender != 0)
         {
-            playerGender = (r5->unk.gname.unk_00.playerTrainerId[arg1 + 1] >> 3) & 1;
+            playerGender = (x20->gname_uname.gname.unk_00.playerTrainerId[overrideGender + 1] >> 3) & 1;
         }
-        switch (r5->unk.gname.unk_0a_0 & 0x3F)
+        switch (x20->gname_uname.gname.activity & 0x3F)
         {
-        case 1:
+        case ACTIVITY_BATTLE:
+            // Battling
             StringExpandPlaceholders(gStringVar4, gUnknown_8458758[playerGender][Random() % 4]);
             break;
-        case 4:
+        case ACTIVITY_TRADE:
+            // Trading
             StringExpandPlaceholders(gStringVar4, gUnknown_8458A78[playerGender][Random() % 2]);
             break;
-        case 5:
+        case ACTIVITY_CHAT:
+            // Chatting
             StringExpandPlaceholders(gStringVar4, gUnknown_84588BC[playerGender][Random() % 4]);
             break;
-        case 8:
+        case ACTIVITY_CARD:
+            // Sharing cards
             StringExpandPlaceholders(gStringVar4, gUnknown_84589AC[playerGender][Random() % 2]);
             break;
         default:
+            // Unknown
             StringExpandPlaceholders(gStringVar4, gUnknown_8457F90);
             break;
         }
@@ -4169,73 +4311,73 @@ static void nullsub_92(u8 windowId, s32 itemId, u8 y)
 
 }
 
-static void sub_811ABE4(u8 windowId, u8 y, struct GFtgtGname * gname, const u8 * uname, u8 colorIdx)
+static void TradeBoardPrintItemInfo(u8 windowId, u8 y, struct GFtgtGname * gname, const u8 * uname, u8 colorIdx)
 {
     u8 level_t[4];
     u16 species = gname->species;
     u8 type = gname->type;
     u8 level = gname->level;
 
-    sub_811A444(windowId, 2, uname, 8, y, colorIdx);
+    UR_AddTextPrinterParameterized(windowId, 2, uname, 8, y, colorIdx);
     if (species == SPECIES_EGG)
     {
-        sub_811A444(windowId, 2, gUnknown_8458FBC, 0x44, y, colorIdx);
+        UR_AddTextPrinterParameterized(windowId, 2, gText_EggTrade, 0x44, y, colorIdx);
     }
     else
     {
         BlitMoveInfoIcon(windowId, type + 1, 0x44, y);
-        sub_811A444(windowId, 2, gSpeciesNames[species], 0x76, y, colorIdx);
+        UR_AddTextPrinterParameterized(windowId, 2, gSpeciesNames[species], 0x76, y, colorIdx);
         ConvertIntToDecimalStringN(level_t, level, STR_CONV_MODE_LEFT_ALIGN, 3);
-        sub_811A444(windowId, 2, level_t, GetStringRightAlignXOffset(2, level_t, 218), y, colorIdx);
+        UR_AddTextPrinterParameterized(windowId, 2, level_t, GetStringRightAlignXOffset(2, level_t, 218), y, colorIdx);
     }
 }
 
-static void sub_811ACA4(u8 windowId, s32 itemId, u8 y)
+static void TradeBoardListMenuItemPrintFunc(u8 windowId, s32 itemId, u8 y)
 {
     struct UnkStruct_Leader * leader = sUnionRoomMain.leader;
     struct GFtgtGname * rfu;
     s32 i, j;
-    u8 uname[8];
+    u8 uname[RFU_USER_NAME_LENGTH];
 
-    if (itemId == -3 && y == gUnknown_8456F7C.upText_Y)
+    if (itemId == -3 && y == sTradeBoardListMenuTemplate.upText_Y)
     {
-        rfu = sub_80F9800();
+        rfu = GetHostRFUtgtGname();
         if (rfu->species != SPECIES_NONE)
         {
-            sub_811ABE4(windowId, y, rfu, gSaveBlock2Ptr->playerName, 5);
+            TradeBoardPrintItemInfo(windowId, y, rfu, gSaveBlock2Ptr->playerName, 5);
         }
     }
     else
     {
         j = 0;
-        for (i = 0; i < 8; i++)
+        for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++)
         {
-            if (leader->field_0->arr[i].field_1A_0 == 1 && leader->field_0->arr[i].unk.gname.species != SPECIES_NONE)
+            if (leader->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && leader->field_0->arr[i].gname_uname.gname.species != SPECIES_NONE)
             {
                 j++;
             }
             if (j == itemId + 1)
             {
                 IntlConvPartnerUname(uname, leader->field_0->arr[i]);
-                sub_811ABE4(windowId, y, &leader->field_0->arr[i].unk.gname, uname, 6);
+                TradeBoardPrintItemInfo(windowId, y, &leader->field_0->arr[i].gname_uname.gname, uname, 6);
                 break;
             }
         }
     }
 }
 
-static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1)
+static s32 GetIndexOfNthTradeBoardOffer(struct UnkStruct_x20 * x20, s32 n)
 {
     s32 i;
     s32 j = 0;
 
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++)
     {
-        if (arg[i].field_1A_0 == 1 && arg[i].unk.gname.species != SPECIES_NONE)
+        if (x20[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && x20[i].gname_uname.gname.species != SPECIES_NONE)
         {
             j++;
         }
-        if (j == arg1 + 1)
+        if (j == n + 1)
         {
             return i;
         }
@@ -4244,12 +4386,12 @@ static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1)
     return -1;
 }
 
-static s32 GetUnionRoomPlayerGender(s32 arg1, struct UnkStruct_Main0 * arg0)
+static s32 GetUnionRoomPlayerGender(s32 playerIdx, struct UnkStruct_Main0 * main0)
 {
-    return arg0->arr[arg1].unk.gname.playerGender;
+    return main0->arr[playerIdx].gname_uname.gname.playerGender;
 }
 
-static s32 sub_811ADD0(u32 type, u32 species)
+static s32 IsRequestedTypeAndSpeciesInPlayerParty(u32 type, u32 species)
 {
     s32 i;
 
@@ -4260,10 +4402,10 @@ static s32 sub_811ADD0(u32 type, u32 species)
             species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2);
             if (species == SPECIES_EGG)
             {
-                return 0;
+                return UR_TRADE_MATCH;
             }
         }
-        return 2;
+        return UR_TRADE_NOEGG;
     }
     else
     {
@@ -4272,77 +4414,77 @@ static s32 sub_811ADD0(u32 type, u32 species)
             species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2);
             if (gBaseStats[species].type1 == type || gBaseStats[species].type2 == type)
             {
-                return 0;
+                return UR_TRADE_MATCH;
             }
         }
-        return 1;
+        return UR_TRADE_NOTYPE;
     }
 }
 
-static void sub_811AE68(u8 *dst, s32 arg1, u32 playerGender)
+static void GetURoomActivityRejectMsg(u8 *dst, s32 activity, u32 playerGender)
 {
-    switch (arg1)
+    switch (activity)
     {
-    case 0x41:
+    case ACTIVITY_BATTLE | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8458314[playerGender]);
         break;
-    case 0x45:
+    case ACTIVITY_CHAT | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_84585E8[playerGender]);
         break;
-    case 0x44:
+    case ACTIVITY_TRADE | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8458F9C);
         break;
-    case 0x48:
+    case ACTIVITY_CARD | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_84583B4[playerGender]);
         break;
     }
 }
 
-static void sub_811AECC(u8 *dst, u8 arg1)
+static void GetURoomActivityStartMsg(u8 *dst, u8 activity)
 {
     u8 mpId = GetMultiplayerId();
     u8 gender = gLinkPlayers[mpId ^ 1].gender;
 
-    switch (arg1)
+    switch (activity)
     {
-    case 0x41:
+    case ACTIVITY_BATTLE | IN_UNION_ROOM:
         StringCopy(dst, gUnknown_8458230[mpId][gender][0]);
         break;
-    case 0x44:
+    case ACTIVITY_TRADE | IN_UNION_ROOM:
         StringCopy(dst, gUnknown_8458230[mpId][gender][2]);
         break;
-    case 0x45:
+    case ACTIVITY_CHAT | IN_UNION_ROOM:
         StringCopy(dst, gUnknown_8458230[mpId][gender][1]);
         break;
     }
 }
 
-static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * arg3)
+static s32 GetChatLeaderActionRequestMessage(u8 *dst, u32 gender, u16 *activity_p, struct UnkStruct_URoom * arg3)
 {
     s32 result = 0;
     u16 species = SPECIES_NONE;
     s32 i;
 
-    switch (arg2[0])
+    switch (activity_p[0])
     {
-    case 0x41:
+    case ACTIVITY_BATTLE | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8457CA4);
         result = 1;
         break;
-    case 0x45:
+    case ACTIVITY_CHAT | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8457CF8);
         result = 1;
         break;
-    case 0x44:
-        ConvertIntToDecimalStringN(arg3->field_58[0], sUnionRoomTrade.playerLevel, STR_CONV_MODE_LEFT_ALIGN, 3);
-        StringCopy(arg3->field_58[1], gSpeciesNames[sUnionRoomTrade.playerSpecies]);
-        for (i = 0; i < 4; i++)
+    case ACTIVITY_TRADE | IN_UNION_ROOM:
+        ConvertIntToDecimalStringN(arg3->activityRequestStrbufs[0], sUnionRoomTrade.playerLevel, STR_CONV_MODE_LEFT_ALIGN, 3);
+        StringCopy(arg3->activityRequestStrbufs[1], gSpeciesNames[sUnionRoomTrade.playerSpecies]);
+        for (i = 0; i < RFU_CHILD_MAX; i++)
         {
-            if (gRfuLinkStatus->partner[i].serialNo == 2)
+            if (gRfuLinkStatus->partner[i].serialNo == 0x0002)
             {
-                ConvertIntToDecimalStringN(arg3->field_58[2], arg2[2], STR_CONV_MODE_LEFT_ALIGN, 3);
-                StringCopy(arg3->field_58[3], gSpeciesNames[arg2[1]]);
-                species = arg2[1];
+                ConvertIntToDecimalStringN(arg3->activityRequestStrbufs[2], activity_p[2], STR_CONV_MODE_LEFT_ALIGN, 3);
+                StringCopy(arg3->activityRequestStrbufs[3], gSpeciesNames[activity_p[1]]);
+                species = activity_p[1];
                 break;
             }
         }
@@ -4352,19 +4494,20 @@ static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom *
         }
         else
         {
-            for (i = 0; i < 4; i++)
+            for (i = 0; i < RFU_CHILD_MAX; i++)
             {
-                DynamicPlaceholderTextUtil_SetPlaceholderPtr(i, arg3->field_58[i]);
+                DynamicPlaceholderTextUtil_SetPlaceholderPtr(i, arg3->activityRequestStrbufs[i]);
             }
             DynamicPlaceholderTextUtil_ExpandPlaceholders(dst, gUnknown_8457D44);
         }
         result = 1;
         break;
-    case 0x48:
+    case ACTIVITY_CARD | IN_UNION_ROOM:
         StringExpandPlaceholders(dst, gUnknown_8457C48);
         result = 1;
         break;
-    case 0x40:
+    case IN_UNION_ROOM:
+        // Chat dropped
         StringExpandPlaceholders(dst, gUnknown_8457E0C);
         result = 2;
         break;
@@ -4373,18 +4516,18 @@ static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom *
     return result;
 }
 
-static bool32 sub_811B0A4(struct UnkStruct_URoom * arg0)
+static bool32 PollPartnerYesNoResponse(struct UnkStruct_URoom * uroom)
 {
     if (gRecvCmds[0][1] != 0)
     {
-        if (gRecvCmds[0][1] == 0x51)
+        if (gRecvCmds[0][1] == (ACTIVITY_ACCEPT | IN_UNION_ROOM))
         {
-            arg0->field_98 = 0x51;
+            uroom->partnerYesNoResponse = ACTIVITY_ACCEPT | IN_UNION_ROOM;
             return TRUE;
         }
-        else if (gRecvCmds[0][1] == 0x52)
+        else if (gRecvCmds[0][1] == (ACTIVITY_DECLINE | IN_UNION_ROOM))
         {
-            arg0->field_98 = 0x52;
+            uroom->partnerYesNoResponse = ACTIVITY_DECLINE | IN_UNION_ROOM;
             return TRUE;
         }
     }
@@ -4418,16 +4561,16 @@ static bool32 HasAtLeastTwoMonsOfLevel30OrLower(void)
         return FALSE;
 }
 
-static void ResetUnionRoomTrade(struct UnionRoomTrade * arg0)
+static void ResetUnionRoomTrade(struct UnionRoomTrade * uroomTrade)
 {
-    arg0->field_0 = 0;
-    arg0->type = 0;
-    arg0->playerPersonality = 0;
-    arg0->playerSpecies = 0;
-    arg0->playerLevel = 0;
-    arg0->species = 0;
-    arg0->level = 0;
-    arg0->personality = 0;
+    uroomTrade->field_0 = 0;
+    uroomTrade->type = 0;
+    uroomTrade->playerPersonality = 0;
+    uroomTrade->playerSpecies = 0;
+    uroomTrade->playerLevel = 0;
+    uroomTrade->species = 0;
+    uroomTrade->level = 0;
+    uroomTrade->personality = 0;
 }
 
 void Script_ResetUnionRoomTrade(void)
@@ -4494,26 +4637,26 @@ static u32 GetPartyPositionOfRegisteredMon(struct UnionRoomTrade * trade, u8 mul
     return response;
 }
 
-static void sub_811B258(bool32 arg0)
+static void HandleCancelTrade(bool32 unlockObjs)
 {
-    sub_811A3F8();
+    UR_BlankBg0();
     ScriptContext2_Disable();
-    sub_80696F0();
-    gUnknown_203B058 = 0;
-    if (arg0)
+    UnionRoom_UnlockPlayerAndChatPartner();
+    sPlayerCurrActivity = 0;
+    if (unlockObjs)
     {
-        sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
-        sub_80FB008(0x40, 0, 0);
+        RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel);
+        UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE);
     }
 }
 
-static void sub_811B298(void)
+static void UR_EnableScriptContext2AndFreezeObjectEvents(void)
 {
     ScriptContext2_Enable();
     ScriptFreezeObjectEvents();
 }
 
-static u8 sub_811B2A8(s32 linkPlayer)
+static u8 GetSinglePartnerSpriteGenderParam(s32 linkPlayer)
 {
     u8 retval = 0x80;
     retval |= gLinkPlayers[linkPlayer].gender << 3;
@@ -4521,17 +4664,17 @@ static u8 sub_811B2A8(s32 linkPlayer)
     return retval;
 }
 
-static u8 sub_811B2D8(struct UnkStruct_URoom * arg0)
+static u8 GetActivePartnerSpriteGenderParam(struct UnkStruct_URoom * uroom)
 {
     u8 retVal = 0x80;
     u8 i;
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < RFU_CHILD_MAX; i++)
     {
-        if (arg0->field_C->arr[i].unk18)
+        if (uroom->field_C->arr[i].active)
         {
-            retVal |= arg0->field_C->arr[i].unk0.gname.playerGender << 3;
-            retVal |= arg0->field_C->arr[i].unk0.gname.unk_00.playerTrainerId[0] & 7;
+            retVal |= uroom->field_C->arr[i].gname_uname.gname.playerGender << 3;
+            retVal |= uroom->field_C->arr[i].gname_uname.gname.unk_00.playerTrainerId[0] & 7;
             break;
         }
     }
@@ -4539,7 +4682,7 @@ static u8 sub_811B2D8(struct UnkStruct_URoom * arg0)
     return retVal;
 }
 
-static void sub_811B31C(u8 *unused, struct UnkStruct_URoom * arg1, bool8 arg2)
+static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uroom, bool8 parent_child)
 {
     struct TrainerCard * trainerCard = &gTrainerCards[GetMultiplayerId() ^ 1];
     s32 i;
@@ -4547,61 +4690,61 @@ static void sub_811B31C(u8 *unused, struct UnkStruct_URoom * arg1, bool8 arg2)
 
     DynamicPlaceholderTextUtil_Reset();
 
-    StringCopy(arg1->trainerCardStrbufs[0], gTrainerClassNames[sub_80447F0()]);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, arg1->trainerCardStrbufs[0]);
+    StringCopy(uroom->trainerCardStrbufs[0], gTrainerClassNames[sub_80447F0()]);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]);
 
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, trainerCard->playerName);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, trainerCard->rse.playerName);
 
-    StringCopy(arg1->field_174, gUnknown_84594B0[trainerCard->stars]);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, arg1->field_174);
+    StringCopy(uroom->field_174, gUnknown_84594B0[trainerCard->rse.stars]);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->field_174);
 
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[2], trainerCard->caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, arg1->trainerCardStrbufs[2]);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->rse.caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]);
 
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[3], trainerCard->playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3);
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[4], trainerCard->playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, arg1->trainerCardStrbufs[3]);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(5, arg1->trainerCardStrbufs[4]);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[3], trainerCard->rse.playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[4], trainerCard->rse.playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, uroom->trainerCardStrbufs[3]);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(5, uroom->trainerCardStrbufs[4]);
 
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_84594C4);
-    StringCopy(gStringVar4, arg1->field_1A4);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_84594C4);
+    StringCopy(gStringVar4, uroom->field_1A4);
 
-    n = trainerCard->linkBattleWins;
+    n = trainerCard->rse.linkBattleWins;
     if (n > 9999)
     {
         n = 9999;
     }
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[0], n, STR_CONV_MODE_LEFT_ALIGN, 4);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, arg1->trainerCardStrbufs[0]);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[0], n, STR_CONV_MODE_LEFT_ALIGN, 4);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]);
 
-    n = trainerCard->linkBattleLosses;
+    n = trainerCard->rse.linkBattleLosses;
     if (n > 9999)
     {
         n = 9999;
     }
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[1], n, STR_CONV_MODE_LEFT_ALIGN, 4);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, arg1->trainerCardStrbufs[1]);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[1], n, STR_CONV_MODE_LEFT_ALIGN, 4);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->trainerCardStrbufs[1]);
 
-    ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[2], trainerCard->pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, arg1->trainerCardStrbufs[2]);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->rse.pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]);
 
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < TRAINER_CARD_PROFILE_LENGTH; i++)
     {
-        CopyEasyChatWord(arg1->trainerCardStrbufs[i + 3], trainerCard->var_28[i]);
-        DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, arg1->trainerCardStrbufs[i + 3]);
+        CopyEasyChatWord(uroom->trainerCardStrbufs[i + 3], trainerCard->rse.easyChatProfile[i]);
+        DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, uroom->trainerCardStrbufs[i + 3]);
     }
 
-    DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459504);
-    StringAppend(gStringVar4, arg1->field_1A4);
+    DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459504);
+    StringAppend(gStringVar4, uroom->field_1A4);
 
-    if (arg2 == TRUE)
+    if (parent_child == MODE_PARENT)
     {
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459588);
-        StringAppend(gStringVar4, arg1->field_1A4);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459588);
+        StringAppend(gStringVar4, uroom->field_1A4);
     }
-    else if (arg2 == FALSE)
+    else if (parent_child == MODE_CHILD)
     {
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459580[trainerCard->gender]);
-        StringAppend(gStringVar4, arg1->field_1A4);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459580[trainerCard->rse.gender]);
+        StringAppend(gStringVar4, uroom->field_1A4);
     }
 }
diff --git a/src/union_room_battle.c b/src/union_room_battle.c
index b75cc086d..b4d8af9ce 100644
--- a/src/union_room_battle.c
+++ b/src/union_room_battle.c
@@ -13,15 +13,16 @@
 #include "text_window.h"
 #include "union_room.h"
 #include "window.h"
+#include "constants/union_room.h"
 
-struct UnkStruct_203B08C
+struct UnionRoomBattleWork
 {
-    s16 a0;
+    s16 textState;
 };
 
-static EWRAM_DATA struct UnkStruct_203B08C * gUnknown_203B08C = NULL;
+static EWRAM_DATA struct UnionRoomBattleWork * sWork = NULL;
 
-static const struct BgTemplate gUnknown_8457194[] = {
+static const struct BgTemplate sBgTemplates[] = {
     {
         .bg = 0,
         .charBaseIndex = 3,
@@ -29,7 +30,7 @@ static const struct BgTemplate gUnknown_8457194[] = {
     }
 };
 
-static const struct WindowTemplate gUnknown_8457198[] = {
+static const struct WindowTemplate sWindowTemplates[] = {
     {
         .bg = 0,
         .tilemapLeft = 2,
@@ -43,10 +44,10 @@ static const struct WindowTemplate gUnknown_8457198[] = {
 
 static const u8 gUnknown_84571A8[] = {1, 2, 3};
 
-static void sub_811C04C(void)
+static void SetUpPartiesAndStartBattle(void)
 {
     s32 i;
-    sub_81173C0(BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER);
+    StartUnionRoomBattle(BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER);
     for (i = 0; i < 2; i++)
     {
         gEnemyParty[i] = gPlayerParty[gSelectedOrderFromParty[i] - 1];
@@ -65,7 +66,7 @@ static void sub_811C04C(void)
     SetMainCallback2(CB2_InitBattle);
 }
 
-static void sub_811C0E0(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed)
+static void UnionRoomBattle_CreateTextPrinter(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed)
 {
     s32 letterSpacing = 1;
     s32 lineSpacing = 1;
@@ -73,13 +74,13 @@ static void sub_811C0E0(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed)
     AddTextPrinterParameterized4(windowId, 3, x, y, letterSpacing, lineSpacing, gUnknown_84571A8, speed, str);
 }
 
-static bool32 sub_811C150(s16 * state, const u8 * str, s32 speed)
+static bool32 UnionRoomBattle_PrintTextOnWindow0(s16 * state, const u8 * str, s32 speed)
 {
     switch (*state)
     {
     case 0:
         DrawTextBorderOuter(0, 0x001, 0xD);
-        sub_811C0E0(0, str, 0, 2, speed);
+        UnionRoomBattle_CreateTextPrinter(0, str, 0, 2, speed);
         PutWindowTilemap(0);
         CopyWindowToVram(0, 3);
         (*state)++;
@@ -95,27 +96,27 @@ static bool32 sub_811C150(s16 * state, const u8 * str, s32 speed)
     return FALSE;
 }
 
-static void sub_811C1B4(void)
+static void VBlankCB_UnionRoomBattle(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
 }
 
-void sub_811C1C8(void)
+void CB2_UnionRoomBattle(void)
 {
     switch (gMain.state)
     {
     case 0:
         SetGpuReg(REG_OFFSET_DISPCNT, 0x0000);
-        gUnknown_203B08C = AllocZeroed(sizeof(struct UnkStruct_203B08C));
+        sWork = AllocZeroed(sizeof(struct UnionRoomBattleWork));
         ResetSpriteData();
         FreeAllSpritePalettes();
         ResetTasks();
         ResetBgsAndClearDma3BusyFlags(0);
-        InitBgsFromTemplates(0, gUnknown_8457194, 1);
+        InitBgsFromTemplates(0, sBgTemplates, 1);
         ResetTempTileDataBuffers();
-        if (!InitWindows(gUnknown_8457198))
+        if (!InitWindows(sWindowTemplates))
         {
             return;
         }
@@ -126,11 +127,11 @@ void sub_811C1C8(void)
         FillBgTilemapBufferRect(0, 0, 0, 0, 30, 20, 0xF);
         TextWindow_SetStdFrame0_WithPal(0, 1, 0xD0);
         Menu_LoadStdPal();
-        SetVBlankCallback(sub_811C1B4);
+        SetVBlankCallback(VBlankCB_UnionRoomBattle);
         gMain.state++;
         break;
     case 1:
-        if (sub_811C150(&gUnknown_203B08C->a0, gText_CommStandbyAwaitingOtherPlayer, 0))
+        if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_CommStandbyAwaitingOtherPlayer, 0))
         {
             gMain.state++;
         }
@@ -146,11 +147,11 @@ void sub_811C1C8(void)
             memset(gBlockSendBuffer, 0, 0x20);
             if (gSelectedOrderFromParty[0] == -gSelectedOrderFromParty[1])
             {
-                gBlockSendBuffer[0] = 0x52;
+                gBlockSendBuffer[0] = ACTIVITY_DECLINE | 0x40;
             }
             else
             {
-                gBlockSendBuffer[0] = 0x51;
+                gBlockSendBuffer[0] = ACTIVITY_ACCEPT | 0x40;
             }
             SendBlock(0, gBlockSendBuffer, 0x20);
             gMain.state++;
@@ -159,15 +160,15 @@ void sub_811C1C8(void)
     case 4:
         if (GetBlockReceivedStatus() == 3)
         {
-            if (gBlockRecvBuffer[0][0] == 0x51 && gBlockRecvBuffer[1][0] == 0x51)
+            if (gBlockRecvBuffer[0][0] == (ACTIVITY_ACCEPT | 0x40) && gBlockRecvBuffer[1][0] == (ACTIVITY_ACCEPT | 0x40))
             {
                 BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
                 gMain.state = 50;
             }
             else
             {
-                sub_800AAC0();
-                if (gBlockRecvBuffer[GetMultiplayerId()][0] == 0x52)
+                Link_TryStartSend5FFF();
+                if (gBlockRecvBuffer[GetMultiplayerId()][0] == (ACTIVITY_DECLINE | 0x40))
                 {
                     gMain.state = 6;
                 }
@@ -182,14 +183,14 @@ void sub_811C1C8(void)
     case 50:
         if (!UpdatePaletteFade())
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             gMain.state++;
         }
         break;
     case 51:
         if (IsLinkTaskFinished())
         {
-            SetMainCallback2(sub_811C04C);
+            SetMainCallback2(SetUpPartiesAndStartBattle);
         }
         break;
     case 6:
@@ -199,7 +200,7 @@ void sub_811C1C8(void)
         }
         break;
     case 7:
-        if (sub_811C150(&gUnknown_203B08C->a0, gText_RefusedBattle, 1))
+        if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_RefusedBattle, 1))
         {
             SetMainCallback2(CB2_ReturnToField);
         }
@@ -211,7 +212,7 @@ void sub_811C1C8(void)
         }
         break;
     case 9:
-        if (sub_811C150(&gUnknown_203B08C->a0, gText_BattleWasRefused, 1))
+        if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_BattleWasRefused, 1))
         {
             SetMainCallback2(CB2_ReturnToField);
         }
diff --git a/src/union_room_chat.c b/src/union_room_chat.c
index 15601c028..4ac4c62cb 100644
--- a/src/union_room_chat.c
+++ b/src/union_room_chat.c
@@ -14,7 +14,7 @@
 #include "task.h"
 #include "union_room_chat.h"
 #include "union_room_chat_display.h"
-#include "data_8479668.h"
+#include "keyboard_text.h"
 #include "constants/songs.h"
 
 #define MESSAGE_BUFFER_NCHAR 15
@@ -207,7 +207,7 @@ void EnterUnionRoomChat(void)
     sWork = Alloc(sizeof(struct UnionRoomChat));
     InitChatWork(sWork);
     gKeyRepeatStartDelay = 20;
-    sub_812B4AC();
+    HelpSystem_DisableToggleWithRButton();
     SetVBlankCallback(NULL);
     SetMainCallback2(CB2_LoadInterface);
 }
@@ -587,7 +587,7 @@ static void ChatEntryRoutine_ExitChat(void)
     case 5:
         if (IsLinkTaskFinished() && !GetRfuUnkCE8())
         {
-            sub_800AAC0();
+            Link_TryStartSend5FFF();
             sWork->exitDelayTimer = 0;
             sWork->routineState++;
         }
@@ -622,7 +622,7 @@ static void ChatEntryRoutine_Drop(void)
     case 1:
         if (!RunDisplaySubtask(0) && IsLinkTaskFinished() && !GetRfuUnkCE8())
         {
-            sub_800AAC0();
+            Link_TryStartSend5FFF();
             sWork->exitDelayTimer = 0;
             sWork->routineState++;
         }
@@ -668,7 +668,7 @@ static void ChatEntryRoutine_Disbanded(void)
     case 2:
         if (RunDisplaySubtask(0) != TRUE && IsLinkTaskFinished() && !GetRfuUnkCE8())
         {
-            sub_800AAC0();
+            Link_TryStartSend5FFF();
             sWork->exitDelayTimer = 0;
             sWork->routineState++;
         }
@@ -893,7 +893,7 @@ static void ChatEntryRoutine_SaveAndExit(void)
     case 13:
         if (!gPaletteFade.active)
         {
-            sub_812B4B8();
+            HelpSystem_EnableToggleWithRButton();
             UnionRoomChat_FreeGraphicsWork();
             FreeChatWork();
             SetMainCallback2(CB2_ReturnToField);
@@ -914,7 +914,7 @@ static bool32 TypeChatMessage_HandleDPad(void)
     {
         if (JOY_REPT(DPAD_UP))
         {
-            if (sWork->currentRow)
+            if (sWork->currentRow > 0)
                 sWork->currentRow--;
             else
                 sWork->currentRow = sKeyboardPageMaxRow[sWork->currentPage];
@@ -938,7 +938,7 @@ static bool32 TypeChatMessage_HandleDPad(void)
         {
             if (JOY_REPT(DPAD_LEFT))
             {
-                if (sWork->currentCol)
+                if (sWork->currentCol > 0)
                     sWork->currentCol--;
                 else
                     sWork->currentCol = 4;
diff --git a/src/union_room_message.c b/src/union_room_message.c
index 9ca5aa15b..3aeb40524 100644
--- a/src/union_room_message.c
+++ b/src/union_room_message.c
@@ -1,10 +1,10 @@
 #include "global.h"
-#include "union_room_message.h"
 #include "mevent_server.h"
+#include "constants/union_room.h"
 
-ALIGNED(4) const u8 gUnknown_84571AC[] = _("");
+ALIGNED(4) const u8 gUnionRoomActivity_Blank[] = _("");
 ALIGNED(4) const u8 gUnknown_84571B0[] = _(":");
-ALIGNED(4) const u8 gUnknown_84571B4[] = _("{EXTRA 7}");
+ALIGNED(4) const u8 gUnknown_84571B4[] = _("{ID}");
 ALIGNED(4) const u8 gUnknown_84571B8[] = _("Please start over from the beginning.");
 ALIGNED(4) const u8 gUnknown_84571E0[] = _("The WIRELESS COMMUNICATION\nSYSTEM search has been canceled.");
 ALIGNED(4) const u8 gUnref_845721C[] = _("ともだちからの れんらくを\nまっています");
@@ -124,6 +124,7 @@ const u8 *const gUnknown_8457754[] = {
 
 ALIGNED(4) const u8 gUnknown_845777C[] = _("The WIRELESS COMMUNICATION\nSYSTEM link has been established.");
 ALIGNED(4) const u8 gUnknown_84577BC[] = _("The WIRELESS COMMUNICATION\nSYSTEM link has been dropped…");
+
 ALIGNED(4) const u8 gUnknown_84577F8[] = _("The link with your friend has been\ndropped…");
 ALIGNED(4) const u8 gUnknown_8457824[] = _("{STR_VAR_1} replied, “No…”");
 
@@ -150,11 +151,12 @@ const u8 *const gUnknown_8457898[] = {
 
 ALIGNED(4) const u8 gUnknown_84578A0[] = _("はなしかけています…\nしょうしょう おまちください");
 ALIGNED(4) const u8 gUnknown_84578BC[] = _("Awaiting {STR_VAR_1}'s response about\nthe trade…");
+
 ALIGNED(4) const u8 gUnknown_84578E4[] = _("Communicating{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.");
 ALIGNED(4) const u8 gUnknown_8457950[] = _("Communicating with {STR_VAR_1}{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.");
 ALIGNED(4) const u8 gUnknown_84579BC[] = _("Please wait a while{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.");
 
-const u8 *const gUnknown_8457A34[] = {
+const u8 *const gURText_PleaseWaitMsgs[] = {
     gUnknown_84578E4,
     gUnknown_8457950,
     gUnknown_84579BC
@@ -165,7 +167,7 @@ ALIGNED(4) const u8 gUnknown_8457A70[] = _("Hello!\nWould you like to do somethi
 ALIGNED(4) const u8 gUnknown_8457A98[] = _("{STR_VAR_1}: Hiya, we meet again!\nWhat are you up for this time?");
 ALIGNED(4) const u8 gUnknown_8457AD0[] = _("{STR_VAR_1}: Oh! {PLAYER}, hello!\nWould you like to do something?");
 
-const u8 *const gUnknown_8457B04[][2] = {
+const u8 *const gURText_FriendPromptsForActivity[][2] = {
     {
         gUnknown_8457A40,
         gUnknown_8457A70
@@ -237,6 +239,7 @@ const u8 *const gUnknown_8457F80[][2] = {
 };
 
 ALIGNED(4) const u8 gUnknown_8457F90[] = _("……\nThe TRAINER appears to be busy…\p");
+
 ALIGNED(4) const u8 gUnknown_8457FB4[] = _("A battle, huh?\nAll right, just give me some time.");
 ALIGNED(4) const u8 gUnknown_8457FE8[] = _("You want to chat, huh?\nSure, just wait a little.");
 ALIGNED(4) const u8 gUnknown_845801C[] = _("Sure thing! As my “Greetings,”\nhere's my TRAINER CARD.");
@@ -244,7 +247,7 @@ ALIGNED(4) const u8 gUnknown_8458054[] = _("A battle? Of course, but I need\ntim
 ALIGNED(4) const u8 gUnknown_8458088[] = _("Did you want to chat?\nOkay, but please wait a moment.");
 ALIGNED(4) const u8 gUnknown_84580C0[] = _("As my introduction, I'll show you\nmy TRAINER CARD.");
 
-const u8 *const gUnknown_84580F4[][4] = {
+const u8 *const gResponseToURoomActivityInviteStringPtrs[][4] = {
     {
         gUnknown_8457FB4,
         gUnknown_8457FE8,
@@ -415,7 +418,8 @@ ALIGNED(4) const u8 gUnknown_8458AB8[] = _("Welcome to the TRADING BOARD.\pYou m
 ALIGNED(4) const u8 gUnknown_8458B44[] = _("This TRADING BOARD is used for\noffering a POKéMON for a trade.\pAll you need to do is register a\nPOKéMON for a trade.\pAnother TRAINER may offer a party\nPOKéMON in return for the trade.\pWe hope you will register POKéMON\nand trade them with many, many\lother TRAINERS.\pWould you like to register one of\nyour POKéMON?");
 ALIGNED(4) const u8 gUnref_ThankYouForComing_JP[] = _("こうかんけいじばん の とうろくが\nかんりょう しました\pごりよう ありがとう\nございました！\p");
 ALIGNED(4) const u8 gUnref_NoOneRegisteredMon[] = _("けいじばんに だれも ポケモンを\nとうろく していません\p\n");
-ALIGNED(4) const u8 gUnknown_8458CD4[] = _("Please choose the type of POKéMON\nthat you would like in the trade.\n");
+
+ALIGNED(4) const u8 gURText_PleaseChooseTypeOfMon[] = _("Please choose the type of POKéMON\nthat you would like in the trade.\n");
 ALIGNED(4) const u8 gUnknown_8458D1C[] = _("Which of your party POKéMON will\nyou offer in trade?\p");
 ALIGNED(4) const u8 gUnknown_8458D54[] = _("Registration has been canceled.\p");
 ALIGNED(4) const u8 gUnknown_8458D78[] = _("Registration has been completed.\p");
@@ -439,9 +443,10 @@ const u8 *const gUnknown_8458F94[] = {
 };
 
 ALIGNED(4) const u8 gUnknown_8458F9C[] = _("Your trade offer was rejected.\p");
-ALIGNED(4) const u8 gUnknown_8458FBC[] = _("EGG TRADE");
+ALIGNED(4) const u8 gText_EggTrade[] = _("EGG TRADE");
 ALIGNED(4) const u8 gUnknown_8458FC8[] = _("{DPAD_UPDOWN}CHOOSE  {A_BUTTON}JOIN  {B_BUTTON}CANCEL");
 ALIGNED(4) const u8 gUnknown_8458FE4[] = _("Please choose a TRAINER.");
+
 ALIGNED(4) const u8 gUnknown_8459000[] = _("Please choose a TRAINER for\na SINGLE BATTLE.");
 ALIGNED(4) const u8 gUnknown_8459030[] = _("Please choose a TRAINER for\na DOUBLE BATTLE.");
 ALIGNED(4) const u8 gUnknown_8459060[] = _("Please choose the LEADER\nfor a MULTI BATTLE.");
@@ -453,15 +458,15 @@ ALIGNED(4) const u8 gUnknown_8459160[] = _("BERRY CRUSH!\nPlease choose the LEAD
 ALIGNED(4) const u8 gUnknown_8459188[] = _("DODRIO BERRY-PICKING!\nPlease choose the LEADER.");
 
 const u8 *const gUnknown_84591B8[] = {
-    gUnknown_8459000,
-    gUnknown_8459030,
-    gUnknown_8459060,
-    gUnknown_8459090,
-    gUnknown_845912C,
-    gUnknown_8459160,
-    gUnknown_8459188,
-    gUnknown_84590BC,
-    gUnknown_84590F4
+    [LINK_GROUP_SINGLE_BATTLE] = gUnknown_8459000,
+    [LINK_GROUP_DOUBLE_BATTLE] = gUnknown_8459030,
+    [LINK_GROUP_MULTI_BATTLE]  = gUnknown_8459060,
+    [LINK_GROUP_TRADE]         = gUnknown_8459090,
+    [LINK_GROUP_POKEMON_JUMP]  = gUnknown_845912C,
+    [LINK_GROUP_BERRY_CRUSH]   = gUnknown_8459160,
+    [LINK_GROUP_BERRY_PICKING] = gUnknown_8459188,
+    [LINK_GROUP_WONDER_CARD]   = gUnknown_84590BC,
+    [LINK_GROUP_WONDER_NEWS]   = gUnknown_84590F4
 };
 
 ALIGNED(4) const u8 gUnknown_84591DC[] = _("Searching for a WIRELESS\nCOMMUNICATION SYSTEM. Wait...");
@@ -470,6 +475,7 @@ ALIGNED(4) const u8 gUnknown_8459238[] = _("Awaiting {STR_VAR_1}'s response…")
 ALIGNED(4) const u8 gUnknown_8459250[] = _("{STR_VAR_1} has been asked to register\nyou as a member. Please wait.");
 ALIGNED(4) const u8 gUnknown_845928C[] = _("Awaiting a response from the\nWIRELESS COMMUNICATION SYSTEM.");
 ALIGNED(4) const u8 gUnref_PlsWaitLittleWHile[] = _("ほかの さんかしゃが そろうまで\nしょうしょう おまちください");
+
 ALIGNED(4) const u8 gUnknown_84592E8[] = _("No CARDS appear to be shared \nright now.");
 ALIGNED(4) const u8 gUnknown_8459314[] = _("No NEWS appears to be shared\nright now.");
 
@@ -482,23 +488,26 @@ ALIGNED(4) const u8 gUnknown_8459344[] = _("BATTLE");
 ALIGNED(4) const u8 gUnknown_845934C[] = _("CHAT");
 ALIGNED(4) const u8 gUnknown_8459354[] = _("GREETINGS");
 ALIGNED(4) const u8 gUnknown_8459360[] = _("EXIT");
+
 ALIGNED(4) const u8 gUnknown_8459368[] = _("EXIT");
 ALIGNED(4) const u8 gUnknown_8459370[] = _("INFO");
 ALIGNED(4) const u8 gUnknown_8459378[] = _("NAME{CLEAR_TO 0x3C}WANTED{CLEAR_TO 0x6E}OFFER{CLEAR_TO 0xC6}LV.");
-ALIGNED(4) const u8 gUnknown_8459394[] = _("SINGLE BATTLE");
-ALIGNED(4) const u8 gUnknown_84593A4[] = _("DOUBLE BATTLE");
-ALIGNED(4) const u8 gUnknown_84593B4[] = _("MULTI BATTLE");
-ALIGNED(4) const u8 gUnknown_84593C4[] = _("POKéMON TRADES");
-ALIGNED(4) const u8 gUnknown_84593D4[] = _("CHAT");
-ALIGNED(4) const u8 gUnknown_84593DC[] = _("CARDS");
-ALIGNED(4) const u8 gUnknown_84593E4[] = _("WONDER CARDS");
-ALIGNED(4) const u8 gUnknown_84593F4[] = _("WONDER NEWS");
-ALIGNED(4) const u8 gUnknown_8459400[] = _("POKéMON JUMP");
-ALIGNED(4) const u8 gUnknown_8459410[] = _("BERRY CRUSH");
-ALIGNED(4) const u8 gUnknown_845941C[] = _("BERRY-PICKING");
-ALIGNED(4) const u8 gUnknown_845942C[] = _("SEARCH");
-ALIGNED(4) const u8 gUnknown_8459434[] = _("ぐるぐるこうかん");
-ALIGNED(4) const u8 gUnknown_8459440[] = _("アイテムトレード");
+
+ALIGNED(4) const u8 gUnionRoomActivity_SingleBattle[] = _("SINGLE BATTLE");
+ALIGNED(4) const u8 gUnionRoomActivity_DoubleBattle[] = _("DOUBLE BATTLE");
+ALIGNED(4) const u8 gUnionRoomActivity_MultiBattle[] = _("MULTI BATTLE");
+ALIGNED(4) const u8 gUnionRoomActivity_PokemonTrades[] = _("POKéMON TRADES");
+ALIGNED(4) const u8 gUnionRoomActivity_Chat[] = _("CHAT");
+ALIGNED(4) const u8 gUnionRoomActivity_Cards[] = _("CARDS");
+ALIGNED(4) const u8 gUnionRoomActivity_WonderCards[] = _("WONDER CARDS");
+ALIGNED(4) const u8 gunionRoomActivity_WonderNews[] = _("WONDER NEWS");
+ALIGNED(4) const u8 gUnionRoomActivity_PokemonJump[] = _("POKéMON JUMP");
+ALIGNED(4) const u8 gUnionRoomActivity_BerryCrush[] = _("BERRY CRUSH");
+ALIGNED(4) const u8 gUnionRoomActivity_BerryPicking[] = _("BERRY-PICKING");
+ALIGNED(4) const u8 gUnionRoomActivity_Search[] = _("SEARCH");
+ALIGNED(4) const u8 gUnionRoomActivity_SpinTradeJP[] = _("ぐるぐるこうかん");
+ALIGNED(4) const u8 gUnionRoomActivity_ItemTradeJP[] = _("アイテムトレード");
+
 ALIGNED(4) const u8 gUnknown_845944C[] = _("It's a NORMAL CARD.");
 ALIGNED(4) const u8 gUnknown_8459460[] = _("It's a BRONZE CARD!");
 ALIGNED(4) const u8 gUnknown_8459474[] = _("It's a COPPER CARD!");
@@ -515,6 +524,7 @@ const u8 *const gUnknown_84594B0[] = {
 
 ALIGNED(4) const u8 gUnknown_84594C4[] = _("This is {SPECIAL_F7 0x00} {SPECIAL_F7 0x01}'s\nTRAINER CARD…\l{SPECIAL_F7 0x02}\pPOKéDEX: {SPECIAL_F7 0x03}\nTIME:    {SPECIAL_F7 0x04}:{SPECIAL_F7 0x05}\p");
 ALIGNED(4) const u8 gUnknown_8459504[] = _("BATTLES: {SPECIAL_F7 0x00} WINS  {SPECIAL_F7 0x02} LOSSES\nTRADES:  {SPECIAL_F7 0x03} TIMES\p“{SPECIAL_F7 0x04} {SPECIAL_F7 0x05}\n{SPECIAL_F7 0x06} {SPECIAL_F7 0x07}”\p");
+
 ALIGNED(4) const u8 gUnknown_8459544[] = _("{SPECIAL_F7 0x01}: Glad to have met you!{PAUSE 60}");
 ALIGNED(4) const u8 gUnknown_8459564[] = _("{SPECIAL_F7 0x01}: Glad to meet you!{PAUSE 60}");
 
diff --git a/src/unk_815C980.c b/src/unk_815C980.c
deleted file mode 100644
index 09b92c834..000000000
--- a/src/unk_815C980.c
+++ /dev/null
@@ -1,437 +0,0 @@
-#include "global.h"
-#include "malloc.h"
-#include "decompress.h"
-#include "unk_815C980.h"
-#include "main.h"
-#include "battle.h"
-
-struct UnkStruct2
-{
-    bool8 isActive;
-    u8 firstOamId;
-    u8 field_2;
-    u8 oamCount;
-    u8 palTagIndex;
-    u8 size;
-    u8 shape;
-    u8 priority;
-    u8 xDelta;
-    u8 field_9;
-    u16 tileStart;
-    s16 x;
-    s16 y;
-    u16 tileTag;
-    u16 palTag;
-    u32 field_14;
-    s32 field_18;
-};
-
-struct UnkStruct1
-{
-    u32 count;
-    struct UnkStruct2 *array;
-};
-
-// this file's functions
-static u8 sub_815D244(u8 arg0);;
-static void sub_815CC28(struct UnkStruct2 *arg0);
-static void sub_815CDDC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2);
-static void sub_815CE90(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2);
-static void sub_815CFEC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2);
-static bool32 SharesTileWithAnyActive(u32 id);
-static bool32 SharesPalWithAnyActive(u32 id);
-static void sub_8035648(void);
-static u8 sub_815D324(u32 shape, u32 size);
-
-// ewram
-static EWRAM_DATA struct UnkStruct1 *gUnknown_203F454 = {0};
-
-// const rom data
-static const u8 gUnknown_8479658[][4] =
-{
-    {0x01, 0x04, 0x10, 0x40},
-    {0x02, 0x04, 0x08, 0x20},
-    {0x02, 0x04, 0x08, 0x20},
-    {0x00, 0x00, 0x00, 0x00}
-};
-
-// code
-bool32 sub_815C980(u32 count)
-{
-    u32 i;
-
-    if (gUnknown_203F454 != NULL)
-        sub_815C9F4();
-
-    gUnknown_203F454 = Alloc(sizeof(*gUnknown_203F454));
-    if (gUnknown_203F454 == NULL)
-        return FALSE;
-
-    gUnknown_203F454->array = Alloc(sizeof(struct UnkStruct2) * count);
-    if (gUnknown_203F454->array == NULL)
-    {
-        Free(gUnknown_203F454);
-        return FALSE;
-    }
-
-    gUnknown_203F454->count = count;
-    for (i = 0; i < count; i++)
-    {
-        gUnknown_203F454->array[i].isActive = FALSE;
-        gUnknown_203F454->array[i].firstOamId = 0xFF;
-    }
-
-    return TRUE;
-}
-
-void sub_815C9F4(void)
-{
-    if (gUnknown_203F454 != NULL)
-    {
-        if (gUnknown_203F454->array != NULL)
-        {
-            u32 i;
-
-            for (i = 0; i < gUnknown_203F454->count; i++)
-                sub_815D108(i);
-
-            Free(gUnknown_203F454->array);
-        }
-
-        FREE_AND_SET_NULL(gUnknown_203F454);
-    }
-}
-
-bool32 sub_815CA40(u32 id, s32 arg1, const struct UnkStruct3 *arg2)
-{
-    u32 i;
-
-    if (gUnknown_203F454 == NULL)
-        return FALSE;
-    if (gUnknown_203F454->array[id].isActive)
-        return FALSE;
-
-    gUnknown_203F454->array[id].firstOamId = sub_815D244(arg2->field_1);
-    if (gUnknown_203F454->array[id].firstOamId == 0xFF)
-        return FALSE;
-
-    gUnknown_203F454->array[id].tileStart = GetSpriteTileStartByTag(arg2->spriteSheet->tag);
-    if (gUnknown_203F454->array[id].tileStart == 0xFFFF)
-    {
-        if (arg2->spriteSheet->size != 0)
-        {
-            gUnknown_203F454->array[id].tileStart = LoadSpriteSheet(arg2->spriteSheet);
-        }
-        else
-        {
-            struct CompressedSpriteSheet compObjectPic;
-
-            compObjectPic = *(struct CompressedSpriteSheet*)(arg2->spriteSheet);
-            compObjectPic.size = GetDecompressedDataSize(arg2->spriteSheet->data);
-            gUnknown_203F454->array[id].tileStart = LoadCompressedSpriteSheet(&compObjectPic);
-        }
-
-        if (gUnknown_203F454->array[id].tileStart == 0xFFFF)
-            return FALSE;
-    }
-
-    gUnknown_203F454->array[id].palTagIndex = IndexOfSpritePaletteTag(arg2->spritePal->tag);
-    if (gUnknown_203F454->array[id].palTagIndex == 0xFF)
-        gUnknown_203F454->array[id].palTagIndex = LoadSpritePalette(arg2->spritePal);
-
-    gUnknown_203F454->array[id].field_2 = arg2->field_0_0;
-    gUnknown_203F454->array[id].oamCount = arg2->field_1;
-    gUnknown_203F454->array[id].x = arg2->x;
-    gUnknown_203F454->array[id].y = arg2->y;
-    gUnknown_203F454->array[id].shape = arg2->shape;
-    gUnknown_203F454->array[id].size = arg2->size;
-    gUnknown_203F454->array[id].priority = arg2->priority;
-    gUnknown_203F454->array[id].xDelta = arg2->xDelta;
-    gUnknown_203F454->array[id].field_9 = sub_815D324(arg2->shape, arg2->size);
-    gUnknown_203F454->array[id].tileTag = arg2->spriteSheet->tag;
-    gUnknown_203F454->array[id].palTag = arg2->spritePal->tag;
-    gUnknown_203F454->array[id].isActive = TRUE;
-    gUnknown_203F454->array[id].field_14 = 1;
-
-    for (i = 1; i < arg2->field_1; i++)
-        gUnknown_203F454->array[id].field_14 *= 10;
-
-    sub_815CC28(&gUnknown_203F454->array[id]);
-    sub_815CD70(id, arg1);
-
-    return TRUE;
-}
-
-static void sub_815CC28(struct UnkStruct2 *arg0)
-{
-    u32 i;
-    u32 oamId = arg0->firstOamId;
-    u32 x = arg0->x;
-    u32 oamCount = arg0->oamCount + 1;
-
-    CpuFill16(0, &gMain.oamBuffer[oamId], sizeof(struct OamData) * oamCount);
-    for (i = 0, oamId = arg0->firstOamId; i < oamCount; i++, oamId++)
-    {
-        gMain.oamBuffer[oamId].y = arg0->y;
-        gMain.oamBuffer[oamId].x = x;
-        gMain.oamBuffer[oamId].shape = arg0->shape;
-        gMain.oamBuffer[oamId].size = arg0->size;
-        gMain.oamBuffer[oamId].tileNum = arg0->tileStart;
-        gMain.oamBuffer[oamId].priority = arg0->priority;
-        gMain.oamBuffer[oamId].paletteNum = arg0->palTagIndex;
-
-        x += arg0->xDelta;
-    }
-
-    oamId--;
-    gMain.oamBuffer[oamId].x = arg0->x - arg0->xDelta;
-    gMain.oamBuffer[oamId].affineMode = 2;
-    gMain.oamBuffer[oamId].tileNum = arg0->tileStart + (arg0->field_9 * 10);
-}
-
-void sub_815CD70(u32 id, s32 arg1)
-{
-    bool32 r2;
-
-    if (gUnknown_203F454 == NULL)
-        return;
-    if (!gUnknown_203F454->array[id].isActive)
-        return;
-
-    gUnknown_203F454->array[id].field_18 = arg1;
-    if (arg1 < 0)
-    {
-        r2 = TRUE;
-        arg1 *= -1;
-    }
-    else
-    {
-        r2 = FALSE;
-    }
-
-    switch (gUnknown_203F454->array[id].field_2)
-    {
-    case 0:
-    default:
-        sub_815CDDC(&gUnknown_203F454->array[id], arg1, r2);
-        break;
-    case 1:
-        sub_815CE90(&gUnknown_203F454->array[id], arg1, r2);
-        break;
-    case 2:
-        sub_815CFEC(&gUnknown_203F454->array[id], arg1, r2);
-        break;
-    }
-}
-
-static void sub_815CDDC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2)
-{
-    u32 r5 = arg0->field_14;
-    u32 oamId = arg0->firstOamId;
-
-    while (r5 != 0)
-    {
-        u32 r4 = arg1 / r5;
-        arg1 -= (r4 * r5);
-        r5 /= 10;
-
-        gMain.oamBuffer[oamId].tileNum = (r4 * arg0->field_9) + arg0->tileStart;
-        oamId++;
-    }
-
-    if (arg2)
-        gMain.oamBuffer[oamId].affineMode = 0;
-    else
-        gMain.oamBuffer[oamId].affineMode = 2;
-}
-
-static void sub_815CE90(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2)
-{
-    u32 r5 = arg0->field_14;
-    static int gUnknown_3002078;
-    static int gUnknown_300207C;
-    static int gUnknown_3002080;
-
-    gUnknown_3002078 = arg0->firstOamId;
-    gUnknown_300207C = 0;
-    gUnknown_3002080 = -1;
-
-    while (r5 != 0)
-    {
-        u32 r4 = arg1 / r5;
-        arg1 -= (r4 * r5);
-        r5 /= 10;
-
-        if (r4 != 0 || gUnknown_3002080 != -1 || r5 == 0)
-        {
-            gMain.oamBuffer[gUnknown_3002078].tileNum = (r4 * arg0->field_9) + arg0->tileStart;
-            gMain.oamBuffer[gUnknown_3002078].affineMode = 0;
-
-            if (gUnknown_3002080 == -1)
-                gUnknown_3002080 = gUnknown_300207C;
-        }
-        else
-        {
-            gMain.oamBuffer[gUnknown_3002078].affineMode = 2;
-        }
-
-        gUnknown_3002078++;
-        gUnknown_300207C++;
-    }
-
-    if (arg2)
-    {
-        gMain.oamBuffer[gUnknown_3002078].affineMode = 0;
-        gMain.oamBuffer[gUnknown_3002078].x = arg0->x + ((gUnknown_3002080 - 1) * arg0->xDelta);
-    }
-    else
-    {
-        gMain.oamBuffer[gUnknown_3002078].affineMode = 2;
-    }
-}
-
-static void sub_815CFEC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2)
-{
-    u32 r5 = arg0->field_14;
-    u32 oamId = arg0->firstOamId;
-    u32 var_28 = 0;
-    s32 r9 = 0;
-
-    while (r5 != 0)
-    {
-        u32 r4 = arg1 / r5;
-        arg1 -= (r4 * r5);
-        r5 /= 10;
-
-        if (r4 != 0 || var_28 != 0 || r5 == 0)
-        {
-            var_28 = 1;
-            gMain.oamBuffer[oamId].tileNum = (r4 * arg0->field_9) + arg0->tileStart;
-            gMain.oamBuffer[oamId].affineMode = 0;
-
-            oamId++;
-            r9++;
-        }
-    }
-
-    while (r9 < arg0->oamCount)
-    {
-        gMain.oamBuffer[oamId].affineMode = 2;
-        oamId++;
-        r9++;
-    }
-
-    if (arg2)
-        gMain.oamBuffer[oamId].affineMode = 0;
-    else
-        gMain.oamBuffer[oamId].affineMode = 2;
-}
-
-void sub_815D108(u32 id)
-{
-    s32 oamId, oamCount, i;
-
-    if (gUnknown_203F454 == NULL)
-        return;
-    if (!gUnknown_203F454->array[id].isActive)
-        return;
-
-    oamCount = gUnknown_203F454->array[id].oamCount + 1;
-    oamId = gUnknown_203F454->array[id].firstOamId;
-
-    for (i = 0; i < oamCount; i++, oamId++)
-        gMain.oamBuffer[oamId].affineMode = 2;
-
-    if (!SharesTileWithAnyActive(id))
-        FreeSpriteTilesByTag(gUnknown_203F454->array[id].tileTag);
-    if (!SharesPalWithAnyActive(id))
-        FreeSpritePaletteByTag(gUnknown_203F454->array[id].palTag);
-
-    gUnknown_203F454->array[id].isActive = FALSE;
-}
-
-void sub_815D1A8(u32 id, bool32 arg1)
-{
-    s32 oamId, oamCount, i;
-
-    if (gUnknown_203F454 == NULL)
-        return;
-    if (!gUnknown_203F454->array[id].isActive)
-        return;
-
-    oamCount = gUnknown_203F454->array[id].oamCount + 1;
-    oamId = gUnknown_203F454->array[id].firstOamId;
-    if (arg1)
-    {
-        for (i = 0; i < oamCount; i++, oamId++)
-            gMain.oamBuffer[oamId].affineMode = 2;
-    }
-    else
-    {
-        for (i = 0; i < oamCount; i++, oamId++)
-            gMain.oamBuffer[oamId].affineMode = 0;
-
-        sub_815CD70(id, gUnknown_203F454->array[id].field_18);
-    }
-}
-
-static u8 sub_815D244(u8 arg0)
-{
-    u32 i;
-    u16 oamCount = 64;
-
-    for (i = 0; i < gUnknown_203F454->count; i++)
-    {
-        if (!gUnknown_203F454->array[i].isActive)
-        {
-            if (gUnknown_203F454->array[i].firstOamId != 0xFF && gUnknown_203F454->array[i].oamCount <= arg0)
-                return gUnknown_203F454->array[i].firstOamId;
-        }
-        else
-        {
-            oamCount += 1 + gUnknown_203F454->array[i].oamCount;
-        }
-    }
-
-    if (oamCount + arg0 + 1 > 128)
-        return 0xFF;
-    else
-        return oamCount;
-}
-
-static bool32 SharesTileWithAnyActive(u32 id)
-{
-    u32 i;
-
-    for (i = 0; i < gUnknown_203F454->count; i++)
-    {
-        if (gUnknown_203F454->array[i].isActive && i != id
-            && gUnknown_203F454->array[i].tileTag == gUnknown_203F454->array[id].tileTag)
-        {
-            return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-
-static bool32 SharesPalWithAnyActive(u32 id)
-{
-    u32 i;
-
-    for (i = 0; i < gUnknown_203F454->count; i++)
-    {
-        if (gUnknown_203F454->array[i].isActive && i != id
-            && gUnknown_203F454->array[i].palTag == gUnknown_203F454->array[id].palTag)
-        {
-            return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-
-static u8 sub_815D324(u32 shape, u32 size)
-{
-    return gUnknown_8479658[shape][size];
-}
diff --git a/src/util.c b/src/util.c
index 93aa60f84..b32799584 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,5 +1,4 @@
 #include "global.h"
-#include "util.h"
 
 const u32 gBitTable[] =
 {
diff --git a/src/vs_seeker.c b/src/vs_seeker.c
index 417b281d9..60f5f338f 100644
--- a/src/vs_seeker.c
+++ b/src/vs_seeker.c
@@ -18,19 +18,22 @@
 #include "battle.h"
 #include "battle_setup.h"
 #include "random.h"
-#include "event_object_movement.h"
 #include "field_player_avatar.h"
-#include "event_object_80688E4.h"
-#include "event_object_8097404.h"
-#include "unk_810c3a4.h"
 #include "vs_seeker.h"
-#include "constants/movement_commands.h"
-#include "constants/object_events.h"
+#include "constants/event_object_movement.h"
+#include "constants/event_objects.h"
 #include "constants/trainers.h"
 #include "constants/maps.h"
 #include "constants/items.h"
 #include "constants/quest_log.h"
 
+enum
+{
+   VSSEEKER_NOT_CHARGED,
+   VSSEEKER_NO_ONE_IN_RANGE,
+   VSSEEKER_CAN_USE,
+};
+
 typedef enum
 {
     VSSEEKER_RESPONSE_NO_RESPONSE,
@@ -548,29 +551,35 @@ static const VsSeekerData sVsSeekerData[] = {
 };
 
 static const u8 gUnknown_8453F5C[] = {
-    delay_16,
-    delay_16,
-    delay_16,
-    step_end
+    MOVEMENT_ACTION_DELAY_16,
+    MOVEMENT_ACTION_DELAY_16,
+    MOVEMENT_ACTION_DELAY_16,
+    MOVEMENT_ACTION_STEP_END
 };
 
 static const u8 gUnknown_8453F60[] = {
-    emote_exclamation_mark,
-    step_end
+    MOVEMENT_ACTION_EMOTE_EXCLAMATION_MARK,
+    MOVEMENT_ACTION_STEP_END
 };
 
 static const u8 sMovementScript_TrainerNoRematch[] = {
-    emote_x,
-    step_end
+    MOVEMENT_ACTION_EMOTE_X,
+    MOVEMENT_ACTION_STEP_END
 };
 
 static const u8 sMovementScript_TrainerRematch[] = {
-    walk_in_place_fastest_down,
-    emote_double_exclamation_mark,
-    step_end
+    MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_DOWN,
+    MOVEMENT_ACTION_EMOTE_DOUBLE_EXCL_MARK,
+    MOVEMENT_ACTION_STEP_END
 };
 
-static const u8 gUnknown_8453F67[] = { 0x08, 0x08, 0x07, 0x09, 0x0a };
+static const u8 gUnknown_8453F67[] = {
+    MOVEMENT_TYPE_FACE_DOWN,
+    MOVEMENT_TYPE_FACE_DOWN,
+    MOVEMENT_TYPE_FACE_UP,
+    MOVEMENT_TYPE_FACE_LEFT,
+    MOVEMENT_TYPE_FACE_RIGHT
+};
 
 
 // text
@@ -733,20 +742,20 @@ void Task_VsSeeker_0(u8 taskId)
     sVsSeeker = AllocZeroed(sizeof(struct VsSeekerStruct));
     GatherNearbyTrainerInfo();
     respval = CanUseVsSeeker();
-    if (respval == 0)
+    if (respval == VSSEEKER_NOT_CHARGED)
     {
         Free(sVsSeeker);
-        DisplayItemMessageOnField(taskId, 2, gUnknown_81C137C, sub_80A1E0C);
+        DisplayItemMessageOnField(taskId, 2, VSSeeker_Text_BatteryNotChargedNeedXSteps, sub_80A1E0C);
     }
-    else if (respval == 1)
+    else if (respval == VSSEEKER_NO_ONE_IN_RANGE)
     {
         Free(sVsSeeker);
-        DisplayItemMessageOnField(taskId, 2, gUnknown_81C13D6, sub_80A1E0C);
+        DisplayItemMessageOnField(taskId, 2, VSSeeker_Text_NoTrainersWithinRange, sub_80A1E0C);
     }
-    else if (respval == 2)
+    else if (respval == VSSEEKER_CAN_USE)
     {
         ItemUse_SetQuestLogEvent(QL_EVENT_USED_ITEM, 0, gSpecialVar_ItemId, 0xffff);
-        FieldEffectStart(FLDEFF_UNK_41); // TODO: name this enum
+        FieldEffectStart(FLDEFF_USE_VS_SEEKER);
         gTasks[taskId].func = Task_VsSeeker_1;
         gTasks[taskId].data[0] = 15;
     }
@@ -772,7 +781,7 @@ static void Task_VsSeeker_2(u8 taskId)
         data[2]++;
     }
 
-    if (!FieldEffectActiveListContains(FLDEFF_UNK_41))
+    if (!FieldEffectActiveListContains(FLDEFF_USE_VS_SEEKER))
     {
         data[1] = 0;
         data[2] = 0;
@@ -812,13 +821,13 @@ static void Task_VsSeeker_3(u8 taskId)
 {
     if (ScriptMovement_IsObjectMovementFinished(0xFF, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup))
     {
-        if (sVsSeeker->responseCode == 0)
+        if (sVsSeeker->responseCode == VSSEEKER_RESPONSE_NO_RESPONSE)
         {
-            DisplayItemMessageOnField(taskId, 2, gUnknown_81C1429, sub_80A1E0C);
+            DisplayItemMessageOnField(taskId, 2, VSSeeker_Text_TrainersNotReady, sub_80A1E0C);
         }
         else
         {
-            if (sVsSeeker->responseCode == 2)
+            if (sVsSeeker->responseCode == VSSEEKER_RESPONSE_FOUND_REMATCHES)
                 StartAllRespondantIdleMovements();
             ClearDialogWindowAndFrame(0, 1);
             sub_80696C0();
@@ -829,20 +838,20 @@ static void Task_VsSeeker_3(u8 taskId)
     }
 }
 
-u8 CanUseVsSeeker(void)
+static u8 CanUseVsSeeker(void)
 {
     u8 vsSeekerChargeSteps = gSaveBlock1Ptr->trainerRematchStepCounter;
     if (vsSeekerChargeSteps == 100)
     {
         if (GetRematchableTrainerLocalId() == 0xFF)
-            return 1;
+            return VSSEEKER_NO_ONE_IN_RANGE;
         else
-            return 2;
+            return VSSEEKER_CAN_USE;
     }
     else
     {
         TV_PrintIntToStringVar(0, 100 - vsSeekerChargeSteps);
-        return 0;
+        return VSSEEKER_NOT_CHARGED;
     }
 }
 
@@ -926,11 +935,11 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
         PlaySE(SE_PIN);
         FlagSet(FLAG_SYS_VS_SEEKER_CHARGING);
         sub_810C640();
-        return 2;
+        return VSSEEKER_RESPONSE_FOUND_REMATCHES;
     }
     if (sVsSeeker->trainerHasNotYetBeenFought)
-        return 1;
-    return 0;
+        return VSSEEKER_RESPONSE_UNFOUGHT_TRAINERS;
+    return VSSEEKER_RESPONSE_NO_RESPONSE;
 }
 
 void sub_810CB90(void)
@@ -957,7 +966,7 @@ void sub_810CB90(void)
                 if (gSelectedObjectEvent == sp0)
                     r4_2->movementType = gUnknown_8453F67[r4_2->facingDirection];
                 else
-                    r4_2->movementType = 0x08;
+                    r4_2->movementType = MOVEMENT_TYPE_FACE_DOWN;
             }
         }
     }
@@ -1077,7 +1086,7 @@ s32 GetRematchTrainerId(u16 a0)
     return sVsSeekerData[i].trainerIdxs[j];
 }
 
-u8 ScrSpecial_GetTrainerEyeRematchFlag(void) // unreferenced, or reference not disassembled
+u8 IsTrainerReadyForRematch(void)
 {
     return sub_810CED0(sVsSeekerData, gTrainerBattleOpponent_A);
 }
@@ -1127,32 +1136,32 @@ static u8 GetRunningBehaviorFromGraphicsId(u8 graphicsId)
 {
     switch (graphicsId)
     {
-        case OBJECT_EVENT_GFX_LITTLE_GIRL:
-        case OBJECT_EVENT_GFX_YOUNGSTER:
-        case OBJECT_EVENT_GFX_BOY:
-        case OBJECT_EVENT_GFX_BUG_CATCHER:
-        case OBJECT_EVENT_GFX_LASS:
-        case OBJECT_EVENT_GFX_WOMAN_1:
-        case OBJECT_EVENT_GFX_BATTLE_GIRL:
-        case OBJECT_EVENT_GFX_MAN:
-        case OBJECT_EVENT_GFX_ROCKER:
-        case OBJECT_EVENT_GFX_WOMAN_2:
-        case OBJECT_EVENT_GFX_BEAUTY:
-        case OBJECT_EVENT_GFX_BALDING_MAN:
-        case OBJECT_EVENT_GFX_TUBER_F:
-        case OBJECT_EVENT_GFX_CAMPER:
-        case OBJECT_EVENT_GFX_PICNICKER:
-        case OBJECT_EVENT_GFX_COOLTRAINER_M:
-        case OBJECT_EVENT_GFX_COOLTRAINER_F:
-        case OBJECT_EVENT_GFX_SWIMMER_M_LAND:
-        case OBJECT_EVENT_GFX_SWIMMER_F_LAND:
-        case OBJECT_EVENT_GFX_BLACKBELT:
-        case OBJECT_EVENT_GFX_HIKER:
-        case OBJECT_EVENT_GFX_SAILOR:
+        case OBJ_EVENT_GFX_LITTLE_GIRL:
+        case OBJ_EVENT_GFX_YOUNGSTER:
+        case OBJ_EVENT_GFX_BOY:
+        case OBJ_EVENT_GFX_BUG_CATCHER:
+        case OBJ_EVENT_GFX_LASS:
+        case OBJ_EVENT_GFX_WOMAN_1:
+        case OBJ_EVENT_GFX_BATTLE_GIRL:
+        case OBJ_EVENT_GFX_MAN:
+        case OBJ_EVENT_GFX_ROCKER:
+        case OBJ_EVENT_GFX_WOMAN_2:
+        case OBJ_EVENT_GFX_BEAUTY:
+        case OBJ_EVENT_GFX_BALDING_MAN:
+        case OBJ_EVENT_GFX_TUBER_F:
+        case OBJ_EVENT_GFX_CAMPER:
+        case OBJ_EVENT_GFX_PICNICKER:
+        case OBJ_EVENT_GFX_COOLTRAINER_M:
+        case OBJ_EVENT_GFX_COOLTRAINER_F:
+        case OBJ_EVENT_GFX_SWIMMER_M_LAND:
+        case OBJ_EVENT_GFX_SWIMMER_F_LAND:
+        case OBJ_EVENT_GFX_BLACKBELT:
+        case OBJ_EVENT_GFX_HIKER:
+        case OBJ_EVENT_GFX_SAILOR:
             return 0x4e;
-        case OBJECT_EVENT_GFX_TUBER_M_1:
-        case OBJECT_EVENT_GFX_SWIMMER_M_WATER:
-        case OBJECT_EVENT_GFX_SWIMMER_F_WATER:
+        case OBJ_EVENT_GFX_TUBER_M_1:
+        case OBJ_EVENT_GFX_SWIMMER_M_WATER:
+        case OBJ_EVENT_GFX_SWIMMER_F_WATER:
             return 0x4f;
         default:
             return 0x4d;
diff --git a/src/wild_encounter.c b/src/wild_encounter.c
index b32eb583a..cf495db56 100644
--- a/src/wild_encounter.c
+++ b/src/wild_encounter.c
@@ -367,11 +367,11 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
     headerId = GetCurrentMapWildMonHeaderId();
     if (headerId != 0xFFFF)
     {
-        if (sub_8058F1C(currMetatileBehavior, 4) == TRUE)
+        if (GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 4) == TRUE)
         {
             if (gWildMonHeaders[headerId].landMonsInfo == NULL)
                 return FALSE;
-            else if (previousMetatileBehavior != sub_8058F1C(currMetatileBehavior, 0) && !DoGlobalWildEncounterDiceRoll())
+            else if (previousMetatileBehavior != GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0) && !DoGlobalWildEncounterDiceRoll())
                 return FALSE;
             if (DoWildEncounterRateTest(gWildMonHeaders[headerId].landMonsInfo->encounterRate, FALSE) != TRUE)
             {
@@ -387,7 +387,7 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
                     return FALSE;
                 }
 
-                BattleSetup_StartRoamerBattle();
+                StartRoamerBattle();
                 return TRUE;
             }
             else
@@ -396,7 +396,7 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
                 // try a regular wild land encounter
                 if (TryGenerateWildMon(gWildMonHeaders[headerId].landMonsInfo, WILD_AREA_LAND, WILD_CHECK_REPEL) == TRUE)
                 {
-                    BattleSetup_StartWildBattle();
+                    StartWildBattle();
                     return TRUE;
                 }
                 else
@@ -405,12 +405,12 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
                 }
             }
         }
-        else if (sub_8058F1C(currMetatileBehavior, 4) == 2
-                 || (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && MetatileBehavior_IsBridge(sub_8058F1C(currMetatileBehavior, 0)) == TRUE))
+        else if (GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 4) == 2
+                 || (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && MetatileBehavior_IsBridge(GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0)) == TRUE))
         {
             if (gWildMonHeaders[headerId].waterMonsInfo == NULL)
                 return FALSE;
-            else if (previousMetatileBehavior != sub_8058F1C(currMetatileBehavior, 0) && !DoGlobalWildEncounterDiceRoll())
+            else if (previousMetatileBehavior != GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0) && !DoGlobalWildEncounterDiceRoll())
                 return FALSE;
             else if (DoWildEncounterRateTest(gWildMonHeaders[headerId].waterMonsInfo->encounterRate, FALSE) != TRUE)
             {
@@ -426,14 +426,14 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
                     return FALSE;
                 }
 
-                BattleSetup_StartRoamerBattle();
+                StartRoamerBattle();
                 return TRUE;
             }
             else // try a regular surfing encounter
             {
                 if (TryGenerateWildMon(gWildMonHeaders[headerId].waterMonsInfo, WILD_AREA_WATER, WILD_CHECK_REPEL) == TRUE)
                 {
-                    BattleSetup_StartWildBattle();
+                    StartWildBattle();
                     return TRUE;
                 }
                 else
@@ -447,7 +447,7 @@ bool8 StandardWildEncounter(u32 currMetatileBehavior, u16 previousMetatileBehavi
     return FALSE;
 }
 
-void ScrSpecial_RockSmashWildEncounter(void)
+void RockSmashWildEncounter(void)
 {
     u16 headerIdx = GetCurrentMapWildMonHeaderId();
     if (headerIdx == 0xFFFF)
@@ -458,7 +458,7 @@ void ScrSpecial_RockSmashWildEncounter(void)
         gSpecialVar_Result = FALSE;
     else if (TryGenerateWildMon(gWildMonHeaders[headerIdx].rockSmashMonsInfo, WILD_AREA_ROCKS, WILD_CHECK_REPEL) == TRUE)
     {
-        BattleSetup_StartWildBattle();
+        StartWildBattle();
         gSpecialVar_Result = TRUE;
     }
     else
@@ -474,11 +474,11 @@ bool8 SweetScentWildEncounter(void)
     headerId = GetCurrentMapWildMonHeaderId();
     if (headerId != 0xFFFF)
     {
-        if (sub_8058F48(x, y, 4) == 1)
+        if (MapGridGetMetatileAttributeAt(x, y, 4) == 1)
         {
             if (TryStartRoamerEncounter() == TRUE)
             {
-                BattleSetup_StartRoamerBattle();
+                StartRoamerBattle();
                 return TRUE;
             }
 
@@ -487,14 +487,14 @@ bool8 SweetScentWildEncounter(void)
 
             TryGenerateWildMon(gWildMonHeaders[headerId].landMonsInfo, WILD_AREA_LAND, 0);
 
-            BattleSetup_StartWildBattle();
+            StartWildBattle();
             return TRUE;
         }
-        else if (sub_8058F48(x, y, 4) == 2)
+        else if (MapGridGetMetatileAttributeAt(x, y, 4) == 2)
         {
             if (TryStartRoamerEncounter() == TRUE)
             {
-                BattleSetup_StartRoamerBattle();
+                StartRoamerBattle();
                 return TRUE;
             }
 
@@ -502,7 +502,7 @@ bool8 SweetScentWildEncounter(void)
                 return FALSE;
 
             TryGenerateWildMon(gWildMonHeaders[headerId].waterMonsInfo, WILD_AREA_WATER, 0);
-            BattleSetup_StartWildBattle();
+            StartWildBattle();
             return TRUE;
         }
     }
@@ -524,7 +524,7 @@ void FishingWildEncounter(u8 rod)
 {
     GenerateFishingEncounter(gWildMonHeaders[GetCurrentMapWildMonHeaderId()].fishingMonsInfo, rod);
     IncrementGameStat(GAME_STAT_FISHING_CAPTURES);
-    BattleSetup_StartWildBattle();
+    StartWildBattle();
 }
 
 u16 GetLocalWildMon(bool8 *isWaterMon)
@@ -711,7 +711,7 @@ void ResetEncounterRateModifiers(void)
 
 static bool8 HandleWildEncounterCooldown(u32 currMetatileBehavior)
 {
-    u8 unk = sub_8058F1C(currMetatileBehavior, 4);
+    u8 unk = GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 4);
     u32 minSteps;
     u32 encRate;
     if (unk == 0)
@@ -763,19 +763,19 @@ bool8 TryStandardWildEncounter(u32 currMetatileBehavior)
 {
     if (!HandleWildEncounterCooldown(currMetatileBehavior))
     {
-        sWildEncounterData.prevMetatileBehavior = sub_8058F1C(currMetatileBehavior, 0);
+        sWildEncounterData.prevMetatileBehavior = GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0);
         return FALSE;
     }
     else if (StandardWildEncounter(currMetatileBehavior, sWildEncounterData.prevMetatileBehavior) == TRUE)
     {
         sWildEncounterData.encounterRateBuff = 0;
         sWildEncounterData.stepsSinceLastEncounter = 0;
-        sWildEncounterData.prevMetatileBehavior = sub_8058F1C(currMetatileBehavior, 0);
+        sWildEncounterData.prevMetatileBehavior = GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0);
         return TRUE;
     }
     else
     {
-        sWildEncounterData.prevMetatileBehavior = sub_8058F1C(currMetatileBehavior, 0);
+        sWildEncounterData.prevMetatileBehavior = GetMetatileAttributeFromRawMetatileBehavior(currMetatileBehavior, 0);
         return FALSE;
     }
 }
diff --git a/src/wild_pokemon_area.c b/src/wild_pokemon_area.c
index 3c5afaf25..ccdd27b40 100644
--- a/src/wild_pokemon_area.c
+++ b/src/wild_pokemon_area.c
@@ -6,7 +6,7 @@
 #include "overworld.h"
 #include "pokedex_area_markers.h"
 #include "constants/vars.h"
-#include "constants/region_map.h"
+#include "constants/region_map_sections.h"
 #include "constants/species.h"
 
 struct SeviiDexArea
@@ -244,7 +244,7 @@ static s32 CountRoamerNests(u16 species, struct Subsprite * subsprites)
     roamerIdx = GetRoamerIndex(species);
     if (roamerIdx < 0)
         return 0;
-    if (sRoamerPairs[roamerIdx].starter != ScrSpecial_GetStarter())
+    if (sRoamerPairs[roamerIdx].starter != GetStarterSpecies())
         return 0;
     roamerLocation = GetRoamerLocationMapSectionId();
     dexAreaEntryLUTidx = 0;
diff --git a/src/wireless_communication_status_screen.c b/src/wireless_communication_status_screen.c
index 9be2823aa..a284a6d16 100644
--- a/src/wireless_communication_status_screen.c
+++ b/src/wireless_communication_status_screen.c
@@ -13,40 +13,32 @@
 #include "dynamic_placeholder_text_util.h"
 #include "overworld.h"
 #include "sound.h"
+#include "strings.h"
 #include "menu.h"
 #include "librfu.h"
 #include "link_rfu.h"
 #include "union_room.h"
 #include "constants/songs.h"
+#include "constants/union_room.h"
 
 struct WirelessCommunicationStatusScreenStruct
 {
-    u32 field_00[4];
-    u32 field_10[4];
-    u32 field_20[16];
-    u8 field_60;
-    u8 field_61;
+    u32 counts[4];
+    u32 lastCounts[4];
+    u32 activities[16];
+    u8 taskId;
+    u8 rfuTaskId;
     u8 filler_62[0xA];
 };
 
-struct WirelessCommunicationStatusScreenStruct * gUnknown_3002040;
+static struct WirelessCommunicationStatusScreenStruct * sWCSS;
 
-extern const u8 gUnknown_841E2B4[];
-extern const u8 gUnknown_841E2BF[];
-extern const u8 gUnknown_841E2C9[];
-extern const u8 gUnknown_841E2D4[];
-extern const u8 gUnknown_841E245[];
-extern const u8 gUnknown_841E263[];
-extern const u8 gUnknown_841E273[];
-extern const u8 gUnknown_841E284[];
-extern const u8 gUnknown_841E29E[];
+static void CB2_InitWirelessCommunicationScreen(void);
+static void Task_WirelessCommunicationScreen(u8 taskId);
+static void WCSS_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx);
+static bool32 UpdateCommunicationCounts(u32 * counts, u32 * lastCounts, u32 * activities, u8 taskId);
 
-void sub_814F1E4(void);
-void sub_814F46C(u8 taskId);
-void sub_814F65C(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx);
-bool32 sub_814F7E4(u32 * a0, u32 * a1, u32 * a2, u8 taskId);
-
-const u16 gUnknown_846F4D0[][16] = {
+static const u16 sWCSS_Palettes[][16] = {
     INCBIN_U16("graphics/misc/unk_846f4d0.gbapal"),
     INCBIN_U16("graphics/misc/unk_846f4f0.gbapal"),
     INCBIN_U16("graphics/misc/unk_846f510.gbapal"),
@@ -65,10 +57,10 @@ const u16 gUnknown_846F4D0[][16] = {
     INCBIN_U16("graphics/misc/unk_846f6b0.gbapal")
 };
 
-const u32 gUnknown_846F6D0[] = INCBIN_U32("graphics/misc/unk_846f6d0.4bpp.lz");
-const u16 gUnknown_846F8E0[] = INCBIN_U16("graphics/misc/unk_846f8e0.bin");
+static const u32 sBgTilesGfx[] = INCBIN_U32("graphics/misc/unk_846f6d0.4bpp.lz");
+static const u16 sBgTilemap[] = INCBIN_U16("graphics/misc/unk_846f8e0.bin");
 
-const struct BgTemplate gUnknown_846FA74[] = {
+static const struct BgTemplate sBGTemplates[] = {
     {
         .bg = 0,
         .charBaseIndex = 2,
@@ -88,7 +80,7 @@ const struct BgTemplate gUnknown_846FA74[] = {
     }
 };
 
-const struct WindowTemplate gUnknown_846FA7C[] = {
+static const struct WindowTemplate sWindowTemplates[] = {
     {
         .bg = 0x00,
         .tilemapLeft = 0x03,
@@ -116,47 +108,51 @@ const struct WindowTemplate gUnknown_846FA7C[] = {
     }, DUMMY_WIN_TEMPLATE
 };
 
-const u8 *const gUnknown_846FA9C[] = {
+static const u8 *const gUnknown_846FA9C[] = {
     gUnknown_841E2B4,
     gUnknown_841E2BF,
     gUnknown_841E2C9,
     gUnknown_841E2D4
 };
-const u8 *const gUnknown_846FAAC[] = {
-    gUnknown_841E245,
-    gUnknown_841E263,
-    gUnknown_841E273,
-    gUnknown_841E284,
-    gUnknown_841E29E
+
+static const u8 *const sHeaderTextPtrs[] = {
+    gText_WirelessCommunicationStatus,
+    gText_PeopleTrading,
+    gText_PeopleBattling,
+    gText_PeopleInUnionRoom,
+    gText_PeopleCommunicating
 };
 
-const u8 gUnknown_846FAC0[][3] = {
-    {0x01, 0x01, 0x02},
-    {0x02, 0x01, 0x02},
-    {0x03, 0x01, 0x04},
-    {0x04, 0x00, 0x02},
-    {0x15, 0x03, 0x02},
-    {0x16, 0x03, 0x02},
-    {0x09, 0x04, 0x00},
-    {0x0a, 0x04, 0x00},
-    {0x0b, 0x04, 0x00},
-    {0x0c, 0xff, 0x00},
-    {0x0d, 0x00, 0x00},
-    {0x0e, 0xff, 0x00},
-    {0x0f, 0x04, 0x00},
-    {0x10, 0xff, 0x00},
-    {0x40, 0x02, 0x01},
-    {0x41, 0x02, 0x02},
-    {0x44, 0x02, 0x02},
-    {0x45, 0x02, 0x00},
-    {0x48, 0x02, 0x02},
-    {0x54, 0x02, 0x01},
-    {0x53, 0x02, 0x02},
-    {0x51, 0x02, 0x01},
-    {0x52, 0x02, 0x01}
+static const u8 sCountParams[][3] = {
+    // activity,         count idx, by
+    // by=0 means count all
+    // UB: no check for count idx == -1
+    {ACTIVITY_BATTLE,            1, 2},
+    {ACTIVITY_DBLBATTLE,         1, 2},
+    {ACTIVITY_MLTBATTLE,         1, 4},
+    {ACTIVITY_TRADE,             0, 2},
+    {ACTIVITY_WCARD2,            3, 2},
+    {ACTIVITY_WNEWS2,            3, 2},
+    {ACTIVITY_PJUMP,             4, 0},
+    {ACTIVITY_BCRUSH,            4, 0},
+    {ACTIVITY_BPICK,             4, 0},
+    {ACTIVITY_SEARCH,           -1, 0},
+    {ACTIVITY_SPINTRADE,         0, 0},
+    {ACTIVITY_ITEMTRADE,        -1, 0},
+    {0x0f,                       4, 0},
+    {0x10,                      -1, 0},
+    {0x40,                       2, 1},
+    {ACTIVITY_BATTLE | 0x40,     2, 2},
+    {ACTIVITY_TRADE | 0x40,      2, 2},
+    {ACTIVITY_CHAT | 0x40,       2, 0},
+    {ACTIVITY_CARD | 0x40,       2, 2},
+    {20 | 0x40,                  2, 1},
+    {19 | 0x40,                  2, 2},
+    {ACTIVITY_ACCEPT | 0x40,     2, 1},
+    {ACTIVITY_DECLINE | 0x40,    2, 1}
 };
 
-void sub_814F19C(void)
+static void CB2_RunWirelessCommunicationScreen(void)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -168,50 +164,50 @@ void sub_814F19C(void)
     }
 }
 
-void sub_814F1C0(void)
+static void VBlankCB_WirelessCommunicationScreen(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
     TransferPlttBuffer();
 }
 
-void sub_814F1D4(void)
+void ShowWirelessCommunicationScreen(void)
 {
-    SetMainCallback2(sub_814F1E4);
+    SetMainCallback2(CB2_InitWirelessCommunicationScreen);
 }
 
-void sub_814F1E4(void)
+static void CB2_InitWirelessCommunicationScreen(void)
 {
     SetGpuReg(REG_OFFSET_DISPCNT, 0);
-    gUnknown_3002040 = AllocZeroed(sizeof(*gUnknown_3002040));
+    sWCSS = AllocZeroed(sizeof(*sWCSS));
     SetVBlankCallback(NULL);
-    ResetBgsAndClearDma3BusyFlags(0);
-    InitBgsFromTemplates(0, gUnknown_846FA74, NELEMS(gUnknown_846FA74));
+    ResetBgsAndClearDma3BusyFlags(FALSE);
+    InitBgsFromTemplates(0, sBGTemplates, NELEMS(sBGTemplates));
     SetBgTilemapBuffer(1, Alloc(0x800));
     SetBgTilemapBuffer(0, Alloc(0x800));
-    DecompressAndLoadBgGfxUsingHeap(1, gUnknown_846F6D0, 0, 0, 0);
-    CopyToBgTilemapBuffer(1, gUnknown_846F8E0, 0, 0);
-    InitWindows(gUnknown_846FA7C);
+    DecompressAndLoadBgGfxUsingHeap(1, sBgTilesGfx, 0, 0, 0);
+    CopyToBgTilemapBuffer(1, sBgTilemap, 0, 0);
+    InitWindows(sWindowTemplates);
     DeactivateAllTextPrinters();
     ResetPaletteFade();
     ResetSpriteData();
     ResetTasks();
     ScanlineEffect_Stop();
     m4aSoundVSyncOn();
-    SetVBlankCallback(sub_814F1C0);
-    gUnknown_3002040->field_60 = CreateTask(sub_814F46C, 0);
-    gUnknown_3002040->field_61 = sub_8116DE0();
-    gUnknown_3002040->field_10[3] = 1;
+    SetVBlankCallback(VBlankCB_WirelessCommunicationScreen);
+    sWCSS->taskId = CreateTask(Task_WirelessCommunicationScreen, 0);
+    sWCSS->rfuTaskId = CreateTask_ListenToWireless();
+    sWCSS->lastCounts[3] = 1;
     ChangeBgX(0, 0, 0);
     ChangeBgY(0, 0, 0);
     ChangeBgX(1, 0, 0);
     ChangeBgY(1, 0, 0);
-    LoadPalette(gUnknown_846F4D0, 0, 0x20);
+    LoadPalette(sWCSS_Palettes, 0, 0x20);
     Menu_LoadStdPalAt(0xf0);
     DynamicPlaceholderTextUtil_Reset();
     FillBgTilemapBufferRect(0, 0x000, 0, 0, 32, 32, 0xF);
     CopyBgTilemapBufferToVram(1);
-    SetMainCallback2(sub_814F19C);
+    SetMainCallback2(CB2_RunWirelessCommunicationScreen);
     RunTasks();
     RunTextPrinters();
     AnimateSprites();
@@ -219,7 +215,7 @@ void sub_814F1E4(void)
     UpdatePaletteFade();
 }
 
-void sub_814F32C(void)
+static void ExitWirelessCommunicationStatusScreen(void)
 {
     s32 i;
 
@@ -228,55 +224,55 @@ void sub_814F32C(void)
     {
         Free(GetBgTilemapBuffer(i));
     }
-    Free(gUnknown_3002040);
+    Free(sWCSS);
     SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
-void sub_814F364(s16 * unk0, s16 * unk1)
+static void WCSS_CyclePalette(s16 * frameCtr_p, s16 * palIdx_p)
 {
     s32 idx;
-    (*unk0)++;
-    if (*unk0 > 5)
+    (*frameCtr_p)++;
+    if (*frameCtr_p > 5)
     {
-        (*unk1)++;
-        if (*unk1 == 14)
+        (*palIdx_p)++;
+        if (*palIdx_p == 14)
         {
-            *unk1 = 0;
+            *palIdx_p = 0;
         }
-        *unk0 = 0;
+        *frameCtr_p = 0;
     }
-    idx = *unk1 + 2;
-    LoadPalette(gUnknown_846F4D0[idx], 0, 16);
+    idx = *palIdx_p + 2;
+    LoadPalette(sWCSS_Palettes[idx], 0, 16);
 }
 
-void sub_814F3A8(void)
+static void PrintHeaderTexts(void)
 {
     s32 i;
     u32 width;
 
-    FillWindowPixelBuffer(0, 0);
-    FillWindowPixelBuffer(1, 0);
-    FillWindowPixelBuffer(2, 0);
-    width = 0xC0 - GetStringWidth(3, gUnknown_846FAAC[0], 0);
-    sub_814F65C(0, 3, gUnknown_846FAAC[0], width / 2, 6, 3);
+    FillWindowPixelBuffer(0, PIXEL_FILL(0));
+    FillWindowPixelBuffer(1, PIXEL_FILL(0));
+    FillWindowPixelBuffer(2, PIXEL_FILL(0));
+    width = 0xC0 - GetStringWidth(3, sHeaderTextPtrs[0], 0);
+    WCSS_AddTextPrinterParameterized(0, 3, sHeaderTextPtrs[0], width / 2, 6, 3);
     for (i = 0; i < 3; i++)
     {
-        sub_814F65C(1, 3, gUnknown_846FAAC[i + 1], 0, 30 * i + 10, 1);
+        WCSS_AddTextPrinterParameterized(1, 3, sHeaderTextPtrs[i + 1], 0, 30 * i + 10, 1);
     }
-    sub_814F65C(1, 3, gUnknown_846FAAC[i + 1], 0, 30 * i + 10, 2);
+    WCSS_AddTextPrinterParameterized(1, 3, sHeaderTextPtrs[i + 1], 0, 30 * i + 10, 2);
     PutWindowTilemap(0);
     CopyWindowToVram(0, 2);
     PutWindowTilemap(1);
     CopyWindowToVram(1, 2);
 }
 
-void sub_814F46C(u8 taskId)
+static void Task_WirelessCommunicationScreen(u8 taskId)
 {
     s32 i;
     switch (gTasks[taskId].data[0])
     {
     case 0:
-        sub_814F3A8();
+        PrintHeaderTexts();
         gTasks[taskId].data[0]++;
         break;
     case 1:
@@ -291,16 +287,16 @@ void sub_814F46C(u8 taskId)
             gTasks[taskId].data[0]++;
         break;
     case 3:
-        if (sub_814F7E4(gUnknown_3002040->field_00, gUnknown_3002040->field_10, gUnknown_3002040->field_20, gUnknown_3002040->field_61))
+        if (UpdateCommunicationCounts(sWCSS->counts, sWCSS->lastCounts, sWCSS->activities, sWCSS->rfuTaskId))
         {
-            FillWindowPixelBuffer(2, 0x00);
+            FillWindowPixelBuffer(2, PIXEL_FILL(0));
             for (i = 0; i < 4; i++)
             {
-                ConvertIntToDecimalStringN(gStringVar4, gUnknown_3002040->field_00[i], STR_CONV_MODE_RIGHT_ALIGN, 2);
+                ConvertIntToDecimalStringN(gStringVar4, sWCSS->counts[i], STR_CONV_MODE_RIGHT_ALIGN, 2);
                 if (i != 3)
-                    sub_814F65C(2, 3, gStringVar4, 4, 30 * i + 10, 1);
+                    WCSS_AddTextPrinterParameterized(2, 3, gStringVar4, 4, 30 * i + 10, 1);
                 else
-                    sub_814F65C(2, 3, gStringVar4, 4, 100, 2);
+                    WCSS_AddTextPrinterParameterized(2, 3, gStringVar4, 4, 100, 2);
             }
             PutWindowTilemap(2);
             CopyWindowToVram(2, 3);
@@ -308,10 +304,10 @@ void sub_814F46C(u8 taskId)
         if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON))
         {
             PlaySE(SE_SELECT);
-            gTasks[gUnknown_3002040->field_61].data[15] = 0xFF;
+            gTasks[sWCSS->rfuTaskId].data[15] = 0xFF;
             gTasks[taskId].data[0]++;
         }
-        sub_814F364(&gTasks[taskId].data[7], &gTasks[taskId].data[8]);
+        WCSS_CyclePalette(&gTasks[taskId].data[7], &gTasks[taskId].data[8]);
         break;
     case 4:
         BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
@@ -320,117 +316,117 @@ void sub_814F46C(u8 taskId)
     case 5:
         if (!gPaletteFade.active)
         {
-            SetMainCallback2(sub_814F32C);
+            SetMainCallback2(ExitWirelessCommunicationStatusScreen);
             DestroyTask(taskId);
         }
         break;
     }
 }
 
-void sub_814F65C(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx)
+static void WCSS_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx)
 {
     u8 textColor[3];
     switch (palIdx)
     {
     case 0:
-        textColor[0] = 0;
-        textColor[1] = 2;
-        textColor[2] = 3;
+        textColor[0] = TEXT_COLOR_TRANSPARENT;
+        textColor[1] = TEXT_COLOR_DARK_GREY;
+        textColor[2] = TEXT_COLOR_LIGHT_GREY;
         break;
     case 1:
-        textColor[0] = 0;
-        textColor[1] = 1;
-        textColor[2] = 3;
+        textColor[0] = TEXT_COLOR_TRANSPARENT;
+        textColor[1] = TEXT_COLOR_WHITE;
+        textColor[2] = TEXT_COLOR_LIGHT_GREY;
         break;
     case 2:
-        textColor[0] = 0;
-        textColor[1] = 4;
-        textColor[2] = 5;
+        textColor[0] = TEXT_COLOR_TRANSPARENT;
+        textColor[1] = TEXT_COLOR_RED;
+        textColor[2] = TEXT_COLOR_LIGHT_RED;
         break;
     case 3:
-        textColor[0] = 0;
-        textColor[1] = 7;
-        textColor[2] = 6;
+        textColor[0] = TEXT_COLOR_TRANSPARENT;
+        textColor[1] = TEXT_COLOR_LIGHT_GREEN;
+        textColor[2] = TEXT_COLOR_GREEN;
         break;
     case 4:
-        textColor[0] = 0;
-        textColor[1] = 1;
-        textColor[2] = 2;
+        textColor[0] = TEXT_COLOR_TRANSPARENT;
+        textColor[1] = TEXT_COLOR_WHITE;
+        textColor[2] = TEXT_COLOR_DARK_GREY;
         break;
     // default: UB
     }
     AddTextPrinterParameterized4(windowId, fontId,x, y, fontId == 0 ? 0 : 1, 0, textColor, -1, str);
 }
 
-u32 sub_814F714(struct UnkStruct_x20 * unk20, u32 * arg1)
+static u32 CountMembersInGroup(struct UnkStruct_x20 * unk20, u32 * counts)
 {
-    u32 r8 = unk20->unk.gname.unk_0a_0;
+    u32 activity = unk20->gname_uname.gname.activity;
     s32 i, j, k;
 
-    for (i = 0; i < NELEMS(gUnknown_846FAC0); i++)
+    for (i = 0; i < NELEMS(sCountParams); i++)
     {
-        if (r8 == gUnknown_846FAC0[i][0] && unk20->field_1A_0 == 1)
+        if (activity == sCountParams[i][0] && unk20->groupScheduledAnim == UNION_ROOM_SPAWN_IN)
         {
-            if (gUnknown_846FAC0[i][2] == 0)
+            if (sCountParams[i][2] == 0)
             {
                 k = 0;
-                for (j = 0; j < 4; j++)
+                for (j = 0; j < RFU_CHILD_MAX; j++)
                 {
-                    if (unk20->unk.gname.unk_04[j] != 0) k++;
+                    if (unk20->gname_uname.gname.child_sprite_gender[j] != 0) k++;
                 }
                 k++;
-                arg1[gUnknown_846FAC0[i][1]] += k;
+                counts[sCountParams[i][1]] += k;
             }
             else
             {
-                arg1[gUnknown_846FAC0[i][1]] += gUnknown_846FAC0[i][2];
+                counts[sCountParams[i][1]] += sCountParams[i][2];
             }
         }
     }
 
-    return r8;
+    return activity;
 }
 
-bool32 sub_814F7BC(const u32 * ptr0, const u32 * ptr1)
+static bool32 HaveCountsChanged(const u32 * newCounts, const u32 * prevCounts)
 {
     s32 i;
 
     for (i = 0; i < 4; i++)
     {
-        if (ptr0[i] != ptr1[i])
+        if (newCounts[i] != prevCounts[i])
             return TRUE;
     }
 
     return FALSE;
 }
 
-bool32 sub_814F7E4(u32 * a0, u32 * a1, u32 * a2, u8 taskId)
+static bool32 UpdateCommunicationCounts(u32 * counts, u32 * lastCounts, u32 * activities, u8 taskId)
 {
-    bool32 r8 = FALSE;
-    u32 sp0[4] = {0, 0, 0, 0};
+    bool32 activitiesUpdated = FALSE;
+    u32 buffer[4] = {0, 0, 0, 0};
     struct UnkStruct_Group * group = (void *)gTasks[taskId].data;
     s32 i;
 
     for (i = 0; i < 16; i++)
     {
-        u32 r1 = sub_814F714(&group->field_0->arr[i], sp0);
-        if (r1 != a2[i])
+        u32 activity = CountMembersInGroup(&group->field_0->arr[i], buffer);
+        if (activity != activities[i])
         {
-            a2[i] = r1;
-            r8 = TRUE;
+            activities[i] = activity;
+            activitiesUpdated = TRUE;
         }
     }
 
-    if (sub_814F7BC(sp0, a1) == FALSE)
+    if (HaveCountsChanged(buffer, lastCounts) == FALSE)
     {
-        if (r8 == TRUE)
+        if (activitiesUpdated == TRUE)
             return TRUE;
         else
             return FALSE;
     }
 
-    memcpy(a0, sp0, sizeof(sp0));
-    memcpy(a1, sp0, sizeof(sp0));
-    a0[3] = a0[0] + a0[1] + a0[2];
+    memcpy(counts, buffer, sizeof(buffer));
+    memcpy(lastCounts, buffer, sizeof(buffer));
+    counts[3] = counts[0] + counts[1] + counts[2];
     return TRUE;
 }