Merge pull request #253 from PikalaxALT/add_arm_agbcc

librfu_intr

53 files changed, 7632 insertions, 6813 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/battle_controller_player.c b/src/battle_controller_player.c
index cb9e04a50..7b0a8aa47 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -831,9 +831,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_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_main.c b/src/battle_main.c
index 76f373f8f..3f20399f6 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -1152,9 +1152,9 @@ static void CB2_PreInitMultiBattle(void)
         {
             ++gBattleCommunication[MULTIUSE_STATE];
             if (gWirelessCommType)
-                sub_800AB9C();
+                PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             else
-                sub_800AAC0();
+                Link_TryStartSend5FFF();
         }
         break;
     case 3:
diff --git a/src/digit_obj_util.c b/src/digit_obj_util.c
new file mode 100644
index 000000000..af2618615
--- /dev/null
+++ b/src/digit_obj_util.c
@@ -0,0 +1,449 @@
+#include "global.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "digit_obj_util.h"
+#include "main.h"
+#include "battle.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
+    }
+};
+
+// 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->tag);
+    if (sOamWork->array[id].tileStart == 0xFFFF)
+    {
+        if (template->spriteSheet->size != 0)
+        {
+            sOamWork->array[id].tileStart = LoadSpriteSheet(template->spriteSheet);
+        }
+        else
+        {
+            struct CompressedSpriteSheet compObjectPic;
+
+            compObjectPic = *(struct CompressedSpriteSheet*)(template->spriteSheet);
+            compObjectPic.size = GetDecompressedDataSize(template->spriteSheet->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->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/dodrio_berry_picking_2.c b/src/dodrio_berry_picking_2.c
index fc6aa14c6..4260c6f2f 100644
--- a/src/dodrio_berry_picking_2.c
+++ b/src/dodrio_berry_picking_2.c
@@ -7,7 +7,7 @@ void sub_815A5BC(s32 a0)
     struct Padded_U8 data[2];
     data[0].value = 1;
     data[1].value = a0;
-    sub_80F9E2C(data);
+    RfuPrepareSend0x2f00(data);
 }
 
 u8 sub_815A5E8(s32 a0)
diff --git a/src/dynamic_placeholder_text_util.c b/src/dynamic_placeholder_text_util.c
index 6909fea30..a2622bf02 100644
--- a/src/dynamic_placeholder_text_util.c
+++ b/src/dynamic_placeholder_text_util.c
@@ -2,16 +2,89 @@
 #include "text.h"
 #include "dynamic_placeholder_text_util.h"
 #include "string_util.h"
+#include "constants/object_events.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
+    [OBJECT_EVENT_GFX_RED_NORMAL / 2]              = 0x00, // OBJECT_EVENT_GFX_RED_BIKE
+    [OBJECT_EVENT_GFX_RED_RUN / 2]                 = 0x00, // OBJECT_EVENT_GFX_RED_ITEM
+    [OBJECT_EVENT_GFX_RED_FISH / 2]                = 0x00, // OBJECT_EVENT_GFX_RED_ITEM_COPY
+    [OBJECT_EVENT_GFX_RED_VS_SEEKER / 2]           = 0x10, // OBJECT_EVENT_GFX_GREEN_NORMAL
+    [OBJECT_EVENT_GFX_GREEN_BIKE / 2]              = 0x11, // OBJECT_EVENT_GFX_GREEN_RUN
+    [OBJECT_EVENT_GFX_GREEN_ITEM / 2]              = 0x11, // OBJECT_EVENT_GFX_GREEN_FISH
+    [OBJECT_EVENT_GFX_GREEN_ITEM_COPY / 2]         = 0x11, // OBJECT_EVENT_GFX_GREEN_VS_SEEKER
+    [OBJECT_EVENT_GFX_RS_BRENDAN / 2]              = 0x10, // OBJECT_EVENT_GFX_RS_MAY
+    [OBJECT_EVENT_GFX_LITTLE_BOY / 2]              = 0x10, // OBJECT_EVENT_GFX_LITTLE_GIRL
+    [OBJECT_EVENT_GFX_YOUNGSTER / 2]               = 0x00, // OBJECT_EVENT_GFX_BOY
+    [OBJECT_EVENT_GFX_BUG_CATCHER / 2]             = 0x00, // OBJECT_EVENT_GFX_SITTING_BOY
+    [OBJECT_EVENT_GFX_LASS / 2]                    = 0x11, // OBJECT_EVENT_GFX_WOMAN_1
+    [OBJECT_EVENT_GFX_BATTLE_GIRL / 2]             = 0x01, // OBJECT_EVENT_GFX_MAN
+    [OBJECT_EVENT_GFX_ROCKER / 2]                  = 0x00, // OBJECT_EVENT_GFX_FAT_MAN
+    [OBJECT_EVENT_GFX_WOMAN_2 / 2]                 = 0x11, // OBJECT_EVENT_GFX_BEAUTY
+    [OBJECT_EVENT_GFX_BALDING_MAN / 2]             = 0x10, // OBJECT_EVENT_GFX_WOMAN_3
+    [OBJECT_EVENT_GFX_OLD_MAN_1 / 2]               = 0x00, // OBJECT_EVENT_GFX_OLD_MAN_2
+    [OBJECT_EVENT_GFX_OLD_MAN_LYING_DOWN / 2]      = 0x10, // OBJECT_EVENT_GFX_OLD_WOMAN
+    [OBJECT_EVENT_GFX_TUBER_M_1 / 2]               = 0x10, // OBJECT_EVENT_GFX_TUBER_F
+    [OBJECT_EVENT_GFX_TUBER_M_2 / 2]               = 0x00, // OBJECT_EVENT_GFX_CAMPER
+    [OBJECT_EVENT_GFX_PICNICKER / 2]               = 0x01, // OBJECT_EVENT_GFX_COOLTRAINER_M
+    [OBJECT_EVENT_GFX_COOLTRAINER_F / 2]           = 0x01, // OBJECT_EVENT_GFX_SWIMMER_M_WATER
+    [OBJECT_EVENT_GFX_SWIMMER_F_WATER / 2]         = 0x01, // OBJECT_EVENT_GFX_SWIMMER_M_LAND
+    [OBJECT_EVENT_GFX_SWIMMER_F_LAND / 2]          = 0x01, // OBJECT_EVENT_GFX_WORKER_M
+    [OBJECT_EVENT_GFX_WORKER_F / 2]                = 0x01, // OBJECT_EVENT_GFX_ROCKET_M
+    [OBJECT_EVENT_GFX_ROCKET_F / 2]                = 0x01, // OBJECT_EVENT_GFX_GBA_KID
+    [OBJECT_EVENT_GFX_SUPER_NERD / 2]              = 0x00, // OBJECT_EVENT_GFX_BIKER
+    [OBJECT_EVENT_GFX_BLACKBELT / 2]               = 0x00, // OBJECT_EVENT_GFX_SCIENTIST
+    [OBJECT_EVENT_GFX_HIKER / 2]                   = 0x00, // OBJECT_EVENT_GFX_FISHER
+    [OBJECT_EVENT_GFX_CHANNELER / 2]               = 0x01, // OBJECT_EVENT_GFX_CHEF
+    [OBJECT_EVENT_GFX_POLICEMAN / 2]               = 0x00, // OBJECT_EVENT_GFX_GENTLEMAN
+    [OBJECT_EVENT_GFX_SAILOR / 2]                  = 0x00, // OBJECT_EVENT_GFX_CAPTAIN
+    [OBJECT_EVENT_GFX_NURSE / 2]                   = 0x11, // OBJECT_EVENT_GFX_CABLE_CLUB_RECEPTIONIST
+    [OBJECT_EVENT_GFX_UNION_ROOM_RECEPTIONIST / 2] = 0x01, // OBJECT_EVENT_GFX_UNUSED_MALE_RECEPTIONIST
+    [OBJECT_EVENT_GFX_CLERK / 2]                   = 0x00, // OBJECT_EVENT_GFX_MG_DELIVERYMAN
+    [OBJECT_EVENT_GFX_TRAINER_TOWER_DUDE / 2]      = 0x00, // OBJECT_EVENT_GFX_PROF_OAK
+    [OBJECT_EVENT_GFX_BLUE / 2]                    = 0x00, // OBJECT_EVENT_GFX_BILL
+    [OBJECT_EVENT_GFX_LANCE / 2]                   = 0x10, // OBJECT_EVENT_GFX_AGATHA
+    [OBJECT_EVENT_GFX_DAISY / 2]                   = 0x11, // OBJECT_EVENT_GFX_LORELEI
+    [OBJECT_EVENT_GFX_MR_FUJI / 2]                 = 0x00, // OBJECT_EVENT_GFX_BRUNO
+    [OBJECT_EVENT_GFX_BROCK / 2]                   = 0x10, // OBJECT_EVENT_GFX_MISTY
+    [OBJECT_EVENT_GFX_LT_SURGE / 2]                = 0x10, // OBJECT_EVENT_GFX_ERIKA
+    [OBJECT_EVENT_GFX_KOGA / 2]                    = 0x10, // OBJECT_EVENT_GFX_SABRINA
+    [OBJECT_EVENT_GFX_BLAINE / 2]                  = 0x00, // OBJECT_EVENT_GFX_GIOVANNI
+    [OBJECT_EVENT_GFX_MOM / 2]                     = 0x01, // OBJECT_EVENT_GFX_CELIO
+    [OBJECT_EVENT_GFX_TEACHY_TV_HOST / 2]          = 0x00, // OBJECT_EVENT_GFX_GYM_GUY
+    [OBJECT_EVENT_GFX_ITEM_BALL / 2]               = 0x33, // OBJECT_EVENT_GFX_TOWN_MAP
+    [OBJECT_EVENT_GFX_POKEDEX / 2]                 = 0x33, // OBJECT_EVENT_GFX_CUT_TREE
+    [OBJECT_EVENT_GFX_ROCK_SMASH_ROCK / 2]         = 0x33, // OBJECT_EVENT_GFX_STRENGTH_BOULDER
+    [OBJECT_EVENT_GFX_FOSSIL / 2]                  = 0x33, // OBJECT_EVENT_GFX_RUBY
+    [OBJECT_EVENT_GFX_SAPPHIRE / 2]                = 0x33, // OBJECT_EVENT_GFX_OLD_AMBER
+    [OBJECT_EVENT_GFX_GYM_SIGN / 2]                = 0x33, // OBJECT_EVENT_GFX_SIGN
+    [OBJECT_EVENT_GFX_TRAINER_TIPS / 2]            = 0x33, // OBJECT_EVENT_GFX_CLIPBOARD
+    [OBJECT_EVENT_GFX_METEORITE / 2]               = 0x33, // OBJECT_EVENT_GFX_LAPRAS_DOLL
+    [OBJECT_EVENT_GFX_SEAGALLOP / 2]               = 0x23, // OBJECT_EVENT_GFX_SNORLAX
+    [OBJECT_EVENT_GFX_SPEAROW / 2]                 = 0x22, // OBJECT_EVENT_GFX_CUBONE
+    [OBJECT_EVENT_GFX_POLIWRATH / 2]               = 0x22, // OBJECT_EVENT_GFX_CLEFAIRY
+    [OBJECT_EVENT_GFX_PIDGEOT / 2]                 = 0x22, // OBJECT_EVENT_GFX_JIGGLYPUFF
+    [OBJECT_EVENT_GFX_PIDGEY / 2]                  = 0x22, // OBJECT_EVENT_GFX_CHANSEY
+    [OBJECT_EVENT_GFX_OMANYTE / 2]                 = 0x22, // OBJECT_EVENT_GFX_KANGASKHAN
+    [OBJECT_EVENT_GFX_PIKACHU / 2]                 = 0x22, // OBJECT_EVENT_GFX_PSYDUCK
+    [OBJECT_EVENT_GFX_NIDORAN_F / 2]               = 0x22, // OBJECT_EVENT_GFX_NIDORAN_M
+    [OBJECT_EVENT_GFX_NIDORINO / 2]                = 0x22, // OBJECT_EVENT_GFX_MEOWTH
+    [OBJECT_EVENT_GFX_SEEL / 2]                    = 0x22, // OBJECT_EVENT_GFX_VOLTORB
+    [OBJECT_EVENT_GFX_SLOWPOKE / 2]                = 0x22, // OBJECT_EVENT_GFX_SLOWBRO
+    [OBJECT_EVENT_GFX_MACHOP / 2]                  = 0x22, // OBJECT_EVENT_GFX_WIGGLYTUFF
+    [OBJECT_EVENT_GFX_DODUO / 2]                   = 0x22, // OBJECT_EVENT_GFX_FEAROW
+    [OBJECT_EVENT_GFX_MACHOKE / 2]                 = 0x22, // OBJECT_EVENT_GFX_LAPRAS
+    [OBJECT_EVENT_GFX_ZAPDOS / 2]                  = 0x22, // OBJECT_EVENT_GFX_MOLTRES
+    [OBJECT_EVENT_GFX_ARTICUNO / 2]                = 0x22, // OBJECT_EVENT_GFX_MEWTWO
+    [OBJECT_EVENT_GFX_MEW / 2]                     = 0x22, // OBJECT_EVENT_GFX_ENTEI
+    [OBJECT_EVENT_GFX_SUICUNE / 2]                 = 0x22, // OBJECT_EVENT_GFX_RAIKOU
+    [OBJECT_EVENT_GFX_LUGIA / 2]                   = 0x22, // OBJECT_EVENT_GFX_HO_OH
+    [OBJECT_EVENT_GFX_CELEBI / 2]                  = 0x22, // OBJECT_EVENT_GFX_KABUTO
+    [OBJECT_EVENT_GFX_DEOXYS_D / 2]                = 0x22, // OBJECT_EVENT_GFX_DEOXYS_A
+    [OBJECT_EVENT_GFX_DEOXYS_N / 2]                = 0x32, // OBJECT_EVENT_GFX_SS_ANNE
 };
 
 void DynamicPlaceholderTextUtil_Reset(void)
@@ -63,7 +136,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/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..74d1cf608 100644
--- a/src/event_data.c
+++ b/src/event_data.c
@@ -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);
diff --git a/src/event_object_80688E4.c b/src/event_object_80688E4.c
index 133052642..2d79c4f7b 100644
--- a/src/event_object_80688E4.c
+++ b/src/event_object_80688E4.c
@@ -524,12 +524,12 @@ void RfuUnionObjectSetFacingDirection(u8 objectEventId, u8 direction)
     }
 }
 
-void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 arg1)
+void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 invisible)
 {
     u8 spriteId = GetObjectEventSpriteId(objectEventId);
     if (spriteId != MAX_SPRITES)
     {
-        if (arg1)
+        if (invisible)
             gSprites[spriteId].tInvisible = TRUE;
         else
             gSprites[spriteId].tInvisible = FALSE;
@@ -544,12 +544,12 @@ bool32 RfuUnionObjectIsInvisible(u8 objectEventId)
     return gSprites[spriteId].tInvisible == TRUE;
 }
 
-void RfuUnionObjectStartWarp(u8 objectEventId, u8 direction)
+void RfuUnionObjectStartWarp(u8 objectEventId, u8 animNo)
 {
     u8 spriteId = GetObjectEventSpriteId(objectEventId);
     if (spriteId != MAX_SPRITES)
     {
-        gSprites[spriteId].tUnionRoomWarpAnimNo = direction;
+        gSprites[spriteId].tUnionRoomWarpAnimNo = animNo;
         gSprites[spriteId].tUnionRoomWarpAnimState = 0;
     }
 }
diff --git a/src/event_object_lock.c b/src/event_object_lock.c
index cf500054f..304b71c28 100644
--- a/src/event_object_lock.c
+++ b/src/event_object_lock.c
@@ -93,7 +93,7 @@ void sub_80696C0(void)
     UnfreezeObjectEvents();
 }
 
-void sub_80696F0(void)
+void UnionRoom_UnlockPlayerAndChatPartner(void)
 {
     u8 objectEventId;
     if (gObjectEvents[gSelectedObjectEvent].active)
diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c
index 42fe26c91..2e1dcd919 100644
--- a/src/field_fadetransition.c
+++ b/src/field_fadetransition.c
@@ -206,7 +206,7 @@ static void sub_807DDF0(u8 taskId)
     switch (task->data[0])
     {
     case 0:
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         task->data[0]++;
         break;
     case 1:
@@ -227,7 +227,7 @@ static void sub_807DDF0(u8 taskId)
     }
 }
 
-void sub_807DE58(void)
+void FieldCB_ReturnToFieldWirelessLink(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
@@ -632,7 +632,7 @@ static void sub_807E5EC(u8 taskId)
         break;
     case 2:
         WarpIntoMap();
-        SetMainCallback2(sub_8056788);
+        SetMainCallback2(CB2_ReturnToFieldCableClub);
         DestroyTask(taskId);
         break;
     }
@@ -662,7 +662,7 @@ static void sub_807E678(u8 taskId)
     case 1:
         if (!sub_807E40C() && BGMusicStopped())
         {
-            sub_800AAC0();
+            Link_TryStartSend5FFF();
             data[0]++;
         }
         break;
diff --git a/src/field_specials.c b/src/field_specials.c
index bb320d42a..bd19a0477 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -1920,15 +1920,15 @@ u16 Special_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;
diff --git a/src/fieldmap.c b/src/fieldmap.c
index adb26f230..0844087e0 100644
--- a/src/fieldmap.c
+++ b/src/fieldmap.c
@@ -490,7 +490,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 < VMap.Xsize
         && y >= 0 && y < VMap.Ysize)
diff --git a/src/help_system.c b/src/help_system.c
index 4a4d927c5..bb3135260 100644
--- a/src/help_system.c
+++ b/src/help_system.c
@@ -33,7 +33,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 +53,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))
         {
@@ -93,9 +93,9 @@ u8 RunHelpSystemCallback(void)
         HelpSystem_PrintText_Row61(gString_Help);
         sub_813BD14(1);
         if (sub_812B40C() == TRUE)
-            sub_812BC54(&gHelpSystemListMenu, gHelpSystemListMenuItems);
+            HelpSystemSubroutine_PrintWelcomeMessage(&gHelpSystemListMenu, gHelpSystemListMenuItems);
         else
-            sub_812BCA8(&gHelpSystemListMenu, gHelpSystemListMenuItems);
+            HelpSystemSubroutine_WelcomeEndGotoMenu(&gHelpSystemListMenu, gHelpSystemListMenuItems);
         sub_813BE78(1);
         sub_813BF50(1);
         CommitTilemap();
@@ -110,7 +110,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 +981,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 +1007,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 +1051,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 +1071,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,7 +1086,7 @@ void PlaceListMenuCursor(void)
 {
     u8 glyphHeight = GetFontAttribute(2, 1) + 1;
     u8 x = gHelpSystemListMenu.sub.left;
-    u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.field_0D;
+    u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.cursorPos;
     HelpSystem_PrintTextAt(gFameCheckerText_ListMenuCursor, x, y);
 }
 
@@ -1107,24 +1107,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 +1134,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 +1159,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,14 +1172,14 @@ 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);
diff --git a/src/help_system_812B1E0.c b/src/help_system_812B1E0.c
index df892152a..5b634a273 100644
--- a/src/help_system_812B1E0.c
+++ b/src/help_system_812B1E0.c
@@ -19,22 +19,22 @@
 static EWRAM_DATA u16 sSomeVariable = 0;
 static EWRAM_DATA u8 gUnknown_203B0EE = 0;
 
-u8 gUnknown_3005E9C[4];
+u8 sHelpSystemState[4];
 u16 gSomeVariableBackup;
 
 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[] = {
+static void BuildMainTopicsListAndMoveToH00(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
+static void SetHelpSystemSubmenuItems(struct HelpSystemListMenu * a0, struct ListMenuItem * a1);
+static bool8 HelpSystem_HasDefeatedBrock(void);
+static bool8 HelpSystemSubmenuIndexIsActive(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);
+
+static const u8 *const sHelpSystemTopicPtrs[] = {
     gUnknown_81B2DF8,
     gUnknown_81B2E1C,
     gUnknown_81B2E2E,
@@ -43,7 +43,7 @@ static const u8 *const gUnknown_845B080[] = {
     gUnknown_81B2E6A
 };
 
-static const u8 *const gUnknown_845B098[] = {
+static const u8 *const sHelpSystemTopicMouseoverDescriptionPtrs[] = {
     gUnknown_81B2E88,
     gUnknown_81B2EC8,
     gUnknown_81B2F00,
@@ -52,7 +52,7 @@ static const u8 *const gUnknown_845B098[] = {
     gUnknown_81B2FA9
 };
 
-static const u8 *const gUnknown_845B0B0[] = {
+static const u8 *const sHelpSystemSpecializedQuestionTextPtrs[] = {
     NULL,
     gUnknown_81B3083,
     gUnknown_81B30A9,
@@ -100,7 +100,7 @@ static const u8 *const gUnknown_845B0B0[] = {
     gUnknown_81B3516
 };
 
-static const u8 *const gUnknown_845B164[] = {
+static const u8 *const sHelpSystemSpecializedAnswerTextPtrs[] = {
     NULL,
     gUnknown_81B3525,
     gUnknown_81B35E6,
@@ -148,7 +148,7 @@ static const u8 *const gUnknown_845B164[] = {
     gUnknown_81B55F4
 };
 
-static const u8 *const gUnknown_845B218[] = {
+static const u8 *const sHelpSystemMenuTopicTextPtrs[] = {
     NULL,
     gUnknown_81B56E3,
     gUnknown_81B56F4,
@@ -200,7 +200,7 @@ static const u8 *const gUnknown_845B218[] = {
     gUnknown_81B5A37
 };
 
-static const u8 *const gUnknown_845B2DC[] = {
+static const u8 *const sHelpSystemSpecializedControlsTextPtrs[] = {
     NULL,
     gUnknown_81B5A4D,
     gUnknown_81B5B0C,
@@ -252,7 +252,7 @@ static const u8 *const gUnknown_845B2DC[] = {
     gUnknown_81B7C57
 };
 
-static const u8 *const gUnknown_845B3A0[] = {
+static const u8 *const sHelpSystemSpecializedStringsTextPtrs[] = {
     NULL,
     gUnknown_81B7CC1,
     gUnknown_81B7CC4,
@@ -299,7 +299,7 @@ static const u8 *const gUnknown_845B3A0[] = {
     gUnknown_81B7E0F
 };
 
-static const u8 *const gUnknown_845B450[] = {
+static const u8 *const sHelpSystemSpecializedStringDefinitionsTextPtrs[] = {
     NULL,
     gUnknown_81B7E16,
     gUnknown_81B7F0A,
@@ -346,7 +346,7 @@ static const u8 *const gUnknown_845B450[] = {
     gUnknown_81B9B2F
 };
 
-static const u8 *const gUnknown_845B500[] = {
+static const u8 *const sHelpSystemGeneralTopicTextPtrs[] = {
     NULL,
     gUnknown_81B9BB7,
     gUnknown_81B9BC7,
@@ -357,7 +357,7 @@ static const u8 *const gUnknown_845B500[] = {
     gUnknown_81B9C1D
 };
 
-static const u8 *const gUnknown_845B520[] = {
+static const u8 *const sHelpSystemGeneralTopicDescriptionTextPtrs[] = {
     NULL,
     gUnknown_81B9C2F,
     gUnknown_81B9D04,
@@ -368,7 +368,7 @@ static const u8 *const gUnknown_845B520[] = {
     gUnknown_81BA027
 };
 
-static const u8 *const gUnknown_845B540[] = {
+static const u8 *const sHelpSystemTypeMatchupTextPtrs[] = {
     NULL,
     gUnknown_81BA0F1,
     gUnknown_81BA10D,
@@ -407,7 +407,7 @@ static const u8 *const gUnknown_845B540[] = {
     gUnknown_81BA400
 };
 
-static const u8 *const gUnknown_845B5D0[] = {
+static const u8 *const sHelpSystemTypeMatchupDescriptionTextPtrs[] = {
     NULL,
     gUnknown_81BA416,
     gUnknown_81BA4E6,
@@ -446,7 +446,6 @@ static const u8 *const gUnknown_845B5D0[] = {
     gUnknown_81BB156
 };
 
-
 static const u8 gUnknown_845B660[] = {
     0x01, 0x02, 0x03, 0xff
 };
@@ -739,7 +738,7 @@ 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[] = {
+static const u8 *const sHelpSystemSubmenuIndexPointers[] = {
     NULL, NULL, NULL, NULL, NULL,
     NULL, NULL, NULL, gUnknown_845B660, NULL,
     NULL, NULL, NULL, gUnknown_845B664, NULL,
@@ -780,48 +779,48 @@ static const u8 *const gUnknown_845B9E0[] = {
 
 static const u16 unref_845BCB0[] = INCBIN_U16("graphics/help_system/unk_845BCB0.bin");
 
-static const u8 gUnknown_845C4B0[] = {
+static const u8 sHelpSystemContextTopicOrder[] = {
     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 bool8 sHelpSystemContextTopicFlags[][6] = {
+    {FALSE, FALSE, FALSE, FALSE, FALSE, TRUE },
+    {FALSE, FALSE, FALSE, TRUE,  FALSE, TRUE },
+    {FALSE, FALSE, FALSE, TRUE,  FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, TRUE,  FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, FALSE, TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, FALSE, TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  FALSE, FALSE, TRUE,  FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  TRUE,  FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, TRUE,  TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, FALSE, TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, TRUE,  TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, TRUE,  TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, TRUE,  TRUE },
+    {TRUE,  TRUE,  TRUE,  FALSE, TRUE,  TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, TRUE,  FALSE, FALSE, FALSE, TRUE },
+    {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
+    {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE}
 };
 
 static const u16 sMartMaps[] = {
@@ -961,12 +960,12 @@ static bool8 IsInDungeonMap(void)
 
 void sub_812B35C(void)
 {
-    sub_812B4B8();
+    HelpSystem_EnableToggleWithRButton();
     if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING))
         HelpSystem_SetSomeVariable2(0x16);
     else if (IsInDungeonMap())
         HelpSystem_SetSomeVariable2(0x15);
-    else if (is_light_level_8_or_9(gMapHeader.mapType))
+    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);
@@ -1015,126 +1014,126 @@ 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, sHelpSystemState[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;
+    u8 totalItems = 0;
     for (i = 0; i < 6; i++)
     {
-        if (gUnknown_845C4B6[sSomeVariable][gUnknown_845C4B0[i]] == 1)
+        if (sHelpSystemContextTopicFlags[sSomeVariable][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[sHelpSystemState[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 * indexPtr = sHelpSystemSubmenuIndexPointers[sSomeVariable * 5 + sHelpSystemState[1]];
     u8 i;
-    for (i = 0; r3[i] != 0xFF; i++)
+    for (i = 0; indexPtr[i] != 0xFF; i++)
     {
-        if (sub_812B780(r3[i]) == TRUE)
+        if (HelpSystemSubmenuIndexIsActive(indexPtr[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]];
+            if (sHelpSystemState[1] == 0)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedQuestionTextPtrs[indexPtr[i]];
+            else if (sHelpSystemState[1] == 1)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemMenuTopicTextPtrs[indexPtr[i]];
+            else if (sHelpSystemState[1] == 2)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedStringsTextPtrs[indexPtr[i]];
+            else if (sHelpSystemState[1] == 3)
+                listMenuItemsBuffer[totalItems].label = sHelpSystemGeneralTopicTextPtrs[indexPtr[i]];
             else
-                a1[r6].label = gUnknown_845B540[r3[i]];
-            a1[r6].index = r3[i];
-            r6++;
+                listMenuItemsBuffer[totalItems].label = sHelpSystemTypeMatchupTextPtrs[indexPtr[i]];
+            listMenuItemsBuffer[totalItems].index = indexPtr[i];
+            totalItems++;
         }
     }
-    if (sub_812B754() == TRUE)
+    if (HelpSystem_HasDefeatedBrock() == TRUE)
     {
-        for (i = 0, r3 = gUnknown_845B9BE; r3[i] != 0xFF; i++)
+        for (i = 0, indexPtr = gUnknown_845B9BE; indexPtr[i] != 0xFF; i++)
         {
-            a1[r6].label = gUnknown_845B3A0[r3[i]];
-            a1[r6].index = r3[i];
-            r6++;
+            listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedStringsTextPtrs[indexPtr[i]];
+            listMenuItemsBuffer[totalItems].index = indexPtr[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 = gUnknown_81B2E6F;
+    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_HasDefeatedBrock(void)
 {
-    if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && gUnknown_3005E9C[1] == 2)
+    if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && sHelpSystemState[1] == 2)
         return TRUE;
     return FALSE;
 }
 
-static bool8 sub_812B780(u8 id)
+static bool8 HelpSystemSubmenuIndexIsActive(u8 id)
 {
     u8 i = 0;
 
-    if (gUnknown_3005E9C[1] == 0)
+    if (sHelpSystemState[1] == 0)
     {
         switch (id)
         {
@@ -1188,7 +1187,7 @@ static bool8 sub_812B780(u8 id)
             return FlagGet(FLAG_BADGE01_GET);
         case 28:
         case 40:
-            return sub_812BB10();
+            return HasGottenAtLeastOneHM();
         case 39:
             return FlagGet(FLAG_GOT_FAME_CHECKER);
         case 44:
@@ -1196,7 +1195,7 @@ static bool8 sub_812B780(u8 id)
         }
         return FALSE;
     }
-    if (gUnknown_3005E9C[1] == 1)
+    if (sHelpSystemState[1] == 1)
     {
         switch (id)
         {
@@ -1254,7 +1253,7 @@ static bool8 sub_812B780(u8 id)
             return FlagGet(FLAG_BADGE01_GET);
         case 16:
         case 17:
-            return sub_812BB10();
+            return HasGottenAtLeastOneHM();
         case 18:
             return FlagGet(FLAG_GOT_BICYCLE);
         case 48:
@@ -1262,9 +1261,9 @@ static bool8 sub_812B780(u8 id)
         }
         return FALSE;
     }
-    if (gUnknown_3005E9C[1] == 2)
+    if (sHelpSystemState[1] == 2)
     {
-        if (sub_812B754() == TRUE)
+        if (HelpSystem_HasDefeatedBrock() == TRUE)
         {
             for (i = 0; gUnknown_845B9BE[i] != 0xFF; i++)
             {
@@ -1311,7 +1310,7 @@ static bool8 sub_812B780(u8 id)
             return FlagGet(FLAG_SYS_POKEMON_GET);
         case 36:
         case 37:
-            return sub_812BB10();
+            return HasGottenAtLeastOneHM();
         case 3:
         case 15:
         case 18:
@@ -1320,7 +1319,7 @@ static bool8 sub_812B780(u8 id)
         }
         return TRUE;
     }
-    if (gUnknown_3005E9C[1] == 3)
+    if (sHelpSystemState[1] == 3)
     {
         switch (id)
         {
@@ -1331,7 +1330,7 @@ static bool8 sub_812B780(u8 id)
         }
         return TRUE;
     }
-    if (gUnknown_3005E9C[1] == 4)
+    if (sHelpSystemState[1] == 4)
     {
         return TRUE;
     }
@@ -1339,7 +1338,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,64 +1357,64 @@ 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;
+    sHelpSystemState[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)
@@ -1425,42 +1424,42 @@ bool8 sub_812BCD0(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
         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;
+        sHelpSystemState[1] = v0;
+        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);
+    sHelpSystemState[0] = 1;
+    sHelpSystemState[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;
+    sHelpSystemState[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)
@@ -1468,7 +1467,7 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
     case -6:
         return FALSE;
     case -2:
-        a0->field_0E = 2;
+        helpListMenu->state = 2;
         break;
     case -5:
     case -4:
@@ -1476,8 +1475,8 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
     case -1:
         break;
     default:
-        gUnknown_3005E9C[3] = v0;
-        a0->field_0E = 4;
+        sHelpSystemState[3] = v0;
+        helpListMenu->state = 4;
         break;
     }
     return TRUE;
@@ -1485,60 +1484,60 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1)
 
 void sub_812BDEC(void)
 {
-    HelpSystem_PrintTextAt(gUnknown_845B080[gUnknown_3005E9C[1]], 0, 0);
+    HelpSystem_PrintTextAt(sHelpSystemTopicPtrs[sHelpSystemState[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;
+    sHelpSystemState[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 (sHelpSystemState[1] == 0)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B0B0[gUnknown_3005E9C[3]], gUnknown_845B164[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemSpecializedQuestionTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedAnswerTextPtrs[sHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 1)
+    else if (sHelpSystemState[1] == 1)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B218[gUnknown_3005E9C[3]], gUnknown_845B2DC[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemMenuTopicTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedControlsTextPtrs[sHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 2)
+    else if (sHelpSystemState[1] == 2)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B3A0[gUnknown_3005E9C[3]], gUnknown_845B450[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemSpecializedStringsTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedStringDefinitionsTextPtrs[sHelpSystemState[3]]);
     }
-    else if (gUnknown_3005E9C[1] == 3)
+    else if (sHelpSystemState[1] == 3)
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B500[gUnknown_3005E9C[3]], gUnknown_845B520[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemGeneralTopicTextPtrs[sHelpSystemState[3]], sHelpSystemGeneralTopicDescriptionTextPtrs[sHelpSystemState[3]]);
     }
     else
     {
-        HelpSystem_PrintTwoStrings(gUnknown_845B540[gUnknown_3005E9C[3]], gUnknown_845B5D0[gUnknown_3005E9C[3]]);
+        HelpSystem_PrintTwoStrings(sHelpSystemTypeMatchupTextPtrs[sHelpSystemState[3]], sHelpSystemTypeMatchupDescriptionTextPtrs[sHelpSystemState[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);
+    sHelpSystemState[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 +1545,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);
 }
 
-static void sub_812BF74(const u8 * str)
+static void PrintTextOnPanel2Row52RightAlign(const u8 * str)
 {
     HelpSystem_FillPanel2();
     HelpSystem_PrintTextRightAlign_Row52(str);
@@ -1560,21 +1559,21 @@ static void sub_812BF74(const u8 * str)
 
 u8 sub_812BF88(void)
 {
-    return gUnknown_3005E9C[0];
+    return sHelpSystemState[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/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/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..420fb7c9a 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,13 +74,38 @@ 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
@@ -91,46 +116,54 @@ static const char lib_ver[] = "RFU_V1024";
 
 static const char str_checkMbootLL[] = "RFU-MBOOT";
 
-u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam)
+#define COPY(src, dst, size) do {         \
+    const u16 *_src = (const u16 *)(src); \
+    u16 *_dst = (u16 *)(dst);             \
+    u16 _size = (size);                   \
+    while (_size-- != 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 +176,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 < 1028
+    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
+    // register swap dst <--> buffByteSizeMax
+    COPY(
+        (const u16 *)((uintptr_t)&rfu_STC_fastCopy & ~1),
+        gRfuFixed->fastCopyBuffer,
+        0x60 / sizeof(u16)
+        );
+#endif
     gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1;
     return 0;
 }
@@ -155,19 +198,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 +223,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 +248,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 +272,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 +320,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 +362,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 +383,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 +414,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 +427,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 +490,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 >= 1028
+    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 +562,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 +576,65 @@ 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 true_slots[RFU_CHILD_MAX];
+    u8 bm_slot_id;
+
+#if LIBRFU_VERSION >= 1028
+//#if 1
+    // TODO: decompile this
+#endif
 
-    if (r8 != 0)
+    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)
+    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 (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;
             }
         }
-        --r8;
+        --numSlots;
     }
 }
 
@@ -575,11 +644,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 +657,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 +672,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 +720,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 +734,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 +744,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 +822,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 +852,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 +865,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;
@@ -814,25 +882,25 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
     if (gRfuStatic->nowWatchInterval == 0)
     {
         gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval;
-        sp08 = 1;
+        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 +911,33 @@ 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)
+        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 +946,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 +957,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 +976,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 +998,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 +1019,46 @@ 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 ((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 +1071,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 +1083,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 +1136,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 +1192,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 +1209,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 +1224,7 @@ void rfu_clearAllSlot(void)
 {
     u16 i;
     u16 IMEBackup = REG_IME;
-    
+
     REG_IME = 0;
     for (i = 0; i < RFU_CHILD_MAX; ++i)
     {
@@ -1175,87 +1240,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 +1366,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 +1383,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;
-    #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette
+            *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 bm_slot_id, r3, frameSize, sending 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 +1501,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 +1527,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 +1543,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 +1658,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 +1849,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)
+                    {
+                        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
                     {
-                        r12->n[r4] = 1;
-                        r12->now_p[r4] = r12->src + r12->payloadSize * r4;
+                        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..26e223153 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;
 }
@@ -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..706c1679b 100644
--- a/src/list_menu.c
+++ b/src/list_menu.c
@@ -763,7 +763,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/mevent.c b/src/mevent.c
index afad326b5..a246e3e44 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,14 +419,14 @@ void sub_8143910(u8 taskId)
             }
             break;
         case 15:
-            data->t0E = ValidateTrainerTowerData((struct EReaderTrainerHillSet *)gDecompressionBuffer);
-            sub_800AA80(data->t0E);
+            data->initialSendResult = ValidateTrainerTowerData((struct EReaderTrainerHillSet *)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;
@@ -439,39 +435,39 @@ void sub_8143910(u8 taskId)
         case 17:
             if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerHillSet *)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..3b1762540 100644
--- a/src/mevent_server.c
+++ b/src/mevent_server.c
@@ -176,7 +176,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 +247,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_show_card.c b/src/mevent_show_card.c
new file mode 100644
index 000000000..3eeafa4b5
--- /dev/null
+++ b/src/mevent_show_card.c
@@ -0,0 +1,459 @@
+#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 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..d100caea1 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)
+bool8 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_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/new_game.c b/src/new_game.c
index 05fb9c83e..9aea0b3aa 100644
--- a/src/new_game.c
+++ b/src/new_game.c
@@ -145,7 +145,7 @@ void NewGameInitData(void)
     ResetTrainerFanClub();
     UnionRoomChat_InitializeRegisteredTexts();
     ResetMiniGamesResults();
-    sub_8143D24();
+    InitMEventData();
     SetAllRenewableItemFlags();
     WarpToPlayersRoom();
     ScriptContext2_RunNewScript(EventScript_ResetAllMapFlags);
diff --git a/src/party_menu.c b/src/party_menu.c
index df0e70b37..600350ca9 100644
--- a/src/party_menu.c
+++ b/src/party_menu.c
@@ -3881,7 +3881,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 +3907,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)
     {
diff --git a/src/pokedex_screen.c b/src/pokedex_screen.c
index 2ccec7a3f..cd201a884 100644
--- a/src/pokedex_screen.c
+++ b/src/pokedex_screen.c
@@ -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/rfu_union_tool.c b/src/rfu_union_tool.c
index 3811aa3e7..1d33fb7d1 100644
--- a/src/rfu_union_tool.c
+++ b/src/rfu_union_tool.c
@@ -10,14 +10,15 @@
 #include "task.h"
 #include "constants/flags.h"
 #include "constants/event_object_movement.h"
+#include "constants/union_room.h"
 #include "constants/object_events.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]   = {
@@ -69,12 +70,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 +117,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 +189,7 @@ static bool32 SetUnionRoomPlayerEnterExitMovement(u32 playerIdx, const u8 * move
     }
     return TRUE;
 }
+
 static bool32 TryReleaseUnionRoomPlayerObjectEvent(u32 playerIdx)
 {
     u8 objectId;
@@ -263,11 +265,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 +277,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 +308,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 +324,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 +344,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 +355,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 +368,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 +385,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 +411,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 +420,7 @@ static void sub_811BA5C(void)
     }
 }
 
-void sub_811BA78(void)
+void DeleteUnionObjWorkAndStopTask(void)
 {
     s32 i;
     for (i = 0; i < 8; i++)
@@ -430,31 +432,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);
-        RfuUnionObjectToggleInvisibility(r5 - 0x38, TRUE);
+        s32 obj_id = 5 * group + i;
+        sprite_ids[obj_id] = sprite_new(OBJECT_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 +464,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 RfuUnionObjectIsInvisible(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)
     {
-        RfuUnionObjectToggleInvisibility(r7 - 0x38, FALSE);
-        RfuUnionObjectStartWarp(r7 - 0x38, 1);
+        RfuUnionObjectToggleInvisibility(objId - 0x38, FALSE);
+        RfuUnionObjectStartWarp(objId - 0x38, UNION_ROOM_SPAWN_IN);
     }
-    RfuUnionObjectSetFacingDirection(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;
-    RfuUnionObjectStartWarp(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 (RfuUnionObjectIsInvisible(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 +561,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 +633,33 @@ bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3)
             {
                 continue;
             }
-            if (RfuUnionObjectIsInvisible(r3 - 0x38) != 0)
+            if (RfuUnionObjectIsInvisible(objId - 0x38) != 0)
             {
                 continue;
             }
-            if (RfuUnionObjectIsWarping(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)
 {
-    TurnObjectEvent(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/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/script.c b/src/script.c
index 0a4b69bac..ee4ffb7cf 100644
--- a/src/script.c
+++ b/src/script.c
@@ -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/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/tm_case.c b/src/tm_case.c
index d45061bde..ac4134029 100644
--- a/src/tm_case.c
+++ b/src/tm_case.c
@@ -1304,7 +1304,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..1872e98ee 100644
--- a/src/trade.c
+++ b/src/trade.c
@@ -765,9 +765,9 @@ static void sub_804C728(void)
 
             if (gWirelessCommType)
             {
-                sub_800B1F4();
+                SetWirelessCommType1();
                 OpenLink();
-                sub_80FBB20();
+                LinkRfu_CreateIdleTask();
             }
             else
             {
@@ -810,14 +810,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 +1213,7 @@ static void sub_804D548(void)
         }
         else
         {
-            sub_800AA80(32);
+            Link_StartSend5FFFwithParam(32);
             sTradeMenuResourcesPtr->unk_6F = 13;
         }
     }
@@ -2004,11 +2004,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 +2044,7 @@ static void sub_804E9C0(void)
 {
     if (!sub_80FA484(FALSE))
     {
-        sub_800AB9C();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         sTradeMenuResourcesPtr->unk_6F = 13;
     }
 }
@@ -2740,30 +2740,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 +2794,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1,
         return 3;
     }
 
-    if (!r9)
+    if (!playerHasNationalDex)
     {
         if (species1 == SPECIES_EGG)
         {
@@ -2812,7 +2812,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1,
         }
     }
 
-    if (!r10 && species1 > SPECIES_MEW)
+    if (!partnerHasNationalDex && species1 > SPECIES_MEW)
     {
         return 7;
     }
@@ -2820,11 +2820,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 +2834,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..601d7ae2b 100644
--- a/src/trade_scene.c
+++ b/src/trade_scene.c
@@ -2556,7 +2556,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 +2594,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 +2641,7 @@ static void sub_8053E8C(void)
     case 41:
         if (sTradeData->timer == 0)
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             gMain.state = 42;
         }
         else
@@ -2660,7 +2660,7 @@ static void sub_8053E8C(void)
         if (++sTradeData->timer > 60)
         {
             gMain.state++;
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
         }
         break;
     case 6:
@@ -2682,11 +2682,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..f29c9c71c 100644
--- a/src/trainer_card.c
+++ b/src/trainer_card.c
@@ -590,7 +590,7 @@ static void Task_TrainerCard(u8 taskId)
         }
         break;
     case 15:
-        sub_800AAC0();
+        Link_TryStartSend5FFF();
         DrawDialogueFrame(0, 1);
         AddTextPrinterParameterized(0, 2, gText_WaitingTrainerFinishReading, 0, 1, TEXT_SPEED_FF, 0);
         CopyWindowToVram(0, 3);
diff --git a/src/union_room.c b/src/union_room.c
index f942fb7d3..f3aeeebc5 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,14 @@
 #include "constants/cable_club.h"
 #include "constants/field_weather.h"
 #include "constants/species.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 +62,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 +168,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 +190,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 +200,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 +229,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 +239,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 +249,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 +289,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 +299,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 +327,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 +343,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 +364,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 +374,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 +395,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 +416,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 +436,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 +481,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 +520,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 +664,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 +725,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 +734,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 +742,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 +806,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 +834,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 +861,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 +882,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 +915,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 +927,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 +937,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 +967,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 +984,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 +1004,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 +1027,7 @@ static void sub_8115A68(u8 taskId)
         gSpecialVar_Result = 8;
         break;
     case 26:
-        if (sub_80FBA00())
+        if (RfuIsErrorStatus1or2())
         {
             data->state = 29;
         }
@@ -928,9 +1035,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 +1045,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 +1242,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 +1270,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 +1279,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 +1287,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 +1301,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 +1341,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 +1376,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 +1418,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 +1451,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 +1470,7 @@ static void sub_8116738(u8 taskId)
         }
         break;
     case 9:
-        if (sub_80FB9F4())
+        if (RfuGetErrorStatus())
             data->state = 6;
         break;
     case 10:
@@ -1361,23 +1478,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 +1507,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 +1522,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 +1551,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 +1578,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 +1586,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 +1641,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 +1673,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 +1698,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 +1707,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 +1720,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_CallBC2ReturnFromLinkTrade(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 +1782,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 +1806,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 +1820,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 +1840,7 @@ static void sub_8117354(void)
     BuildOamBuffer();
 }
 
-void sub_81173C0(u16 battleFlags)
+void StartUnionRoomBattle(u16 battleFlags)
 {
     HealPlayerParty();
     SavePlayerParty();
@@ -1736,7 +1853,7 @@ void sub_81173C0(u16 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 +1861,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 +1872,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 +1892,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 +2000,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 +2022,7 @@ static void sub_8117900(u8 taskId)
     case 2:
         if (!gPaletteFade.active)
         {
-            sub_800AB9C();
+            PrepareSendLinkCmd2FFE_or_RfuCmd6600();
             data[0]++;
         }
         break;
@@ -1908,38 +2030,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 +2070,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 +2114,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 +2122,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 +2134,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 +2180,7 @@ static void sub_8117A0C(u8 taskId)
         }
         else if (val == 2)
         {
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             data->state = 2;
         }
         break;
@@ -2066,17 +2189,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 +2209,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 +2228,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 +2242,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 +2256,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 +2280,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 +2293,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 +2333,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 +2360,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 +2379,7 @@ static void sub_8117F20(u8 taskId)
             break;
         case 5:
             AddTextPrinterToWindow1(gUnknown_84576AC);
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             break;
         }
         break;
@@ -2264,19 +2388,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 +2408,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 +2422,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 +2447,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 +2459,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 +2493,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 +2517,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 +2544,7 @@ static void sub_81182DC(u8 taskId)
             break;
         case 5:
             AddTextPrinterToWindow1(gUnknown_845777C);
-            sub_80FB9E4(0, 0);
+            RfuSetErrorStatus(0, 0);
             break;
         }
         break;
@@ -2434,7 +2558,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 +2568,7 @@ static void sub_81182DC(u8 taskId)
         {
             DestroyWirelessStatusIndicatorSprite();
             DestroyTask(taskId);
-            sub_80F8DC0();
+            LinkRfu_Shutdown();
             gSpecialVar_Result = 5;
         }
         break;
@@ -2453,22 +2577,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 +2606,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 +2621,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 +2629,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 +2639,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 +2648,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 +2669,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 +2723,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 +2750,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 +2758,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 +2774,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 +2873,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 +2893,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 +2925,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 +2953,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 +2966,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 +3006,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 +3020,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 +3032,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 +3054,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 +3070,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 +3096,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 +3110,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 +3198,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 +3208,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 +3239,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 +3275,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 +3283,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 +3294,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 +3313,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 +3324,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 +3363,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 +3379,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 +3416,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 +3462,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 +3473,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 +3485,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 +3513,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 +3536,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 +3556,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 +3603,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 +3726,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 +3743,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 +3785,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 +3819,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 +3851,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 +3907,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 +3961,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 +3990,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 +4092,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 +4127,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 +4167,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 +4227,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 +4310,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 +4385,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 +4401,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 +4413,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 +4493,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 +4515,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 +4560,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 +4636,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 +4663,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 +4681,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 +4689,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);
 
-    StringCopy(arg1->field_174, gUnknown_84594B0[trainerCard->stars]);
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, arg1->field_174);
+    StringCopy(uroom->field_174, gUnknown_84594B0[trainerCard->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->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->playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[4], trainerCard->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;
     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;
     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->pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]);
 
     for (i = 0; i < 4; i++)
     {
-        CopyEasyChatWord(arg1->trainerCardStrbufs[i + 3], trainerCard->var_28[i]);
-        DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, arg1->trainerCardStrbufs[i + 3]);
+        CopyEasyChatWord(uroom->trainerCardStrbufs[i + 3], trainerCard->var_28[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->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..167da514a 100644
--- a/src/union_room_chat.c
+++ b/src/union_room_chat.c
@@ -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..1d26d1968 100644
--- a/src/union_room_message.c
+++ b/src/union_room_message.c
@@ -1,10 +1,11 @@
 #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 +125,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 +152,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 +168,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 +240,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 +248,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 +419,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 +444,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 +459,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 +476,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 +489,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 +525,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/vs_seeker.c b/src/vs_seeker.c
index c0f53d5c2..9c9a4d67f 100644
--- a/src/vs_seeker.c
+++ b/src/vs_seeker.c
@@ -22,7 +22,6 @@
 #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"
diff --git a/src/wireless_communication_status_screen.c b/src/wireless_communication_status_screen.c
index 9be2823aa..7267d4ace 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 Special_WirelessCommunicationScreen(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;
 }