Port librfu from firered

17 files changed, 6671 insertions, 6160 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/berry_crush.c b/src/berry_crush.c
index f0987c953..9e1de22d7 100755
--- a/src/berry_crush.c
+++ b/src/berry_crush.c
@@ -280,9 +280,9 @@ void sub_8020C70(MainCallback callback)
     if (!gReceivedRemoteLinkPlayers || gWirelessCommType == 0)
     {
         SetMainCallback2(callback);
-        gUnknown_03005000.unk_10 = 0;
-        gUnknown_03005000.unk_12 = 0;
-        gUnknown_03005000.unk_ee = 1;
+        Rfu.unk_10 = 0;
+        Rfu.unk_12 = 0;
+        Rfu.unk_ee = 1;
         return;
     }
 
@@ -291,9 +291,9 @@ void sub_8020C70(MainCallback callback)
     if (playerCount < 2 || multiplayerId >= playerCount)
     {
         SetMainCallback2(callback);
-        gUnknown_03005000.unk_10 = 0;
-        gUnknown_03005000.unk_12 = 0;
-        gUnknown_03005000.unk_ee = 1;
+        Rfu.unk_10 = 0;
+        Rfu.unk_12 = 0;
+        Rfu.unk_ee = 1;
         return;
     }
 
@@ -301,9 +301,9 @@ void sub_8020C70(MainCallback callback)
     if (!gUnknown_02022C90)
     {
         SetMainCallback2(callback);
-        gUnknown_03005000.unk_10 = 0;
-        gUnknown_03005000.unk_12 = 0;
-        gUnknown_03005000.unk_ee = 1;
+        Rfu.unk_10 = 0;
+        Rfu.unk_12 = 0;
+        Rfu.unk_ee = 1;
         return;
     }
 
diff --git a/src/librfu_intr.c b/src/librfu_intr.c
index c6db9a50c..23962a937 100644
--- a/src/librfu_intr.c
+++ b/src/librfu_intr.c
@@ -1,5 +1,402 @@
 #include "global.h"
-#include "main.h"
 #include "librfu.h"
 
-//TODO: decompile asm/librfu_intr.s to here
+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 732cc532d..582060f78 100644
--- a/src/librfu_rfu.c
+++ b/src/librfu_rfu.c
@@ -2,54 +2,54 @@
 
 struct LLSFStruct
 {
-    u8 unk00;
-    u8 unk01;
-    u8 unk02;
-    u8 unk03;
-    u8 unk04;
-    u8 unk05;
-    u8 unk06;
-    u8 unk07;
-    u8 unk08;
-    u8 unk09;
-    u8 unk0A;
-    u8 unk0B;
-    u8 unk0C;
-    u16 unk0E;
+    u8 frameSize;
+    u8 recvFirstShift;
+    u8 connSlotFlagShift;
+    u8 slotStateShift;
+    u8 ackShift;
+    u8 phaseShit;
+    u8 nShift;
+    u8 recvFirstMask;
+    u8 connSlotFlagMask;
+    u8 slotStateMask;
+    u8 ackMask;
+    u8 phaseMask;
+    u8 nMask;
+    u16 framesMask;
 };
 
 struct RfuLocalStruct
 {
-    u8 unk00;
-    u8 unk01;
-    u8 unk02;
-    u8 unk03;
-    u8 unk04;
-    u8 unk05;
-    u16 unk06;
+    u8 recvFirst;
+    u8 connSlotFlag;
+    u8 slotState;
+    u8 ack;
+    u8 phase;
+    u8 n;
+    u16 frame;
 };
 
-static void rfu_CB_defaultCallback(u8, u16);
-static void rfu_CB_reset(u8, u16);
-static void rfu_CB_configGameData(u8, u16);
-static void rfu_CB_stopMode(u8, u16);
-static void rfu_CB_startSearchChild(u8, u16);
-static void rfu_CB_pollAndEndSearchChild(u8, u16);
-static void rfu_CB_startSearchParent(u8, u16);
-static void rfu_CB_pollSearchParent(u8, u16);
-static void rfu_CB_pollConnectParent(u8, u16);
-static void rfu_CB_pollConnectParent(u8, u16);
-static void rfu_CB_disconnect(u8, u16);
-static void rfu_CB_CHILD_pollConnectRecovery(u8, u16);
-static void rfu_CB_sendData(__attribute__((unused)) u8, u16);
-static void rfu_CB_sendData2(__attribute__((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);
@@ -63,7 +63,7 @@ static void rfu_STC_CHILD_analyzeRecvPacket(void);
 static u16 rfu_STC_analyzeLLSF(u8, const u8 *, u16);
 static void rfu_STC_UNI_receive(u8, const struct RfuLocalStruct *, const u8 *);
 static void rfu_STC_NI_receive_Receiver(u8, const struct RfuLocalStruct *, const u8 *);
-static void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuLocalStruct *, __attribute__((unused)) const u8 *);
+static void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuLocalStruct *, UNUSED const u8 *);
 static void rfu_STC_NI_initSlot_asRecvDataEntity(u8, struct NIComm *);
 static void rfu_STC_NI_initSlot_asRecvControllData(u8, struct NIComm *);
 
@@ -74,59 +74,94 @@ struct RfuStatic *gRfuStatic;
 struct RfuFixed *gRfuFixed;
 
 static const struct LLSFStruct llsf_struct[2] = {
-  {
-    2, 14, 0, 10, 9, 5, 7, 2,
-    0, 15, 1, 3, 3, 0x1f
-  }, {
-    3, 22, 18, 14, 13, 9, 11, 3,
-    15, 15, 1, 3, 3, 0x7f
-  }
+    [MODE_CHILD] = {
+        .frameSize = 2,
+        .recvFirstShift = 14,
+        .connSlotFlagShift = 0,
+        .slotStateShift = 10,
+        .ackShift = 9,
+        .phaseShit = 5,
+        .nShift = 7,
+        .recvFirstMask = 2,
+        .connSlotFlagMask = 0,
+        .slotStateMask = 15,
+        .ackMask = 1,
+        .phaseMask = 3,
+        .nMask = 3,
+        .framesMask = 0x1f
+    },
+    [MODE_PARENT] = {
+        .frameSize = 3,
+        .recvFirstShift = 22,
+        .connSlotFlagShift = 18,
+        .slotStateShift = 14,
+        .ackShift = 13,
+        .phaseShit = 9,
+        .nShift = 11,
+        .recvFirstMask = 3,
+        .connSlotFlagMask = 15,
+        .slotStateMask = 15,
+        .ackMask = 1,
+        .phaseMask = 3,
+        .nMask = 3,
+        .framesMask = 0x7f
+    }
 };
 
-static const char lib_ver[] = "RFU_V1026";
+#define xstr(s) str(s)
+#define str(s) #s
+const char version_string[] = "RFU_V" xstr(LIBRFU_VERSION);
 
 static const char str_checkMbootLL[] = "RFU-MBOOT";
 
-u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam)
+#define COPY(src, dst, iterator, size) do {         \
+    const u16 *_src = (const u16 *)(src);           \
+    u16 *_dst = (u16 *)(dst);                       \
+    (iterator) = (size);                            \
+    while ((iterator)-- != 0)                       \
+        *_dst++ = *_src++;                          \
+} while (0)
+
+u16 rfu_initializeAPI(u32 *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam)
 {
     u16 i;
     u16 *dst;
     const u16 *src;
-    u16 r3;
+    u16 buffByteSizeMax;
 
-    // is in EWRAM? 
-    if (((u32)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam)
+    // is in EWRAM?
+    if (((uintptr_t)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam)
         return ERR_RFU_API_BUFF_ADR;
-    // is not 4-byte aligned? 
+    // is not 4-byte aligned?
     if ((u32)APIBuffer & 3)
         return ERR_RFU_API_BUFF_ADR;
     if (copyInterruptToRam)
     {
         // An assert/debug print may have existed before, ie
         // printf("%s %u < %u", "somefile.c:12345", buffByteSize, num)
-        // to push this into r3?
-        r3 = sizeof(struct RfuAPIBuffer);
-        if (buffByteSize < r3)
+        // to push this into buffByteSizeMax?
+        buffByteSizeMax = RFU_API_BUFF_SIZE_RAM;
+        if (buffByteSize < buffByteSizeMax)
             return ERR_RFU_API_BUFF_SIZE;
     }
     if (!copyInterruptToRam)
     {
-        r3 = 0x504; // same issue as above
-        if (buffByteSize < r3)
+        buffByteSizeMax = RFU_API_BUFF_SIZE_ROM; // same issue as above
+        if (buffByteSize < buffByteSizeMax)
             return ERR_RFU_API_BUFF_SIZE;
     }
-    gRfuLinkStatus = &APIBuffer->linkStatus;
-    gRfuStatic = &APIBuffer->static_;
-    gRfuFixed = &APIBuffer->fixed;
-    gRfuSlotStatusNI[0] = &APIBuffer->NI[0];
-    gRfuSlotStatusUNI[0] = &APIBuffer->UNI[0];
+    gRfuLinkStatus = (void *)APIBuffer + 0;
+    gRfuStatic = (void *)APIBuffer + 0xb4; // + sizeof(*gRfuLinkStatus)
+    gRfuFixed = (void *)APIBuffer + 0xdc; // + sizeof(*gRfuStatic)
+    gRfuSlotStatusNI[0] = (void *)APIBuffer + 0x1bc; // + sizeof(*gRfuFixed)
+    gRfuSlotStatusUNI[0] = (void *)APIBuffer + 0x37c; // + sizeof(*gRfuSlotStatusNI[0])
     for (i = 1; i < RFU_CHILD_MAX; ++i)
     {
         gRfuSlotStatusNI[i] = &gRfuSlotStatusNI[i - 1][1];
         gRfuSlotStatusUNI[i] = &gRfuSlotStatusUNI[i - 1][1];
     }
-    // TODO: Is it possible to fix the following 2 statements? 
-    // It's equivalent to: 
+    // TODO: Is it possible to fix the following 2 statements?
+    // It's equivalent to:
     // gRfuFixed->STWIBuffer = &APIBuffer->intr;
     // STWI_init_all(&APIBuffer->intr, sioIntrTable_p, copyInterruptToRam);
     gRfuFixed->STWIBuffer = (struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1];
@@ -139,34 +174,41 @@ u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc
         gRfuSlotStatusUNI[i]->recvBuffer = NULL;
         gRfuSlotStatusUNI[i]->recvBufferSize = 0;
     }
-    // looks like a macro copying data
-    do
-    {
-        src = (const u16 *)((u32)&rfu_STC_fastCopy & 0xFFFFFFFE);
-        dst = gRfuFixed->fastCopyBuffer;
-        for (r3 = 0x2F; r3 != 0xFFFF; --r3) // copy rfu_STC_fastCopy function body to buffer
-            *dst++ = *src++;
-        gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1;
-    } while (0);
+    // rfu_REQ_changeMasterSlave is the function next to rfu_STC_fastCopy
+#if LIBRFU_VERSION < 1026
+    src = (const u16 *)((uintptr_t)&rfu_STC_fastCopy & ~1);
+    dst = gRfuFixed->fastCopyBuffer;
+    buffByteSizeMax = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16);
+    while (buffByteSizeMax-- != 0)
+        *dst++ = *src++;
+#else
+    COPY(
+        (uintptr_t)&rfu_STC_fastCopy & ~1,
+        gRfuFixed->fastCopyBuffer,
+        buffByteSizeMax,
+        0x60 / sizeof(u16)
+        );
+#endif
+    gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1;
     return 0;
 }
 
 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;
 }
@@ -179,20 +221,20 @@ void rfu_REQ_PARENT_resumeRetransmitAndChange(void)
 
 u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag)
 {
-    struct RfuIntrStruct *buf;
+    u8 *buf;
 
     *ackFlag = 0;
     if (gRfuLinkStatus->parentChild != MODE_PARENT)
         return ERR_MODE_NOT_PARENT;
     buf = rfu_getSTWIRecvBuffer();
-    switch (buf->rxPacketAlloc.rfuPacket8.data[0])
+    switch (*buf)
     {
     case 40:
     case 54:
-        if (buf->rxPacketAlloc.rfuPacket8.data[1] == 0)
+        if (buf[1] == 0)
             *ackFlag = gRfuLinkStatus->connSlotFlag;
         else
-            *ackFlag = buf->rxPacketAlloc.rfuPacket8.data[4];
+            *ackFlag = buf[4];
         return 0;
     default:
         return ERR_REQ_CMD_ID;
@@ -204,9 +246,9 @@ void rfu_setTimerInterrupt(u8 timerNo, IntrFunc *timerIntrTable_p)
     STWI_init_timer(timerIntrTable_p, timerNo);
 }
 
-struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void)
+u8 *rfu_getSTWIRecvBuffer(void)
 {
-    return gRfuFixed->STWIBuffer;
+    return (u8 *)gRfuFixed->STWIBuffer;
 }
 
 void rfu_setMSCCallback(void (*callback)(u16 reqCommandId))
@@ -228,26 +270,26 @@ static void rfu_enableREQCallback(bool8 enable)
         gRfuStatic->flags &= 0xF7;
 }
 
-static void rfu_STC_REQ_callback(u8 r5, u16 reqResult)
+static void rfu_STC_REQ_callback(u8 reqCommand, u16 reqResult)
 {
     STWI_set_Callback_M(rfu_CB_defaultCallback);
     gRfuStatic->reqResult = reqResult;
     if (gRfuStatic->flags & 8)
-        gRfuFixed->reqCallback(r5, reqResult);
+        gRfuFixed->reqCallback(reqCommand, reqResult);
 }
 
-static void rfu_CB_defaultCallback(u8 r0, u16 reqResult)
+static void rfu_CB_defaultCallback(u8 reqCommand, u16 reqResult)
 {
-    s32 r5;
+    s32 bmSlotFlags;
     u8 i;
 
-    if (r0 == 0xFF)
+    if (reqCommand == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ)
     {
         if (gRfuStatic->flags & 8)
-            gRfuFixed->reqCallback(r0, reqResult);
-        r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+            gRfuFixed->reqCallback(reqCommand, reqResult);
+        bmSlotFlags = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
         for (i = 0; i < RFU_CHILD_MAX; ++i)
-            if ((r5 >> i) & 1)
+            if ((bmSlotFlags >> i) & 1)
                 rfu_STC_removeLinkData(i, 1);
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
     }
@@ -276,25 +318,39 @@ u16 rfu_getRFUStatus(u8 *rfuState)
     return 0;
 }
 
+/*
+ * RFU Multiboot images are loaded into IWRAM
+ * struct RfuMbootLL
+ * {
+ *   struct RfuLinkStatus status;
+ *   u8 filler_B4[0x3C];
+ *   char name[10];
+ *   u16 checksum;
+ * }
+ * Returns 1 if the packet to inherit is malformed.
+ */
 u16 rfu_MBOOT_CHILD_inheritanceLinkStatus(void)
 {
     const char *s1 = str_checkMbootLL;
     char *s2 = (char *)0x30000F0;
     u16 checksum;
-    u16 *r2;
+    u16 *mb_buff_iwram_p;
     u8 i;
 
+    // if (strcmp(s1, s2) != 0) return 1;
     while (*s1 != '\0')
         if (*s1++ != *s2++)
             return 1;
-    r2 = (u16 *)0x3000000;
+    mb_buff_iwram_p = (u16 *)0x3000000;
+
+    // The size of struct RfuLinkStatus is 180
     checksum = 0;
-    for (i = 0; i < 90; ++i)
-        checksum += *r2++;
+    for (i = 0; i < 180/2; ++i)
+        checksum += *mb_buff_iwram_p++;
     if (checksum != *(u16 *)0x30000FA)
         return 1;
     CpuCopy16((u16 *)0x3000000, gRfuLinkStatus, sizeof(struct RfuLinkStatus));
-    gRfuStatic->flags |= 0x80;
+    gRfuStatic->flags |= 0x80; // mboot
     return 0;
 }
 
@@ -304,14 +360,14 @@ void rfu_REQ_stopMode(void)
 
     if (REG_IME == 0)
     {
-        rfu_STC_REQ_callback(61, 6);
+        rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 6);
         gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE;
     }
     else
     {
         AgbRFU_SoftReset();
         rfu_STC_clearAPIVariables();
-        if (AgbRFU_checkID(8) == 0x8001)
+        if (AgbRFU_checkID(8) == RFU_ID)
         {
             timerReg = &REG_TMCNT(gSTWIStatus->timerSelect);
             *timerReg = 0;
@@ -325,29 +381,29 @@ void rfu_REQ_stopMode(void)
         else
         {
             REG_SIOCNT = SIO_MULTI_MODE;
-            rfu_STC_REQ_callback(61, 0);
+            rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 0);
         }
     }
 }
 
-static void rfu_CB_stopMode(u8 a1, u16 reqResult)
+static void rfu_CB_stopMode(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         REG_SIOCNT = SIO_MULTI_MODE;
-    rfu_STC_REQ_callback(a1, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u32 rfu_REQBN_softReset_and_checkID(void)
 {
-    u32 r2;
+    u32 id;
 
     if (REG_IME == 0)
         return ERR_ID_CHECK_IME_DISABLE;
     AgbRFU_SoftReset();
     rfu_STC_clearAPIVariables();
-    if ((r2 = AgbRFU_checkID(30)) == 0)
+    if ((id = AgbRFU_checkID(30)) == 0)
         REG_SIOCNT = SIO_MULTI_MODE;
-    return r2;
+    return id;
 }
 
 void rfu_REQ_reset(void)
@@ -356,11 +412,11 @@ void rfu_REQ_reset(void)
     STWI_send_ResetREQ();
 }
 
-static void rfu_CB_reset(u8 a1, u16 reqResult)
+static void rfu_CB_reset(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_clearAPIVariables();
-    rfu_STC_REQ_callback(a1, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
@@ -369,59 +425,59 @@ void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
     STWI_send_SystemConfigREQ((availSlotFlag & AVAIL_SLOT1) | 0x3C, maxMFrame, mcTimer);
     if (mcTimer == 0)
     {
-        gRfuStatic->unk_1a = 1;
+        gRfuStatic->linkEmergencyLimit = 1;
     }
     else
     {
         u16 IMEBackup = REG_IME;
 
         REG_IME = 0;
-        gRfuStatic->unk_1a = Div(600, mcTimer);
+        gRfuStatic->linkEmergencyLimit = Div(600, mcTimer);
         REG_IME = IMEBackup;
     }
 }
 
 void rfu_REQ_configGameData(u8 mbootFlag, u16 serialNo, const u8 *gname, const u8 *uname)
 {
-    u8 sp[16];
+    u8 packet[16];
     u8 i;
-    u8 r3;
+    u8 check_sum;
     const u8 *gnameBackup = gname;
     const u8 *unameBackup;
 
-    sp[0] = serialNo;
-    sp[1] = serialNo >> 8;
+    packet[0] = serialNo;
+    packet[1] = serialNo >> 8;
     if (mbootFlag != 0)
-        sp[1] = (serialNo >> 8) | 0x80;
+        packet[1] = (serialNo >> 8) | 0x80;
     for (i = 2; i < 15; ++i)
-        sp[i] = *gname++;
-    r3 = 0;
+        packet[i] = *gname++;
+    check_sum = 0;
     unameBackup = uname;
     for (i = 0; i < 8; ++i)
     {
-        r3 += *unameBackup++;
-        r3 += *gnameBackup++;
+        check_sum += *unameBackup++;
+        check_sum += *gnameBackup++;
     }
-    sp[15] = ~r3;
+    packet[15] = ~check_sum;
     if (mbootFlag != 0)
-        sp[14] = 0;
+        packet[14] = 0;
     STWI_set_Callback_M(rfu_CB_configGameData);
-    STWI_send_GameConfigREQ(sp, uname);
+    STWI_send_GameConfigREQ(packet, uname);
 }
 
-static void rfu_CB_configGameData(u8 ip, u16 r7)
+static void rfu_CB_configGameData(u8 reqCommand, u16 reqResult)
 {
-    s32 r2, r3;
-    u8 *r4;
+    s32 serialNo;
+    u8 *gname_uname_p;
     u8 i;
-    u8 *r1;
+    u8 *packet_p;
 
-    if (r7 == 0)
+    if (reqResult == 0)
     {
-        r1 = gSTWIStatus->txPacket->rfuPacket8.data;
-        r2 = gRfuLinkStatus->my.serialNo = r1[4];
-        gRfuLinkStatus->my.serialNo = (r1[5] << 8) | r2;
-        r4 = &r1[6];
+        packet_p = gSTWIStatus->txPacket->rfuPacket8.data;
+        serialNo = gRfuLinkStatus->my.serialNo = packet_p[4];
+        gRfuLinkStatus->my.serialNo = (packet_p[5] << 8) | serialNo;
+        gname_uname_p = &packet_p[6];
         if (gRfuLinkStatus->my.serialNo & 0x8000)
         {
             gRfuLinkStatus->my.serialNo = gRfuLinkStatus->my.serialNo ^ 0x8000;
@@ -432,49 +488,54 @@ static void rfu_CB_configGameData(u8 ip, u16 r7)
             gRfuLinkStatus->my.mbootFlag = 0;
         }
         for (i = 0; i < RFU_GAME_NAME_LENGTH; ++i)
-            gRfuLinkStatus->my.gname[i] = *r4++;
-        ++r4;
+            gRfuLinkStatus->my.gname[i] = *gname_uname_p++;
+        ++gname_uname_p;
         for (i = 0; i < RFU_USER_NAME_LENGTH; ++i)
-            gRfuLinkStatus->my.uname[i] = *r4++;
+            gRfuLinkStatus->my.uname[i] = *gname_uname_p++;
     }
-    rfu_STC_REQ_callback(ip, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_startSearchChild(void)
 {
-    u16 r1;
+    u16 result;
+#if LIBRFU_VERSION >= 1026
+    u16 i;
+    for (i = 0; i < RFU_CHILD_MAX; i++)
+    {
+        gRfuStatic->lsFixedCount[i] = 0;
+    }
+#endif
 
-    for (r1 = 0; r1 < 4; ++r1)
-        gRfuStatic->lsFixedCount[r1] = 0;
     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;
@@ -499,11 +560,11 @@ void rfu_REQ_endSearchChild(void)
     STWI_send_SC_EndREQ();
 }
 
-static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult)
+static void rfu_CB_pollAndEndSearchChild(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_readChildList();
-    if (r4 == 26)
+    if (reqCommand == ID_SC_POLL_REQ)
     {
         if (gRfuLinkStatus->my.id == 0)
         {
@@ -513,41 +574,76 @@ static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult)
                 gRfuLinkStatus->my.id = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
         }
     }
-    else if (r4 == 27)
+    else if (reqCommand == ID_SC_END_REQ)
     {
         if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
             gRfuLinkStatus->my.id = 0;
         gRfuStatic->SCStartFlag = 0;
     }
-    rfu_STC_REQ_callback(r4, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 static void rfu_STC_readChildList(void)
 {
-    u32 r5;
-    u8 r8 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1];
-    u8 *r4;
+    u32 stwiParam;
+    u8 numSlots = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1];
+    u8 *data_p;
     u8 i;
-    u8 r2;
+    u8 bm_slot_id;
+#if LIBRFU_VERSION < 1026
+    u8 true_slots[RFU_CHILD_MAX];
+#endif
 
-    for (r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
-         r8 != 0;
-         r4 += 4)
+#if LIBRFU_VERSION < 1026
+    if (numSlots != 0)
     {
-        r2 = r4[2];
-        if (r2 < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1))
+        stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
+        STWI_set_Callback_M(rfu_CB_defaultCallback);
+        STWI_send_LinkStatusREQ();
+        if (STWI_poll_CommandEnd() == 0)
         {
-            gRfuStatic->lsFixedCount[r2] = 0xF0;
-            gRfuLinkStatus->strength[r2] = 0x10;
-            gRfuLinkStatus->connSlotFlag |= 1 << r2;
+            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] = stwiParam;
+    }
+#endif
+    for (data_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
+         numSlots != 0;
+         data_p += 4)
+    {
+        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 LIBRFU_VERSION < 1026
+            if (true_slots[bm_slot_id] != 0)
+                ++gRfuStatic->lsFixedCount[bm_slot_id];
+            if (gRfuStatic->lsFixedCount[bm_slot_id] >= 4)
+            {
+                gRfuStatic->lsFixedCount[bm_slot_id] = 0;
+                gRfuLinkStatus->strength[bm_slot_id] = 255;
+                gRfuLinkStatus->connSlotFlag |= 1 << bm_slot_id;
+                ++gRfuLinkStatus->connCount;
+                gRfuLinkStatus->partner[bm_slot_id].id = *(u16 *)data_p;
+                gRfuLinkStatus->partner[bm_slot_id].slot = bm_slot_id;
+                gRfuLinkStatus->parentChild = MODE_PARENT;
+                gRfuStatic->flags &= 0x7F;
+                gRfuStatic->cidBak[bm_slot_id] = gRfuLinkStatus->partner[bm_slot_id].id;
+            }
+        #else
+            gRfuStatic->lsFixedCount[bm_slot_id] = 0xF0;
+            gRfuLinkStatus->strength[bm_slot_id] = 16;
+            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;
+        #endif
         }
-        --r8;
+        --numSlots;
     }
 }
 
@@ -557,11 +653,11 @@ void rfu_REQ_startSearchParent(void)
     STWI_send_SP_StartREQ();
 }
 
-static void rfu_CB_startSearchParent(u8 r5, u16 reqResult)
+static void rfu_CB_startSearchParent(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
-        rfu_STC_clearLinkStatus(0);
-    rfu_STC_REQ_callback(r5, reqResult);
+        rfu_STC_clearLinkStatus(MODE_CHILD);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_pollSearchParent(void)
@@ -570,11 +666,11 @@ void rfu_REQ_pollSearchParent(void)
     STWI_send_SP_PollingREQ();
 }
 
-static void rfu_CB_pollSearchParent(u8 r5, u16 reqResult)
+static void rfu_CB_pollSearchParent(u8 reqCommand, u16 reqResult)
 {
     if (reqResult == 0)
         rfu_STC_readParentCandidateList();
-    rfu_STC_REQ_callback(r5, reqResult);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 void rfu_REQ_endSearchParent(void)
@@ -585,47 +681,47 @@ void rfu_REQ_endSearchParent(void)
 
 static void rfu_STC_readParentCandidateList(void)
 {
-    u8 r7, r6, r5, r4, r3;
-    u8 *r1, *r2;
-    struct RfuTgtData *r4_;
+    u8 numSlots, i, check_sum, my_check_sum, j;
+    u8 *uname_p, *packet_p;
+    struct RfuTgtData *target;
 
     CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner));
-    r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0];
-    r7 = r2[1];
-    r2 += 4;
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0];
+    numSlots = packet_p[1];
+    packet_p += 4;
     gRfuLinkStatus->findParentCount = 0;
-    for (r6 = 0; r6 < 4 && r7 != 0; ++r6)
-    {
-        r7 -= 7;
-        r1 = r2 + 6;
-        r2 += 19;
-        r5 = ~*r2;
-        ++r2;
-        r4 = 0;
-        for (r3 = 0; r3 < 8; ++r3)
+    for (i = 0; i < RFU_CHILD_MAX && numSlots != 0; ++i)
+    {
+        numSlots -= 7;
+        uname_p = packet_p + 6;
+        packet_p += 19;
+        check_sum = ~*packet_p;
+        ++packet_p;
+        my_check_sum = 0;
+        for (j = 0; j < 8; ++j)
         {
-            r4 += *r2++;
-            r4 += *r1++;
+            my_check_sum += *packet_p++;
+            my_check_sum += *uname_p++;
         }
-        if (r4 == r5)
+        if (my_check_sum == check_sum)
         {
-            r2 -= 28;
-            r4_ = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount];
-            r4_->id = *(u16 *)r2;
-            r2 += 2;
-            r4_->slot = *r2;
-            r2 += 2;
-            r4_->serialNo = *(u16 *)r2 & 0x7FFF;
-            if (*(u16 *)r2 & 0x8000)
-                r4_->mbootFlag = 1;
+            packet_p -= 28;
+            target = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount];
+            target->id = *(u16 *)packet_p;
+            packet_p += 2;
+            target->slot = *packet_p;
+            packet_p += 2;
+            target->serialNo = *(u16 *)packet_p & 0x7FFF;
+            if (*(u16 *)packet_p & 0x8000)
+                target->mbootFlag = 1;
             else
-                r4_->mbootFlag = 0;
-            r2 += 2;
-            for (r3 = 0; r3 < RFU_GAME_NAME_LENGTH; ++r3)
-                r4_->gname[r3] = *r2++;
-            ++r2;
-            for (r3 = 0; r3 < RFU_USER_NAME_LENGTH; ++r3)
-                r4_->uname[r3] = *r2++;
+                target->mbootFlag = 0;
+            packet_p += 2;
+            for (j = 0; j < RFU_GAME_NAME_LENGTH; ++j)
+                target->gname[j] = *packet_p++;
+            ++packet_p;
+            for (j = 0; j < RFU_USER_NAME_LENGTH; ++j)
+                target->uname[j] = *packet_p++;
             ++gRfuLinkStatus->findParentCount;
         }
     }
@@ -633,13 +729,13 @@ static void rfu_STC_readParentCandidateList(void)
 
 void rfu_REQ_startConnectParent(u16 pid)
 {
-    u16 r3 = 0;
+    u16 result = 0;
     u8 i;
     for (i = 0; i < RFU_CHILD_MAX && gRfuLinkStatus->partner[i].id != pid; ++i)
         ;
-    if (i == 4)
-        r3 = 256;
-    if (r3 == 0)
+    if (i == RFU_CHILD_MAX)
+        result = ERR_PID_NOT_FOUND;
+    if (result == 0)
     {
         gRfuStatic->tryPid = pid;
         STWI_set_Callback_M(rfu_STC_REQ_callback);
@@ -647,7 +743,7 @@ void rfu_REQ_startConnectParent(u16 pid)
     }
     else
     {
-        rfu_STC_REQ_callback(31, r3);
+        rfu_STC_REQ_callback(ID_CP_START_REQ, result);
     }
 }
 
@@ -657,70 +753,69 @@ void rfu_REQ_pollConnectParent(void)
     STWI_send_CP_PollingREQ();
 }
 
-static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28)
+static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult)
 {
     u16 id;
     u8 slot;
-    u8 r2, r5;
-    struct RfuTgtData *r9;
-    struct RfuTgtData sp;
+    u8 bm_slot_flag, i;
+    struct RfuTgtData *target_p;
+    struct RfuTgtData target_local;
 
-    if (sp28 == 0)
+    if (reqResult == 0)
     {
         id = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
         slot = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6];
         if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
         {
-            r2 = 1 << slot;
-            if (!(r2 & gRfuLinkStatus->connSlotFlag))
+            bm_slot_flag = 1 << slot;
+            if (!(bm_slot_flag & gRfuLinkStatus->connSlotFlag))
             {
-                gRfuLinkStatus->connSlotFlag |= r2;
-                gRfuLinkStatus->linkLossSlotFlag &= ~r2;
+                gRfuLinkStatus->connSlotFlag |= bm_slot_flag;
+                gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag;
                 gRfuLinkStatus->my.id = id;
                 ++gRfuLinkStatus->connCount;
                 gRfuLinkStatus->parentChild = MODE_CHILD;
                 gRfuStatic->flags |= 0x80;
-                for (r5 = 0; r5 < RFU_CHILD_MAX; ++r5)
+                for (i = 0; i < RFU_CHILD_MAX; ++i)
                 {
-                    if (gRfuLinkStatus->partner[r5].id == gRfuStatic->tryPid)
+                    if (gRfuLinkStatus->partner[i].id == gRfuStatic->tryPid)
                     {
                         if (gRfuLinkStatus->findParentCount != 0)
                         {
-                            r9 = &sp;
-                            CpuCopy16(&gRfuLinkStatus->partner[r5], &sp, sizeof(struct RfuTgtData));
+                            target_p = &target_local;
+                            CpuCopy16(&gRfuLinkStatus->partner[i], &target_local, sizeof(struct RfuTgtData));
                             CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner));
                             gRfuLinkStatus->findParentCount = 0;
                         }
                         else
                         {
-                            r9 = &gRfuLinkStatus->partner[r5];
+                            target_p = &gRfuLinkStatus->partner[i];
                         }
                         break;
                     }
                 }
-                if (r5 < RFU_CHILD_MAX)
+                if (i < RFU_CHILD_MAX)
                 {
-                    CpuCopy16(r9, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData));
+                    CpuCopy16(target_p, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData));
                     gRfuLinkStatus->partner[slot].slot = slot;
                 }
             }
         }
     }
-    rfu_STC_REQ_callback(sp24, sp28);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u16 rfu_getConnectParentStatus(u8 *status, u8 *connectSlotNo)
 {
-    u8 r0, *r2;
+    u8 *packet_p;
 
     *status = 0xFF;
-    r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-    r0 = r2[0] + 96;
-    if (r0 <= 1)
+    packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+    if (packet_p[0] == 0xa0 || packet_p[0] == 0xa1)
     {
-        r2 += 6;
-        *connectSlotNo = r2[0];
-        *status = r2[1];
+        packet_p += 6;
+        *connectSlotNo = packet_p[0];
+        *status = packet_p[1];
         return 0;
     }
     return ERR_REQ_CMD_ID;
@@ -736,28 +831,28 @@ void rfu_REQ_endConnectParent(void)
 
 u16 rfu_syncVBlank(void)
 {
-    u8 r3, r4;
-    s32 r5;
+    u8 masterSlave, i;
+    s32 bmSlotFlag;
 
     rfu_NI_checkCommFailCounter();
     if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
         return 0;
     if (gRfuStatic->nowWatchInterval != 0)
         --gRfuStatic->nowWatchInterval;
-    r3 = rfu_getMasterSlave();
+    masterSlave = rfu_getMasterSlave();
     if (!(gRfuStatic->flags & 2))
     {
-        if (r3 == 0)
+        if (masterSlave == AGB_CLK_SLAVE)
         {
             gRfuStatic->flags |= 4;
             gRfuStatic->watchdogTimer = 360;
         }
     }
-    else if (r3 != 0)
+    else if (masterSlave != AGB_CLK_SLAVE)
     {
         gRfuStatic->flags &= 0xFB;
     }
-    if (r3 != 0)
+    if (masterSlave != AGB_CLK_SLAVE)
         gRfuStatic->flags &= 0xFD;
     else
         gRfuStatic->flags |= 2;
@@ -766,10 +861,10 @@ u16 rfu_syncVBlank(void)
     if (gRfuStatic->watchdogTimer == 0)
     {
         gRfuStatic->flags &= 0xFB;
-        r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
-        for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
-            if ((r5 >> r4) & 1)
-                rfu_STC_removeLinkData(r4, 1);
+        bmSlotFlag = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
+            if ((bmSlotFlag >> i) & 1)
+                rfu_STC_removeLinkData(i, 1);
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
         return 1;
     }
@@ -779,13 +874,13 @@ u16 rfu_syncVBlank(void)
 
 u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason, u8 *parentBmLinkRecoverySlot)
 {
-    u8 sp08 = 0;
-    u8 sp0C = 0;
+    u8 reasonMaybe = 0;
+    u8 reqResult = 0;
     u8 i;
-    s32 sp10, sp14;
-    u8 *r2;
-    u8 r9, r6, r3, connSlotFlag, r0;
-    
+    s32 stwiCommand, stwiParam;
+    u8 *packet_p;
+    u8 to_req_disconnect, newLinkLossFlag, num_packets, connSlotFlag, to_disconnect;
+
     *bmLinkLossSlot = 0;
     *linkLossReason = REASON_DISCONNECTED;
     *parentBmLinkRecoverySlot = 0;
@@ -795,26 +890,30 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
         gRfuStatic->watchdogTimer = 360;
     if (gRfuStatic->nowWatchInterval == 0)
     {
+    #if LIBRFU_VERSION < 1026
+        gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval;
+    #else
         gRfuStatic->nowWatchInterval = 4;
-        sp08 = 1;
+    #endif
+        reasonMaybe = 1;
     }
-    if ((u8)reqCommandId == 41)
+    if ((u8)reqCommandId == ID_DISCONNECTED_AND_CHANGE_REQ)
     {
-        u8 *r1 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-        
-        *bmLinkLossSlot = r1[4];
-        *linkLossReason = r1[5];
+        u8 *packet_p_2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+
+        *bmLinkLossSlot = packet_p_2[4];
+        *linkLossReason = packet_p_2[5];
         if (*linkLossReason == REASON_LINK_LOSS)
             *bmLinkLossSlot = gRfuLinkStatus->connSlotFlag;
-        sp08 = 2;
+        reasonMaybe = 2;
     }
     else
     {
-        if (reqCommandId == 310)
+        if (reqCommandId == 0x0136)
         {
-            r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5];
-            r6 ^= gRfuLinkStatus->connSlotFlag;
-            *bmLinkLossSlot = r6 & gRfuLinkStatus->connSlotFlag;
+            newLinkLossFlag = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5];
+            newLinkLossFlag ^= gRfuLinkStatus->connSlotFlag;
+            *bmLinkLossSlot = newLinkLossFlag & gRfuLinkStatus->connSlotFlag;
             *linkLossReason = REASON_LINK_LOSS;
             for (i = 0; i < RFU_CHILD_MAX; ++i)
             {
@@ -825,39 +924,41 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
             }
         }
-        if (sp08 == 0)
+        if (reasonMaybe == 0)
             return 0;
     }
-    sp10 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command;
-    sp14 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
+    stwiCommand = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command;
+    stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0];
     STWI_set_Callback_M(rfu_CB_defaultCallback);
     STWI_send_LinkStatusREQ();
-    sp0C = STWI_poll_CommandEnd();
-    if (sp0C == 0)
+    reqResult = STWI_poll_CommandEnd();
+    if (reqResult == 0)
     {
-        r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
+        packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
         for (i = 0; i < RFU_CHILD_MAX; ++i)
-            gRfuLinkStatus->strength[i] = *r2++;
-        r9 = 0;
+            gRfuLinkStatus->strength[i] = *packet_p++;
+        to_req_disconnect = 0;
         i = 0;
     }
     else
     {
-        rfu_STC_REQ_callback(17, sp0C);
-        return sp0C;
+        rfu_STC_REQ_callback(ID_LINK_STATUS_REQ, reqResult);
+        return reqResult;
     }
     for (; i < RFU_CHILD_MAX; ++i)
     {
+    #if LIBRFU_VERSION >= 1026
         if (gRfuStatic->lsFixedCount[i] != 0)
         {
             gRfuStatic->lsFixedCount[i] -= 4;
             if (gRfuLinkStatus->strength[i] <= 15)
                 gRfuLinkStatus->strength[i] = 16;
         }
-        r6 = 1 << i;
-        if (sp0C == 0)
+    #endif
+        newLinkLossFlag = 1 << i;
+        if (reqResult == 0)
         {
-            if (sp08 == 1 && (gRfuLinkStatus->connSlotFlag & r6))
+            if (reasonMaybe == 1 && (gRfuLinkStatus->connSlotFlag & newLinkLossFlag))
             {
                 if (gRfuLinkStatus->strength[i] == 0)
                 {
@@ -866,8 +967,8 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                         ++gRfuStatic->linkEmergencyFlag[i];
                         if (gRfuStatic->linkEmergencyFlag[i] > 3)
                         {
-                            *bmLinkLossSlot |= r6;
-                            *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                            *bmLinkLossSlot |= newLinkLossFlag;
+                            *linkLossReason = REASON_LINK_LOSS;
                         }
                     }
                     else
@@ -877,18 +978,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                         {
                             if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
                             {
-                                *bmLinkLossSlot |= r6;
-                                *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                                *bmLinkLossSlot |= newLinkLossFlag;
+                                *linkLossReason = REASON_LINK_LOSS;
                             }
                             else
                             {
-                                if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->unk_1a)
+                                if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->linkEmergencyLimit)
                                 {
                                     gRfuStatic->linkEmergencyFlag[i] = 0;
                                     STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag);
                                     STWI_poll_CommandEnd();
-                                    *bmLinkLossSlot |= r6;
-                                    *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS?
+                                    *bmLinkLossSlot |= newLinkLossFlag;
+                                    *linkLossReason = REASON_LINK_LOSS;
                                 }
                             }
                         }
@@ -896,18 +997,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
                 else
                 {
-                    gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? 
+                    gRfuStatic->linkEmergencyFlag[i] = 0;
                 }
             }
             if (gRfuLinkStatus->parentChild == MODE_PARENT && gRfuLinkStatus->strength[i] != 0)
             {
-                if (r6 & gRfuLinkStatus->linkLossSlotFlag)
+                if (newLinkLossFlag & gRfuLinkStatus->linkLossSlotFlag)
                 {
                     if (gRfuLinkStatus->strength[i] > 10)
                     {
-                        *parentBmLinkRecoverySlot |= r6;
-                        gRfuLinkStatus->connSlotFlag |= r6;
-                        gRfuLinkStatus->linkLossSlotFlag &= ~r6;
+                        *parentBmLinkRecoverySlot |= newLinkLossFlag;
+                        gRfuLinkStatus->connSlotFlag |= newLinkLossFlag;
+                        gRfuLinkStatus->linkLossSlotFlag &= ~newLinkLossFlag;
                         ++gRfuLinkStatus->connCount;
                         gRfuStatic->linkEmergencyFlag[i] = 0;
                     }
@@ -918,19 +1019,19 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
                 }
                 else
                 {
-                    if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r6))
+                    if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & newLinkLossFlag))
                     {
                         STWI_send_SlotStatusREQ();
                         STWI_poll_CommandEnd();
-                        r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
-                        r3 = r2[1] - 1;
-                        for (r2 += 8; r3 != 0; r2 += 4, --r3)
+                        packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data;
+                        num_packets = packet_p[1] - 1;
+                        for (packet_p += 8; num_packets != 0; packet_p += 4, --num_packets)
                         {
-                            u16 r4 = *(u16 *)r2;
+                            u16 cid = *(u16 *)packet_p;
 
-                            if (r2[2] == i && r4 == gRfuStatic->cidBak[i])
+                            if (packet_p[2] == i && cid == gRfuStatic->cidBak[i])
                             {
-                                r9 |= 1 << i;
+                                to_req_disconnect |= 1 << i;
                                 break;
                             }
                         }
@@ -939,47 +1040,49 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason
             }
         }
         connSlotFlag = gRfuLinkStatus->connSlotFlag;
-        r0 = *bmLinkLossSlot;
-        r0 &= connSlotFlag;
-        if (r6 & r0)
+        to_disconnect = *bmLinkLossSlot;
+        to_disconnect &= connSlotFlag;
+        if (newLinkLossFlag & to_disconnect)
             rfu_STC_removeLinkData(i, 0);
     }
-    if (r9 != 0)
+    if (to_req_disconnect != 0)
     {
-        STWI_send_DisconnectREQ(r9);
+        STWI_send_DisconnectREQ(to_req_disconnect);
         STWI_poll_CommandEnd();
     }
     // equivalent to:
-    // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = sp10;
-    *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = sp10;
-    gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = sp14;
+    // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = stwiCommand;
+    *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = stwiCommand;
+    gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = stwiParam;
     return 0;
 }
 
-static void rfu_STC_removeLinkData(u8 r7, u8 r12)
+static void rfu_STC_removeLinkData(u8 bmConnectedPartnerId, u8 bmDisconnect)
 {
-    u8 r5 = 1 << r7;
-    s32 r6;
+    u8 bmLinkLossFlag = 1 << bmConnectedPartnerId;
+    s32 bmLinkRetainedFlag;
 
-    gRfuStatic->lsFixedCount[r7] = 0;
-    if ((gRfuLinkStatus->connSlotFlag & r5) && gRfuLinkStatus->connCount != 0)
+#if LIBRFU_VERSION >= 1026
+    gRfuStatic->lsFixedCount[bmConnectedPartnerId] = 0;
+#endif
+    if ((gRfuLinkStatus->connSlotFlag & bmLinkLossFlag) && gRfuLinkStatus->connCount != 0)
         --gRfuLinkStatus->connCount;
-    gRfuLinkStatus->connSlotFlag &= r6 = ~r5;
-    gRfuLinkStatus->linkLossSlotFlag |= r5;
-    if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0)
+    gRfuLinkStatus->connSlotFlag &= bmLinkRetainedFlag = ~bmLinkLossFlag;
+    gRfuLinkStatus->linkLossSlotFlag |= bmLinkLossFlag;
+    if (gRfuLinkStatus->parentChild == MODE_CHILD && gRfuLinkStatus->connSlotFlag == 0)
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
-    if (r12 != 0)
+    if (bmDisconnect)
     {
-        CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData));
-        gRfuLinkStatus->linkLossSlotFlag &= r6;
-        gRfuLinkStatus->getNameFlag &= r6;
-        gRfuLinkStatus->strength[r7] = 0;
+        CpuFill16(0, &gRfuLinkStatus->partner[bmConnectedPartnerId], sizeof(struct RfuTgtData));
+        gRfuLinkStatus->linkLossSlotFlag &= bmLinkRetainedFlag;
+        gRfuLinkStatus->getNameFlag &= bmLinkRetainedFlag;
+        gRfuLinkStatus->strength[bmConnectedPartnerId] = 0;
     }
 }
 
 void rfu_REQ_disconnect(u8 bmDisconnectSlot)
 {
-    u16 r1;
+    u16 result;
 
     if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmDisconnectSlot)
     {
@@ -992,9 +1095,9 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot)
         else if (gRfuStatic->SCStartFlag
               && (STWI_set_Callback_M(rfu_CB_defaultCallback),
                   STWI_send_SC_EndREQ(),
-                  (r1 = STWI_poll_CommandEnd()) != 0))
+                  (result = STWI_poll_CommandEnd()) != 0))
         {
-            rfu_STC_REQ_callback(27, r1);
+            rfu_STC_REQ_callback(ID_SC_END_REQ, result);
         }
         else
         {
@@ -1004,38 +1107,38 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot)
     }
 }
 
-static void rfu_CB_disconnect(u8 r6, u16 r5)
+static void rfu_CB_disconnect(u8 reqCommand, u16 reqResult)
 {
-    u8 r4, r0;
+    u8 i, bm_slot_flag;
 
-    if (r5 == 3 && gRfuLinkStatus->parentChild == MODE_CHILD)
+    if (reqResult == 3 && gRfuLinkStatus->parentChild == MODE_CHILD)
     {
         STWI_set_Callback_M(rfu_CB_defaultCallback);
         STWI_send_SystemStatusREQ();
         if (STWI_poll_CommandEnd() == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0)
-            r5 = 0;
+            reqResult = 0;
     }
     gRfuStatic->recoveryBmSlot &= gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
     gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8] = gRfuStatic->recoveryBmSlot;
-    if (r5 == 0)
+    if (reqResult == 0)
     {
-        for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r0 = 1 << r4;
-            if (r0 & gRfuStatic->recoveryBmSlot)
-                rfu_STC_removeLinkData(r4, 1);
+            bm_slot_flag = 1 << i;
+            if (bm_slot_flag & gRfuStatic->recoveryBmSlot)
+                rfu_STC_removeLinkData(i, 1);
         }
     }
     if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0)
         gRfuLinkStatus->parentChild = MODE_NEUTRAL;
-    rfu_STC_REQ_callback(r6, r5);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
     if (gRfuStatic->SCStartFlag)
     {
         STWI_set_Callback_M(rfu_CB_defaultCallback);
         STWI_send_SC_StartREQ();
-        r5 = STWI_poll_CommandEnd();
-        if (r5 != 0)
-            rfu_STC_REQ_callback(25, r5);
+        reqResult = STWI_poll_CommandEnd();
+        if (reqResult != 0)
+            rfu_STC_REQ_callback(ID_SC_START_REQ, reqResult);
     }
 }
 
@@ -1057,38 +1160,35 @@ void rfu_REQ_CHILD_pollConnectRecovery(void)
     STWI_send_CPR_PollingREQ();
 }
 
-static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7)
+static void rfu_CB_CHILD_pollConnectRecovery(u8 reqCommand, u16 reqResult)
 {
-    u8 r3, r4;
-    struct RfuLinkStatus *r2;
+    u8 bm_slot_flag, i;
+    struct RfuLinkStatus *rfuLinkStatus;
 
-    if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot)
+    if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot)
     {
         gRfuLinkStatus->parentChild = MODE_CHILD;
-        for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r3 = 1 << r4;
-            r2 = gRfuLinkStatus; // ???
-            if (gRfuStatic->recoveryBmSlot & r3 & r2->linkLossSlotFlag)
+            bm_slot_flag = 1 << i;
+            rfuLinkStatus = gRfuLinkStatus; // ???
+            if (gRfuStatic->recoveryBmSlot & bm_slot_flag & rfuLinkStatus->linkLossSlotFlag)
             {
-                gRfuLinkStatus->connSlotFlag |= r3;
-                gRfuLinkStatus->linkLossSlotFlag &= ~r3;
+                gRfuLinkStatus->connSlotFlag |= bm_slot_flag;
+                gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag;
                 ++gRfuLinkStatus->connCount;
-                gRfuStatic->linkEmergencyFlag[r4] = 0;
+                gRfuStatic->linkEmergencyFlag[i] = 0;
             }
         }
         gRfuStatic->recoveryBmSlot = 0;
     }
-    rfu_STC_REQ_callback(r8, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 u16 rfu_CHILD_getConnectRecoveryStatus(u8 *status)
 {
-    u8 r0;
-
     *status = 0xFF;
-    r0 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] + 77;
-    if (r0 <= 1)
+    if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB3 || gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB4)
     {
         *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4];
         return 0;
@@ -1116,14 +1216,14 @@ static void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size)
 
 void rfu_REQ_changeMasterSlave(void)
 {
-    if (STWI_read_status(1) == 1)
+    if (STWI_read_status(1) == AGB_CLK_MASTER)
     {
         STWI_set_Callback_M(rfu_STC_REQ_callback);
         STWI_send_MS_ChangeREQ();
     }
     else
     {
-        rfu_STC_REQ_callback(39, 0);
+        rfu_STC_REQ_callback(ID_MS_CHANGE_REQ, 0);
     }
 }
 
@@ -1133,11 +1233,11 @@ bool8 rfu_getMasterSlave(void)
 
     if (masterSlave == AGB_CLK_MASTER)
     {
-        if (gSTWIStatus->unk_2c)
+        if (gSTWIStatus->sending)
         {
-            if (gSTWIStatus->reqActiveCommand == 39
-             || gSTWIStatus->reqActiveCommand == 37
-             || gSTWIStatus->reqActiveCommand == 55)
+            if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ
+             || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)
                 masterSlave = AGB_CLK_SLAVE;
         }
     }
@@ -1148,7 +1248,7 @@ void rfu_clearAllSlot(void)
 {
     u16 i;
     u16 IMEBackup = REG_IME;
-    
+
     REG_IME = 0;
     for (i = 0; i < RFU_CHILD_MAX; ++i)
     {
@@ -1164,87 +1264,87 @@ void rfu_clearAllSlot(void)
     REG_IME = IMEBackup;
 }
 
-static void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4)
+static void rfu_STC_releaseFrame(u8 bm_slot_id, u8 send_recv, struct NIComm *NI_comm)
 {
 
     if (!(gRfuStatic->flags & 0x80))
     {
-        if (r3 == 0)
-            gRfuLinkStatus->remainLLFrameSizeParent += r4->payloadSize;
+        if (send_recv == 0)
+            gRfuLinkStatus->remainLLFrameSizeParent += NI_comm->payloadSize;
         gRfuLinkStatus->remainLLFrameSizeParent += 3;
     }
     else
     {
-        if (r3 == 0)
-            gRfuLinkStatus->remainLLFrameSizeChild[r5] += r4->payloadSize;
-        gRfuLinkStatus->remainLLFrameSizeChild[r5] += 2;
+        if (send_recv == 0)
+            gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += NI_comm->payloadSize;
+        gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += 2;
     }
 }
 
 u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex)
 {
-    u16 r10, r3, r1;
-    struct NIComm *r4;
+    u16 imeBak, send_recv, i;
+    struct NIComm *NI_comm;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
     if (!(connTypeFlag & (TYPE_UNI_SEND | TYPE_UNI_RECV | TYPE_NI_SEND | TYPE_NI_RECV)))
         return ERR_COMM_TYPE;
-    r10 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
     if (connTypeFlag & (TYPE_NI_SEND | TYPE_NI_RECV))
     {
-        for (r3 = 0; r3 < 2; ++r3)
+        for (send_recv = 0; send_recv < 2; ++send_recv)
         {
-            r4 = NULL;
-            if (r3 == 0)
+            NI_comm = NULL;
+            if (send_recv == 0)
             {
                 if (connTypeFlag & TYPE_NI_SEND)
                 {
-                    r4 = &gRfuSlotStatusNI[slotStatusIndex]->send;
-                    gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg;
+                    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->send;
+                    gRfuLinkStatus->sendSlotNIFlag &= ~NI_comm->bmSlotOrg;
                 }
             }
             else
             {
                 if (connTypeFlag & TYPE_NI_RECV)
                 {
-                    r4 = &gRfuSlotStatusNI[slotStatusIndex]->recv;
+                    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv;
                     gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex);
                 }
             }
-            if (r4 != NULL)
+            if (NI_comm != NULL)
             {
-                if (r4->state & SLOT_BUSY_FLAG)
+                if (NI_comm->state & SLOT_BUSY_FLAG)
                 {
-                    rfu_STC_releaseFrame(slotStatusIndex, r3, r4);
-                    for (r1 = 0; r1 < RFU_CHILD_MAX; ++r1)
-                        if ((r4->bmSlotOrg >> r1) & 1)
-                            r4->failCounter = 0;
+                    rfu_STC_releaseFrame(slotStatusIndex, send_recv, NI_comm);
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
+                        if ((NI_comm->bmSlotOrg >> i) & 1)
+                            NI_comm->failCounter = 0;
                 }
-                CpuFill16(0, r4, sizeof(struct NIComm));
+                CpuFill16(0, NI_comm, sizeof(struct NIComm));
             }
         }
     }
     if (connTypeFlag & TYPE_UNI_SEND)
     {
-        struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[slotStatusIndex];
+        struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[slotStatusIndex];
 
-        if (r3->send.state & SLOT_BUSY_FLAG)
+        if (slotStatusUNI->send.state & SLOT_BUSY_FLAG)
         {
             if (!(gRfuStatic->flags & 0x80))
-                gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->send.payloadSize;
+                gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)slotStatusUNI->send.payloadSize;
             else
-                gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)r3->send.payloadSize;
-            gRfuLinkStatus->sendSlotUNIFlag &= ~r3->send.bmSlot;
+                gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)slotStatusUNI->send.payloadSize;
+            gRfuLinkStatus->sendSlotUNIFlag &= ~slotStatusUNI->send.bmSlot;
         }
-        CpuFill16(0, &r3->send, sizeof(struct UNISend));
+        CpuFill16(0, &slotStatusUNI->send, sizeof(struct UNISend));
     }
     if (connTypeFlag & TYPE_UNI_RECV)
     {
         CpuFill16(0, &gRfuSlotStatusUNI[slotStatusIndex]->recv, sizeof(struct UNIRecv));
     }
-    REG_IME = r10;
+    REG_IME = imeBak;
     return 0;
 }
 
@@ -1290,16 +1390,16 @@ u16 rfu_NI_CHILD_setSendGameName(u8 slotNo, u8 subFrameSize)
     return rfu_STC_setSendData_org(64, 1 << slotNo, subFrameSize, &gRfuLinkStatus->my.serialNo, 26);
 }
 
-static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 sp28)
+static u16 rfu_STC_setSendData_org(u8 ni_or_uni, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 dataSize)
 {
-    u8 r2, r0;
-    u8 r4;
-    u8 *r9;
-    u8 r5;
+    u8 bm_slot_id, sendSlotFlag;
+    u8 frameSize;
+    u8 *llFrameSize_p;
+    u8 sending;
     u8 i;
-    u16 sp04;
-    struct RfuSlotStatusUNI *r1;
-    struct RfuSlotStatusNI *r12;
+    u16 imeBak;
+    struct RfuSlotStatusUNI *slotStatus_UNI;
+    struct RfuSlotStatusNI *slotStatus_NI;
 
     if (gRfuLinkStatus->parentChild == MODE_NEUTRAL)
         return ERR_MODE_NOT_CONNECTED;
@@ -1307,108 +1407,108 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const
         return ERR_SLOT_NO;
     if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmSendSlot) != bmSendSlot)
         return ERR_SLOT_NOT_CONNECTED;
-    if (r6 & 0x10)
-        r0 = gRfuLinkStatus->sendSlotUNIFlag;
+    if (ni_or_uni & 0x10)
+        sendSlotFlag = gRfuLinkStatus->sendSlotUNIFlag;
     else
-        r0 = gRfuLinkStatus->sendSlotNIFlag;
-    if (r0 & bmSendSlot)
+        sendSlotFlag = gRfuLinkStatus->sendSlotNIFlag;
+    if (sendSlotFlag & bmSendSlot)
         return ERR_SLOT_BUSY;
-    for (r2 = 0; r2 < RFU_CHILD_MAX && !((bmSendSlot >> r2) & 1); ++r2)
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX && !((bmSendSlot >> bm_slot_id) & 1); ++bm_slot_id)
         ;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
-        r9 = &gRfuLinkStatus->remainLLFrameSizeParent;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent;
     else if (gRfuLinkStatus->parentChild == MODE_CHILD)
-        r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2];
-    r4 = llsf_struct[gRfuLinkStatus->parentChild].unk00;
-    if (subFrameSize > *r9 || subFrameSize <= r4)
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id];
+    frameSize = llsf_struct[gRfuLinkStatus->parentChild].frameSize;
+    if (subFrameSize > *llFrameSize_p || subFrameSize <= frameSize)
         return ERR_SUBFRAME_SIZE;
-    sp04 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
-    r5 = r6 & 0x20;
-    if (r5 || r6 == 0x40)
-    {
-        u8 *r1; // a hack to swap instructions
-
-        r12 = gRfuSlotStatusNI[r2];
-        r1 = NULL;
-        r12->send.errorCode = 0;
-        *r12->send.now_p = r1 = &r12->send.dataType;
-        r12->send.remainSize = 7;
-        r12->send.bmSlotOrg = bmSendSlot;
-        r12->send.bmSlot = bmSendSlot;
-        r12->send.payloadSize = subFrameSize - r4;
-        if (r5 != 0)
-            *r1 = 0;
+    sending = ni_or_uni & 0x20;
+    if (sending || ni_or_uni == 0x40)
+    {
+        u8 *dataType_p; // a hack to swap instructions
+
+        slotStatus_NI = gRfuSlotStatusNI[bm_slot_id];
+        slotStatus_UNI = NULL;
+        slotStatus_NI->send.errorCode = 0;
+        *slotStatus_NI->send.now_p = dataType_p = &slotStatus_NI->send.dataType;
+        slotStatus_NI->send.remainSize = 7;
+        slotStatus_NI->send.bmSlotOrg = bmSendSlot;
+        slotStatus_NI->send.bmSlot = bmSendSlot;
+        slotStatus_NI->send.payloadSize = subFrameSize - frameSize;
+        if (sending != 0)
+            *dataType_p = 0;
         else
-            *r1 = 1;
-        r12->send.dataSize = sp28;
-        r12->send.src = src;
-        r12->send.ack = 0;
-        r12->send.phase = 0;
+            *dataType_p = 1;
+        slotStatus_NI->send.dataSize = dataSize;
+        slotStatus_NI->send.src = src;
+        slotStatus_NI->send.ack = 0;
+        slotStatus_NI->send.phase = 0;
     #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette
         asm("":::"r2");
     #endif
         for (i = 0; i < WINDOW_COUNT; ++i)
         {
-            r12->send.recvAckFlag[i] = 0;
-            r12->send.n[i] = 1;
+            slotStatus_NI->send.recvAckFlag[i] = 0;
+            slotStatus_NI->send.n[i] = 1;
         }
-        for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
-            if ((bmSendSlot >> r2) & 1)
-                gRfuSlotStatusNI[r2]->send.failCounter = 0;
+        for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
+            if ((bmSendSlot >> bm_slot_id) & 1)
+                gRfuSlotStatusNI[bm_slot_id]->send.failCounter = 0;
         gRfuLinkStatus->sendSlotNIFlag |= bmSendSlot;
-        *r9 -= subFrameSize;
-        r12->send.state = SLOT_STATE_SEND_START;
+        *llFrameSize_p -= subFrameSize;
+        slotStatus_NI->send.state = SLOT_STATE_SEND_START;
     }
-    else if (r6 & 0x10)
+    else if (ni_or_uni & 0x10)
     {
-        r1 = gRfuSlotStatusUNI[r2];
-        r1->send.bmSlot = bmSendSlot;
-        r1->send.src = src;
-        r1->send.payloadSize = subFrameSize - r4;
-        *r9 -= subFrameSize;
-        r1->send.state = SLOT_STATE_SEND_UNI;
+        slotStatus_UNI = gRfuSlotStatusUNI[bm_slot_id];
+        slotStatus_UNI->send.bmSlot = bmSendSlot;
+        slotStatus_UNI->send.src = src;
+        slotStatus_UNI->send.payloadSize = subFrameSize - frameSize;
+        *llFrameSize_p -= subFrameSize;
+        slotStatus_UNI->send.state = SLOT_STATE_SEND_UNI;
         gRfuLinkStatus->sendSlotUNIFlag |= bmSendSlot;
     }
-    REG_IME = sp04;
+    REG_IME = imeBak;
     return 0;
 }
 
 u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
 {
-    struct RfuSlotStatusNI *r5;
-    u16 r8;
-    u8 r2;
+    struct RfuSlotStatusNI *slotStatusNI;
+    u16 imeBak;
+    u8 i;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
     if (connType == 0x20)
     {
-        r5 = gRfuSlotStatusNI[slotStatusIndex];
-        if ((r5->send.state & SLOT_BUSY_FLAG)
-         && (r5->send.state & SLOT_SEND_FLAG))
+        slotStatusNI = gRfuSlotStatusNI[slotStatusIndex];
+        if ((slotStatusNI->send.state & SLOT_BUSY_FLAG)
+         && (slotStatusNI->send.state & SLOT_SEND_FLAG))
         {
-            connType = bmNewTgtSlot ^ r5->send.bmSlot;
-            
+            connType = bmNewTgtSlot ^ slotStatusNI->send.bmSlot;
+
             if (!(connType & bmNewTgtSlot))
             {
                 if (connType)
                 {
-                    r8 = REG_IME;
+                    imeBak = REG_IME;
                     REG_IME = 0;
-                    for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
                     {
-                        if ((connType >> r2) & 1)
-                            gRfuSlotStatusNI[r2]->send.failCounter = 0;
+                        if ((connType >> i) & 1)
+                            gRfuSlotStatusNI[i]->send.failCounter = 0;
                     }
                     gRfuLinkStatus->sendSlotNIFlag &= ~connType;
-                    r5->send.bmSlot = bmNewTgtSlot;
-                    if (r5->send.bmSlot == 0)
+                    slotStatusNI->send.bmSlot = bmNewTgtSlot;
+                    if (slotStatusNI->send.bmSlot == 0)
                     {
-                        rfu_STC_releaseFrame(slotStatusIndex, 0, &r5->send);
-                        r5->send.state = SLOT_STATE_SEND_FAILED;
+                        rfu_STC_releaseFrame(slotStatusIndex, 0, &slotStatusNI->send);
+                        slotStatusNI->send.state = SLOT_STATE_SEND_FAILED;
                     }
-                    REG_IME = r8;
+                    REG_IME = imeBak;
                 }
             }
             else
@@ -1425,21 +1525,21 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
     {
         if (connType == 16)
         {
-            s32 r3;
+            s32 bmSlot;
 
             if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != SLOT_STATE_SEND_UNI)
                 return ERR_SLOT_NOT_SENDING;
-            for (r3 = 0, r2 = 0; r2 < RFU_CHILD_MAX; ++r2)
-                if (r2 != slotStatusIndex)
-                    r3 |= gRfuSlotStatusUNI[r2]->send.bmSlot;
-            if (bmNewTgtSlot & r3)
+            for (bmSlot = 0, i = 0; i < RFU_CHILD_MAX; ++i)
+                if (i != slotStatusIndex)
+                    bmSlot |= gRfuSlotStatusUNI[i]->send.bmSlot;
+            if (bmNewTgtSlot & bmSlot)
                 return ERR_SLOT_TARGET;
-            r8 = REG_IME;
+            imeBak = REG_IME;
             REG_IME = 0;
             gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot;
             gRfuLinkStatus->sendSlotUNIFlag |= bmNewTgtSlot;
             gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot = bmNewTgtSlot;
-            REG_IME = r8;
+            REG_IME = imeBak;
         }
         else
         {
@@ -1451,14 +1551,14 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot)
 
 u16 rfu_NI_stopReceivingData(u8 slotStatusIndex)
 {
-    struct NIComm *r5;
-    u16 r4, r1;
+    struct NIComm *NI_comm;
+    u16 imeBak;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
-    r5 = &gRfuSlotStatusNI[slotStatusIndex]->recv;
-    r4 = REG_IME;
-    ++r4; --r4; // fix r4, r5 register swap
+    NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv;
+    imeBak = REG_IME;
+    ++imeBak; --imeBak; // fix imeBak, NI_comm register swap
     REG_IME = 0;
     if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & SLOT_BUSY_FLAG)
     {
@@ -1467,43 +1567,43 @@ u16 rfu_NI_stopReceivingData(u8 slotStatusIndex)
         else
             gRfuSlotStatusNI[slotStatusIndex]->recv.state = SLOT_STATE_RECV_FAILED;
         gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex);
-        rfu_STC_releaseFrame(slotStatusIndex, 1, r5);
+        rfu_STC_releaseFrame(slotStatusIndex, 1, NI_comm);
     }
-    REG_IME = r4;
+    REG_IME = imeBak;
     return 0;
 }
 
 u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size)
 {
-    struct UNISend *r4;
-    u8 *r6;
-    u16 r1;
-    u8 r3_;
+    struct UNISend *UNI_send;
+    u8 *frame_p;
+    u16 imeBak;
+    u8 frameEnd;
 
     if (slotStatusIndex >= RFU_CHILD_MAX)
         return ERR_SLOT_NO;
-    r4 = &gRfuSlotStatusUNI[slotStatusIndex]->send;
-    if (r4->state != SLOT_STATE_SEND_UNI)
+    UNI_send = &gRfuSlotStatusUNI[slotStatusIndex]->send;
+    if (UNI_send->state != SLOT_STATE_SEND_UNI)
         return ERR_SLOT_NOT_SENDING;
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
     {
-        r6 = &gRfuLinkStatus->remainLLFrameSizeParent;
-        r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize;
+        frame_p = &gRfuLinkStatus->remainLLFrameSizeParent;
+        frameEnd = gRfuLinkStatus->remainLLFrameSizeParent + (u8)UNI_send->payloadSize;
     }
     else
     {
-        r6 = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex];
-        r3_ = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)r4->payloadSize;
+        frame_p = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex];
+        frameEnd = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)UNI_send->payloadSize;
     }
-    if (r3_ < size)
+    if (frameEnd < size)
         return ERR_SUBFRAME_SIZE;
-    r1 = REG_IME;
+    imeBak = REG_IME;
     REG_IME = 0;
-    r4->src = src;
-    *r6 = r3_ - size;
-    r4->payloadSize = size;
-    r4->dataReadyFlag = 1;
-    REG_IME = r1;
+    UNI_send->src = src;
+    *frame_p = frameEnd - size;
+    UNI_send->payloadSize = size;
+    UNI_send->dataReadyFlag = 1;
+    REG_IME = imeBak;
     return 0;
 }
 
@@ -1582,184 +1682,184 @@ void rfu_REQ_sendData(bool8 clockChangeFlag)
     }
 }
 
-static void rfu_CB_sendData(__attribute__((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(__attribute__((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)
@@ -1773,435 +1873,433 @@ void rfu_REQ_recvData(void)
     }
 }
 
-static void rfu_CB_recvData(u8 r9, u16 r7)
+static void rfu_CB_recvData(u8 reqCommand, u16 reqResult)
 {
-    u8 r6;
-    struct RfuSlotStatusNI *r4;
-    struct NIComm *r5;
+    u8 i;
+    struct RfuSlotStatusNI *slotStatusNI;
+    struct NIComm *NI_comm;
 
-    if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1])
+    if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1])
     {
         gRfuStatic->NIEndRecvFlag = 0;
         if (gRfuLinkStatus->parentChild == MODE_PARENT)
             rfu_STC_PARENT_analyzeRecvPacket();
         else
             rfu_STC_CHILD_analyzeRecvPacket();
-        for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6)
+        for (i = 0; i < RFU_CHILD_MAX; ++i)
         {
-            r4 = gRfuSlotStatusNI[r6];
-            if (r4->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> r6) & 1))
+            slotStatusNI = gRfuSlotStatusNI[i];
+            if (slotStatusNI->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> i) & 1))
             {
-                r5 = &r4->recv;
-                if (r5->dataType == 1)
-                    gRfuLinkStatus->getNameFlag |= 1 << r6;
-                rfu_STC_releaseFrame(r6, 1, r5);
-                gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot;
-                r4->recv.state = SLOT_STATE_RECV_SUCCESS;
+                NI_comm = &slotStatusNI->recv;
+                if (NI_comm->dataType == 1)
+                    gRfuLinkStatus->getNameFlag |= 1 << i;
+                rfu_STC_releaseFrame(i, 1, NI_comm);
+                gRfuLinkStatus->recvSlotNIFlag &= ~NI_comm->bmSlot;
+                slotStatusNI->recv.state = SLOT_STATE_RECV_SUCCESS;
             }
         }
         if (gRfuStatic->recvErrorFlag)
-            r7 = gRfuStatic->recvErrorFlag | ERR_DATA_RECV;
+            reqResult = gRfuStatic->recvErrorFlag | ERR_DATA_RECV;
     }
-    rfu_STC_REQ_callback(r9, r7);
+    rfu_STC_REQ_callback(reqCommand, reqResult);
 }
 
 static void rfu_STC_PARENT_analyzeRecvPacket(void)
 {
-    u32 r3;
-    u8 r5;
-    u8 sp[4];
-    u8 *r6;
+    u32 frames32;
+    u8 bm_slot_id;
+    u8 frame_counts[RFU_CHILD_MAX];
+    u8 *packet_p;
 
-    r3 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8;
-    for (r5 = 0; r5 < NELEMS(sp); ++r5)
+    frames32 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8;
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
     {
-        sp[r5] = r3 & 0x1F;
-        r3 >>= 5;
-        if (sp[r5] == 0)
-            gRfuStatic->NIEndRecvFlag |= 1 << r5;
+        frame_counts[bm_slot_id] = frames32 & 0x1F;
+        frames32 >>= 5;
+        if (frame_counts[bm_slot_id] == 0)
+            gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id;
     }
-    r6 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
-    for (r5 = 0; r5 < NELEMS(sp); ++r5)
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
+    for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
     {
-        if (sp[r5])
+        if (frame_counts[bm_slot_id])
         {
-            u8 *r4 = &sp[r5];
+            u8 *frames_p = &frame_counts[bm_slot_id];
 
             do
             {
-                u8 r0 = rfu_STC_analyzeLLSF(r5, r6, *r4);
+                u8 analyzed_frames = rfu_STC_analyzeLLSF(bm_slot_id, packet_p, *frames_p);
 
-                r6 += r0;
-                *r4 -= r0;
-            } while (!(*r4 & 0x80) && (*r4));
+                packet_p += analyzed_frames;
+                *frames_p -= analyzed_frames;
+            } while (!(*frames_p & 0x80) && (*frames_p));
         }
     }
 }
 
 static void rfu_STC_CHILD_analyzeRecvPacket(void)
 {
-    u16 r4;
-    u8 *r5;
-    u16 r0;
+    u16 frames_remaining;
+    u8 *packet_p;
+    u16 analyzed_frames;
 
-    r4 = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F;
-    r5 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
-    if (r4 == 0)
+    frames_remaining = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F;
+    packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8];
+    if (frames_remaining == 0)
         gRfuStatic->NIEndRecvFlag = 15;
     do
     {
-        if (r4 == 0)
+        if (frames_remaining == 0)
             break;
-        r0 = rfu_STC_analyzeLLSF(0, r5, r4);
-        r5 += r0;
-        r4 -= r0;
-    } while (!(r4 & 0x8000));
-}
-
-static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3)
-{
-    struct RfuLocalStruct sp00;
-    const struct LLSFStruct *r6;
-    u32 r5;
-    u8 r4;
-    u32 r0;
-    u16 r10;
-
-    r6 = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)];
-    if (r3 < r6->unk00)
-        return r3;
-    r5 = 0;
-    for (r4 = 0; r4 < r6->unk00; ++r4)
-        r5 |= *r7++ << 8 * r4;
-    sp00.unk00 = (r5 >> r6->unk01) & r6->unk07;
-    sp00.unk01 = (r5 >> r6->unk02) & r6->unk08;
-    sp00.unk02 = (r5 >> r6->unk03) & r6->unk09;
-    sp00.unk03 = (r5 >> r6->unk04) & r6->unk0A;
-    sp00.unk04 = (r5 >> r6->unk05) & r6->unk0B;
-    sp00.unk05 = (r5 >> r6->unk06) & r6->unk0C;
-    sp00.unk06 = (r5  & r6->unk0E) & r5;
-    r10 = sp00.unk06 + r6->unk00;
-    if (sp00.unk00 == 0)
+        analyzed_frames = rfu_STC_analyzeLLSF(0, packet_p, frames_remaining);
+        packet_p += analyzed_frames;
+        frames_remaining -= analyzed_frames;
+    } while (!(frames_remaining & 0x8000));
+}
+
+static u16 rfu_STC_analyzeLLSF(u8 slot_id, const u8 *src, u16 last_frame)
+{
+    struct RfuLocalStruct llsf_NI;
+    const struct LLSFStruct *llsf_p;
+    u32 frames;
+    u8 i;
+    u16 retVal;
+
+    llsf_p = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)];
+    if (last_frame < llsf_p->frameSize)
+        return last_frame;
+    frames = 0;
+    for (i = 0; i < llsf_p->frameSize; ++i)
+        frames |= *src++ << 8 * i;
+    llsf_NI.recvFirst = (frames >> llsf_p->recvFirstShift) & llsf_p->recvFirstMask;
+    llsf_NI.connSlotFlag = (frames >> llsf_p->connSlotFlagShift) & llsf_p->connSlotFlagMask;
+    llsf_NI.slotState = (frames >> llsf_p->slotStateShift) & llsf_p->slotStateMask;
+    llsf_NI.ack = (frames >> llsf_p->ackShift) & llsf_p->ackMask;
+    llsf_NI.phase = (frames >> llsf_p->phaseShit) & llsf_p->phaseMask;
+    llsf_NI.n = (frames >> llsf_p->nShift) & llsf_p->nMask;
+    llsf_NI.frame = (frames  & llsf_p->framesMask) & frames;
+    retVal = llsf_NI.frame + llsf_p->frameSize;
+    if (llsf_NI.recvFirst == 0)
     {
         if (gRfuLinkStatus->parentChild == MODE_PARENT)
         {
-            if ((gRfuLinkStatus->connSlotFlag >> r12) & 1)
+            if ((gRfuLinkStatus->connSlotFlag >> slot_id) & 1)
             {
-                if (sp00.unk02 == 4)
+                if (llsf_NI.slotState == LCOM_UNI)
                 {
-                    rfu_STC_UNI_receive(r12, &sp00, r7);
+                    rfu_STC_UNI_receive(slot_id, &llsf_NI, src);
                 }
-                else if (sp00.unk03 == 0)
+                else if (llsf_NI.ack == 0)
                 {
-                    rfu_STC_NI_receive_Receiver(r12, &sp00, r7);
+                    rfu_STC_NI_receive_Receiver(slot_id, &llsf_NI, src);
                 }
                 else
                 {
-                    for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
-                        if (((gRfuSlotStatusNI[r4]->send.bmSlot >> r12) & 1)
-                         && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1))
+                    for (i = 0; i < RFU_CHILD_MAX; ++i)
+                        if (((gRfuSlotStatusNI[i]->send.bmSlot >> slot_id) & 1)
+                         && ((gRfuLinkStatus->sendSlotNIFlag >> slot_id) & 1))
                             break;
-                    if (r4 <= 3)
-                        rfu_STC_NI_receive_Sender(r4, r12, &sp00, r7);
+                    if (i < RFU_CHILD_MAX)
+                        rfu_STC_NI_receive_Sender(i, slot_id, &llsf_NI, src);
                 }
             }
         }
         else
         {
-            s32 r5 = gRfuLinkStatus->connSlotFlag & sp00.unk01;
+            s32 conSlots = gRfuLinkStatus->connSlotFlag & llsf_NI.connSlotFlag;
 
-            if (r5)
+            if (conSlots)
             {
-                for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4)
+                for (i = 0; i < RFU_CHILD_MAX; ++i)
                 {
-                    if ((r5 >> r4) & 1)
+                    if ((conSlots >> i) & 1)
                     {
-                        if (sp00.unk02 == 4)
-                            rfu_STC_UNI_receive(r4, &sp00, r7);
-                        else if (sp00.unk03 == 0)
-                            rfu_STC_NI_receive_Receiver(r4, &sp00, r7);
-                        else if ((gRfuLinkStatus->sendSlotNIFlag >> r4) & 1)
-                            rfu_STC_NI_receive_Sender(r4, r4, &sp00, r7);
+                        if (llsf_NI.slotState == LCOM_UNI)
+                            rfu_STC_UNI_receive(i, &llsf_NI, src);
+                        else if (llsf_NI.ack == 0)
+                            rfu_STC_NI_receive_Receiver(i, &llsf_NI, src);
+                        else if ((gRfuLinkStatus->sendSlotNIFlag >> i) & 1)
+                            rfu_STC_NI_receive_Sender(i, i, &llsf_NI, src);
                     }
                 }
             }
         }
     }
-    return r10;
+    return retVal;
 }
 
-static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 *sp00)
+static void rfu_STC_UNI_receive(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *src)
 {
-    u8 *sp04;
-    u32 r2;
-    struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7];
-    struct UNIRecv *r5 = &r3->recv;
+    u8 *dest;
+    u32 size;
+    struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[bm_slot_id];
+    struct UNIRecv *UNI_recv = &slotStatusUNI->recv;
 
-    r5->errorCode = 0;
-    if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06)
+    UNI_recv->errorCode = 0;
+    if (gRfuSlotStatusUNI[bm_slot_id]->recvBufferSize < llsf_NI->frame)
     {
-        r3->recv.state = SLOT_STATE_RECV_IGNORE;
-        r5->errorCode = ERR_RECV_BUFF_OVER;
+        slotStatusUNI->recv.state = SLOT_STATE_RECV_IGNORE;
+        UNI_recv->errorCode = ERR_RECV_BUFF_OVER;
     }
     else
-    { 
-        if (r5->dataBlockFlag)
+    {
+        if (UNI_recv->dataBlockFlag)
         {
-            if (r5->newDataFlag)
+            if (UNI_recv->newDataFlag)
             {
-                r5->errorCode = ERR_RECV_UNK;
-                goto _081E2F0E;
+                UNI_recv->errorCode = ERR_RECV_UNK;
+                goto force_tail_merge;
             }
         }
         else
         {
-            if (r5->newDataFlag)
-                r5->errorCode = ERR_RECV_DATA_OVERWRITED;
+            if (UNI_recv->newDataFlag)
+                UNI_recv->errorCode = ERR_RECV_DATA_OVERWRITED;
         }
-        r5->state = SLOT_STATE_RECEIVING;
-        r2 = r5->dataSize = r6->unk06;
-        sp04 = gRfuSlotStatusUNI[r7]->recvBuffer;
-        gRfuFixed->fastCopyPtr(&sp00, &sp04, r2);
-        r5->newDataFlag = 1;
-        r5->state = 0;
+        UNI_recv->state = SLOT_STATE_RECEIVING;
+        size = UNI_recv->dataSize = llsf_NI->frame;
+        dest = gRfuSlotStatusUNI[bm_slot_id]->recvBuffer;
+        gRfuFixed->fastCopyPtr(&src, &dest, size);
+        UNI_recv->newDataFlag = 1;
+        UNI_recv->state = 0;
     }
-_081E2F0E:
-    if (r5->errorCode)
-        gRfuStatic->recvErrorFlag |= 16 << r7;
+force_tail_merge:
+    if (UNI_recv->errorCode)
+        gRfuStatic->recvErrorFlag |= 16 << bm_slot_id;
 }
 
-static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct *r6, const u8 *r3)
+static void rfu_STC_NI_receive_Sender(u8 NI_slot, u8 bm_flag, const struct RfuLocalStruct *llsf_NI, const u8 *data_p)
 {
-    struct NIComm *r12 = &gRfuSlotStatusNI[r0]->send;
-    u16 r9 = r12->state;
-    u8 sp00 = r12->n[r6->unk04];
-    u8 *r8;
-    u8 r4;
-    u16 r2;
+    struct NIComm *NI_comm = &gRfuSlotStatusNI[NI_slot]->send;
+    u16 state = NI_comm->state;
+    u8 n = NI_comm->n[llsf_NI->phase];
+    u8 i;
+    u16 imeBak;
 
-    if ((r6->unk02 == 2 && r9 == SLOT_STATE_SENDING)
-     || (r6->unk02 == 1 && r9 == SLOT_STATE_SEND_START)
-     || (r6->unk02 == 3 && r9 == SLOT_STATE_SEND_LAST))
+    if ((llsf_NI->slotState == LCOM_NI && state == SLOT_STATE_SENDING)
+     || (llsf_NI->slotState == LCOM_NI_START && state == SLOT_STATE_SEND_START)
+     || (llsf_NI->slotState == LCOM_NI_END && state == SLOT_STATE_SEND_LAST))
     {
-        if (r12->n[r6->unk04] == r6->unk05)
-            r12->recvAckFlag[r6->unk04] |= 1 << r10;
+        if (NI_comm->n[llsf_NI->phase] == llsf_NI->n)
+            NI_comm->recvAckFlag[llsf_NI->phase] |= 1 << bm_flag;
     }
-    if ((r12->recvAckFlag[r6->unk04] & r12->bmSlot) == r12->bmSlot)
+    if ((NI_comm->recvAckFlag[llsf_NI->phase] & NI_comm->bmSlot) == NI_comm->bmSlot)
     {
-        r12->n[r6->unk04] = (r12->n[r6->unk04] + 1) & 3;
-        r12->recvAckFlag[r6->unk04] = 0;
-        if ((u16)(r12->state + ~SLOT_STATE_SEND_NULL) <= 1)
+        NI_comm->n[llsf_NI->phase] = (NI_comm->n[llsf_NI->phase] + 1) & 3;
+        NI_comm->recvAckFlag[llsf_NI->phase] = 0;
+        if ((u16)(NI_comm->state + ~SLOT_STATE_SEND_NULL) <= 1)
         {
-            if (r12->state == SLOT_STATE_SEND_START)
-                r12->now_p[r6->unk04] += r12->payloadSize;
+            if (NI_comm->state == SLOT_STATE_SEND_START)
+                NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize;
             else
-                r12->now_p[r6->unk04] += r12->payloadSize << 2;
-            r12->remainSize -= r12->payloadSize;
-            if (r12->remainSize != 0)
-                if (r12->remainSize >= 0)
+                NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize << 2;
+            NI_comm->remainSize -= NI_comm->payloadSize;
+            if (NI_comm->remainSize != 0)
+                if (NI_comm->remainSize >= 0)
                     goto _081E30AE;
-            // Above is a hack to avoid optimization over comparison. 
-            // rfu_STC_NI_constructLLSF uses this field as u32. 
-            // It's equivalent to the following condition: 
-            // if (r12->remainSize == 0 || r12->remainSize < 0)
-            {
-                r12->phase = 0;
-                if (r12->state == SLOT_STATE_SEND_START)
+            // Above is a hack to avoid optimization over comparison.
+            // rfu_STC_NI_constructLLSF uses this field as u32.
+            // It's equivalent to the following condition:
+            // if (NI_comm->remainSize == 0 || NI_comm->remainSize < 0)
                 {
-                    for (r4 = 0; r4 < WINDOW_COUNT; ++r4)
+                    NI_comm->phase = 0;
+                    if (NI_comm->state == SLOT_STATE_SEND_START)
                     {
-                        r12->n[r4] = 1;
-                        r12->now_p[r4] = r12->src + r12->payloadSize * r4;
+                        for (i = 0; i < WINDOW_COUNT; ++i)
+                        {
+                            NI_comm->n[i] = 1;
+                            NI_comm->now_p[i] = NI_comm->src + NI_comm->payloadSize * i;
+                        }
+                        NI_comm->remainSize = NI_comm->dataSize;
+                        NI_comm->state = SLOT_STATE_SENDING;
+                    }
+                    else
+                    {
+                        NI_comm->n[0] = 0;
+                        NI_comm->remainSize = 0;
+                        NI_comm->state = SLOT_STATE_SEND_LAST;
                     }
-                    r12->remainSize = r12->dataSize;
-                    r12->state = SLOT_STATE_SENDING;
-                }
-                else
-                {
-                    r12->n[0] = 0;
-                    r12->remainSize = 0;
-                    r12->state = SLOT_STATE_SEND_LAST;
                 }
-            }
         _081E30AE:
             ;
         }
-        else if (r12->state == SLOT_STATE_SEND_LAST)
+        else if (NI_comm->state == SLOT_STATE_SEND_LAST)
         {
-            r12->state = SLOT_STATE_SEND_NULL;
+            NI_comm->state = SLOT_STATE_SEND_NULL;
         }
     }
-    if (r12->state != r9
-     || r12->n[r6->unk04] != sp00
-     || (r12->recvAckFlag[r6->unk04] >> r10) & 1)
+    if (NI_comm->state != state
+     || NI_comm->n[llsf_NI->phase] != n
+     || (NI_comm->recvAckFlag[llsf_NI->phase] >> bm_flag) & 1)
     {
-        r2 = REG_IME;
+        imeBak = REG_IME;
         REG_IME = 0;
-        gRfuStatic->recvRenewalFlag |= 16 << r10;
-        gRfuSlotStatusNI[r10]->send.failCounter = 0;
-        REG_IME = r2;
+        gRfuStatic->recvRenewalFlag |= 16 << bm_flag;
+        gRfuSlotStatusNI[bm_flag]->send.failCounter = 0;
+        REG_IME = imeBak;
     }
 }
 
-static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, const u8 *sp00)
+static void rfu_STC_NI_receive_Receiver(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *data_p)
 {
-    u16 r2;
-    u32 r7 = 0;
-    struct RfuSlotStatusNI *r4 = gRfuSlotStatusNI[r8];
-    struct NIComm *r5 = &r4->recv;
-    u16 r9 = r4->recv.state;
-    u8 r10 = r4->recv.n[r6->unk04];
+    u16 imeBak;
+    u32 state_check = 0;
+    struct RfuSlotStatusNI *slotStatus_NI = gRfuSlotStatusNI[bm_slot_id];
+    struct NIComm *recvSlot = &slotStatus_NI->recv;
+    u16 state = slotStatus_NI->recv.state;
+    u8 n = slotStatus_NI->recv.n[llsf_NI->phase];
 
-    if (r6->unk02 == 3)
+    if (llsf_NI->slotState == LCOM_NI_END)
     {
-        gRfuStatic->NIEndRecvFlag |= 1 << r8;
-        if (r4->recv.state == SLOT_STATE_RECEIVING)
+        gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id;
+        if (slotStatus_NI->recv.state == SLOT_STATE_RECEIVING)
         {
-            r4->recv.phase = 0;
-            r4->recv.n[0] = 0;
-            r4->recv.state = SLOT_STATE_RECV_LAST;
+            slotStatus_NI->recv.phase = 0;
+            slotStatus_NI->recv.n[0] = 0;
+            slotStatus_NI->recv.state = SLOT_STATE_RECV_LAST;
         }
     }
-    else if (r6->unk02 == 2)
+    else if (llsf_NI->slotState == LCOM_NI)
     {
-        if (r9 == SLOT_STATE_RECV_START && !r5->remainSize)
-            rfu_STC_NI_initSlot_asRecvDataEntity(r8, r5);
-        if (r5->state == SLOT_STATE_RECEIVING)
-            r7 = 1;
+        if (state == SLOT_STATE_RECV_START && !recvSlot->remainSize)
+            rfu_STC_NI_initSlot_asRecvDataEntity(bm_slot_id, recvSlot);
+        if (recvSlot->state == SLOT_STATE_RECEIVING)
+            state_check = 1;
     }
-    else if (r6->unk02 == 1)
+    else if (llsf_NI->slotState == LCOM_NI_START)
     {
-        if (r9 == SLOT_STATE_RECV_START)
+        if (state == SLOT_STATE_RECV_START)
         {
-            r7 = 1;
+            state_check = 1;
         }
         else
         {
-            rfu_STC_NI_initSlot_asRecvControllData(r8, r5);
-            if (r4->recv.state != SLOT_STATE_RECV_START)
+            rfu_STC_NI_initSlot_asRecvControllData(bm_slot_id, recvSlot);
+            if (slotStatus_NI->recv.state != SLOT_STATE_RECV_START)
                 return;
-            r7 = 1;
+            state_check = 1;
         }
     }
-    if (r7 != 0)
+    if (state_check != 0)
     {
-        if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3))
+        if (llsf_NI->n == ((recvSlot->n[llsf_NI->phase] + 1) & 3))
         {
-            gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->now_p[r6->unk04], r6->unk06);
-            if (r5->state == SLOT_STATE_RECEIVING)
-                r5->now_p[r6->unk04] += 3 * r5->payloadSize;
-            r5->remainSize -= r6->unk06;
-            r5->n[r6->unk04] = r6->unk05;
+            gRfuFixed->fastCopyPtr(&data_p, (u8 **)&recvSlot->now_p[llsf_NI->phase], llsf_NI->frame);
+            if (recvSlot->state == SLOT_STATE_RECEIVING)
+                recvSlot->now_p[llsf_NI->phase] += 3 * recvSlot->payloadSize;
+            recvSlot->remainSize -= llsf_NI->frame;
+            recvSlot->n[llsf_NI->phase] = llsf_NI->n;
         }
     }
-    if (r5->errorCode == 0)
+    if (recvSlot->errorCode == 0)
     {
-        r5->phase = r6->unk04;
-        if (r5->state != r9 || r5->n[r6->unk04] != r10 || r5->n[r6->unk04] == r6->unk05)
+        recvSlot->phase = llsf_NI->phase;
+        if (recvSlot->state != state || recvSlot->n[llsf_NI->phase] != n || recvSlot->n[llsf_NI->phase] == llsf_NI->n)
         {
-            r2 = REG_IME;
+            imeBak = REG_IME;
             REG_IME = 0;
-            gRfuStatic->recvRenewalFlag |= 1 << r8;
-            r5->failCounter = 0;
-            REG_IME = r2;
+            gRfuStatic->recvRenewalFlag |= 1 << bm_slot_id;
+            recvSlot->failCounter = 0;
+            REG_IME = imeBak;
         }
     }
 }
 
-static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2)
+static void rfu_STC_NI_initSlot_asRecvControllData(u8 bm_slot_id, struct NIComm *NI_comm)
 {
-    u8 *r1;
-    u32 r5;
-    u8 r6;
+    u8 *llFrameSize_p;
+    u32 llFrameSize;
+    u8 bm_slot_flag;
 
     if (gRfuLinkStatus->parentChild == MODE_PARENT)
     {
-        r5 = 3;
-        r1 = &gRfuLinkStatus->remainLLFrameSizeParent;
+        llFrameSize = 3;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent;
     }
     else
     {
-        r5 = 2;
-        r1 = &gRfuLinkStatus->remainLLFrameSizeChild[r4];
+        llFrameSize = 2;
+        llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id];
     }
-    r6 = 1 << r4;
-    if (r2->state == 0)
+    bm_slot_flag = 1 << bm_slot_id;
+    if (NI_comm->state == 0)
     {
-        if (*r1 < r5)
+        if (*llFrameSize_p < llFrameSize)
         {
-            r2->state = SLOT_STATE_RECV_IGNORE;
-            r2->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE;
-            gRfuStatic->recvErrorFlag |= r6;
+            NI_comm->state = SLOT_STATE_RECV_IGNORE;
+            NI_comm->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE;
+            gRfuStatic->recvErrorFlag |= bm_slot_flag;
         }
         else
         {
-            r2->errorCode = 0;
-            *r1 -= r5;
-            r2->now_p[0] = &r2->dataType;
-            r2->remainSize = 7;
-            r2->ack = 1;
-            r2->payloadSize = 0;
-            r2->bmSlot = r6;
-            r2->state = SLOT_STATE_RECV_START;
-            gRfuLinkStatus->recvSlotNIFlag |= r6;
+            NI_comm->errorCode = 0;
+            *llFrameSize_p -= llFrameSize;
+            NI_comm->now_p[0] = &NI_comm->dataType;
+            NI_comm->remainSize = 7;
+            NI_comm->ack = 1;
+            NI_comm->payloadSize = 0;
+            NI_comm->bmSlot = bm_slot_flag;
+            NI_comm->state = SLOT_STATE_RECV_START;
+            gRfuLinkStatus->recvSlotNIFlag |= bm_slot_flag;
         }
     }
 }
 
-static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4)
+static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 bm_slot_id, struct NIComm *NI_comm)
 {
-    u8 r1, r3;
+    u8 bm_slot_flag, win_id;
 
-    if (r4->dataType == 1)
+    if (NI_comm->dataType == 1)
     {
-        r4->now_p[0] = (void *)&gRfuLinkStatus->partner[r5].serialNo;
+        NI_comm->now_p[0] = (void *)&gRfuLinkStatus->partner[bm_slot_id].serialNo;
     }
     else
     {
-        if (r4->dataSize > gRfuSlotStatusNI[r5]->recvBufferSize)
+        if (NI_comm->dataSize > gRfuSlotStatusNI[bm_slot_id]->recvBufferSize)
         {
-            r1 = 1 << r5;
-            gRfuStatic->recvErrorFlag |= r1;
-            gRfuLinkStatus->recvSlotNIFlag &= ~r1;
-            r4->errorCode = ERR_RECV_BUFF_OVER;
-            r4->state = SLOT_STATE_RECV_FAILED;
-            rfu_STC_releaseFrame(r5, 1, r4);
+            bm_slot_flag = 1 << bm_slot_id;
+            gRfuStatic->recvErrorFlag |= bm_slot_flag;
+            gRfuLinkStatus->recvSlotNIFlag &= ~bm_slot_flag;
+            NI_comm->errorCode = ERR_RECV_BUFF_OVER;
+            NI_comm->state = SLOT_STATE_RECV_FAILED;
+            rfu_STC_releaseFrame(bm_slot_id, 1, NI_comm);
             return;
         }
-        r4->now_p[0] = gRfuSlotStatusNI[r5]->recvBuffer;
+        NI_comm->now_p[0] = gRfuSlotStatusNI[bm_slot_id]->recvBuffer;
     }
-    for (r3 = 0; r3 < WINDOW_COUNT; ++r3)
+    for (win_id = 0; win_id < WINDOW_COUNT; ++win_id)
     {
-        r4->n[r3] = 0;
-        r4->now_p[r3] = &r4->now_p[0][r4->payloadSize * r3];
+        NI_comm->n[win_id] = 0;
+        NI_comm->now_p[win_id] = &NI_comm->now_p[0][NI_comm->payloadSize * win_id];
     }
-    r4->remainSize = r4->dataSize;
-    r4->state = SLOT_STATE_RECEIVING;
+    NI_comm->remainSize = NI_comm->dataSize;
+    NI_comm->state = SLOT_STATE_RECEIVING;
 }
 
 static void rfu_NI_checkCommFailCounter(void)
 {
-    u16 r12;
-    u32 r7;
-    u8 r2, r3;
+    u16 imeBak;
+    u32 recvRenewalFlag;
+    u8 bm_slot_flag, bm_slot_id;
 
     if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag)
     {
-        r12 = REG_IME;
+        imeBak = REG_IME;
         REG_IME = 0;
-        r7 = gRfuStatic->recvRenewalFlag >> 4;
-        for (r3 = 0; r3 < RFU_CHILD_MAX; ++r3)
+        recvRenewalFlag = gRfuStatic->recvRenewalFlag >> 4;
+        for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id)
         {
-            r2 = 1 << r3;
-            if (gRfuLinkStatus->sendSlotNIFlag & r2
-             && !(gRfuStatic->recvRenewalFlag & r2))
-                ++gRfuSlotStatusNI[r3]->send.failCounter;
-            if (gRfuLinkStatus->recvSlotNIFlag & r2
-             && !(r7 & r2))
-                ++gRfuSlotStatusNI[r3]->recv.failCounter;
+            bm_slot_flag = 1 << bm_slot_id;
+            if (gRfuLinkStatus->sendSlotNIFlag & bm_slot_flag
+             && !(gRfuStatic->recvRenewalFlag & bm_slot_flag))
+                ++gRfuSlotStatusNI[bm_slot_id]->send.failCounter;
+            if (gRfuLinkStatus->recvSlotNIFlag & bm_slot_flag
+             && !(recvRenewalFlag & bm_slot_flag))
+                ++gRfuSlotStatusNI[bm_slot_id]->recv.failCounter;
         }
         gRfuStatic->recvRenewalFlag = 0;
-        REG_IME = r12;
+        REG_IME = imeBak;
     }
 }
 
diff --git a/src/librfu_sio32id.c b/src/librfu_sio32id.c
index fc5701986..b6623540f 100644
--- a/src/librfu_sio32id.c
+++ b/src/librfu_sio32id.c
@@ -4,44 +4,56 @@ static void Sio32IDIntr(void);
 static void Sio32IDInit(void);
 static s32 Sio32IDMain(void);
 
+struct RfuSIO32Id
+{
+    u8 MS_mode;
+    u8 state;
+    u16 count;
+    u16 send_id;
+    u16 recv_id;
+    u16 unk8; // unused
+    u16 lastId;
+};
+
 struct RfuSIO32Id gRfuSIO32Id;
 
 static const u16 Sio32ConnectionData[] = { 0x494e, 0x544e, 0x4e45, 0x4f44 }; // NINTENDO
 static const char Sio32IDLib_Var[] = "Sio32ID_030820";
 
-s32 AgbRFU_checkID(u8 r5)
+s32 AgbRFU_checkID(u8 maxTries)
 {
-    u16 r8;
-    vu16 *r4;
-    s32 r6;
+    u16 ieBak;
+    vu16 *regTMCNTL;
+    s32 id;
 
+    // Interrupts must be enabled
     if (REG_IME == 0)
         return -1;
-    r8 = REG_IE;
+    ieBak = REG_IE;
     gSTWIStatus->state = 10;
     STWI_set_Callback_ID(Sio32IDIntr);
     Sio32IDInit();
-    r4 = &REG_TMCNT_L(gSTWIStatus->timerSelect);
-    r5 *= 8;
-    while (--r5 != 0xFF)
+    regTMCNTL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
+    maxTries *= 8;
+    while (--maxTries != 0xFF)
     {
-        r6 = Sio32IDMain();
-        if (r6 != 0)
+        id = Sio32IDMain();
+        if (id != 0)
             break;
-        r4[1] = 0;
-        r4[0] = 0;
-        r4[1] = TIMER_1024CLK | TIMER_ENABLE;
-        while (r4[0] < 32)
+        regTMCNTL[1] = 0;
+        regTMCNTL[0] = 0;
+        regTMCNTL[1] = TIMER_1024CLK | TIMER_ENABLE;
+        while (regTMCNTL[0] < 32)
             ;
-        r4[1] = 0;
-        r4[0] = 0;
+        regTMCNTL[1] = 0;
+        regTMCNTL[0] = 0;
     }
     REG_IME = 0;
-    REG_IE = r8;
+    REG_IE = ieBak;
     REG_IME = 1;
     gSTWIStatus->state = 0;
     STWI_set_Callback_ID(NULL);
-    return r6;
+    return id;
 }
 
 static void Sio32IDInit(void)
@@ -58,107 +70,105 @@ static void Sio32IDInit(void)
 
 static s32 Sio32IDMain(void)
 {
-    u8 r12;
-
-    switch (r12 = gRfuSIO32Id.unk1)
+    switch (gRfuSIO32Id.state)
     {
     case 0:
-        gRfuSIO32Id.unk0 = 1;
+        gRfuSIO32Id.MS_mode = AGB_CLK_MASTER;
         REG_SIOCNT |= SIO_38400_BPS;
-        REG_IME = r12;
+        REG_IME = 0;
         REG_IE |= INTR_FLAG_SERIAL;
         REG_IME = 1;
-        gRfuSIO32Id.unk1 = 1;
+        gRfuSIO32Id.state = 1;
         *(vu8 *)&REG_SIOCNT |= SIO_ENABLE;
         break;
     case 1:
-        if (gRfuSIO32Id.unkA == 0)
+        if (gRfuSIO32Id.lastId == 0)
         {
-            if (gRfuSIO32Id.unk0 == 1)
+            if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER)
             {
-                if (gRfuSIO32Id.unk2 == 0)
+                if (gRfuSIO32Id.count == 0)
                 {
-                    REG_IME = gRfuSIO32Id.unk2;
+                    REG_IME = 0;
                     REG_SIOCNT |= SIO_ENABLE;
-                    REG_IME = r12;
+                    REG_IME = 1;
                 }
             }
-            else if (gRfuSIO32Id.unk4 != 0x8001 && !gRfuSIO32Id.unk2)
+            else if (gRfuSIO32Id.send_id != RFU_ID && !gRfuSIO32Id.count)
             {
-                REG_IME = gRfuSIO32Id.unk2;
+                REG_IME = 0;
                 REG_IE &= ~INTR_FLAG_SERIAL;
-                REG_IME = r12;
-                REG_SIOCNT = gRfuSIO32Id.unk2;
+                REG_IME = 1;
+                REG_SIOCNT = 0;
                 REG_SIOCNT = SIO_32BIT_MODE;
                 REG_IF = INTR_FLAG_SERIAL;
                 REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE;
-                REG_IME = gRfuSIO32Id.unk2;
+                REG_IME = 0;
                 REG_IE |= INTR_FLAG_SERIAL;
-                REG_IME = r12;
+                REG_IME = 1;
             }
             break;
         }
         else
         {
-            gRfuSIO32Id.unk1 = 2;
+            gRfuSIO32Id.state = 2;
             // fallthrough
         }
     default:
-        return gRfuSIO32Id.unkA;
+        return gRfuSIO32Id.lastId;
     }
     return 0;
 }
 
 static void Sio32IDIntr(void)
 {
-    u32 r5;
-    u16 r0;
+    u32 regSIODATA32;
+    u16 delay;
 #ifndef NONMATCHING
-    register u32 r1 asm("r1");
-    register u16 r0_ asm("r0");
+    register u32 rfuSIO32IdUnk0_times_16 asm("r1");
+    register u16 negRfuSIO32IdUnk6 asm("r0");
 #else
-    u32 r1;
-    u16 r0_;
+    u32 rfuSIO32IdUnk0_times_16;
+    u16 negRfuSIO32IdUnk6;
 #endif
 
-    r5 = REG_SIODATA32;
-    if (gRfuSIO32Id.unk0 != 1)
+    regSIODATA32 = REG_SIODATA32;
+    if (gRfuSIO32Id.MS_mode != AGB_CLK_MASTER)
         REG_SIOCNT |= SIO_ENABLE;
-    r1 = 16 * gRfuSIO32Id.unk0; // to handle side effect of inline asm
-    r1 = (r5 << r1) >> 16;
-    r5 = (r5 << 16 * (1 - gRfuSIO32Id.unk0)) >> 16;
-    if (gRfuSIO32Id.unkA == 0)
+    rfuSIO32IdUnk0_times_16 = 16 * gRfuSIO32Id.MS_mode; // to handle side effect of inline asm
+    rfuSIO32IdUnk0_times_16 = (regSIODATA32 << rfuSIO32IdUnk0_times_16) >> 16;
+    regSIODATA32 = (regSIODATA32 << 16 * (1 - gRfuSIO32Id.MS_mode)) >> 16;
+    if (gRfuSIO32Id.lastId == 0)
     {
-        if (r1 == gRfuSIO32Id.unk6)
+        if (rfuSIO32IdUnk0_times_16 == gRfuSIO32Id.recv_id)
         {
-            if (gRfuSIO32Id.unk2 > 3)
+            if (gRfuSIO32Id.count > 3)
             {
-                gRfuSIO32Id.unkA = r5;
+                gRfuSIO32Id.lastId = regSIODATA32;
             }
-            else if (r1 == (u16)~gRfuSIO32Id.unk4)
+            else if (rfuSIO32IdUnk0_times_16 == (u16)~gRfuSIO32Id.send_id)
             {
-                r0_ = ~gRfuSIO32Id.unk6;
-                if (r5 == r0_)
-                    ++gRfuSIO32Id.unk2;
+                negRfuSIO32IdUnk6 = ~gRfuSIO32Id.recv_id;
+                if (regSIODATA32 == negRfuSIO32IdUnk6)
+                    ++gRfuSIO32Id.count;
             }
         }
         else
         {
-            gRfuSIO32Id.unk2 = gRfuSIO32Id.unkA;
+            gRfuSIO32Id.count = 0;
         }
     }
-    if (gRfuSIO32Id.unk2 < 4)
-        gRfuSIO32Id.unk4 = *(gRfuSIO32Id.unk2 + Sio32ConnectionData);
+    if (gRfuSIO32Id.count < 4)
+        gRfuSIO32Id.send_id = *(gRfuSIO32Id.count + Sio32ConnectionData);
     else
-        gRfuSIO32Id.unk4 = 0x8001;
-    gRfuSIO32Id.unk6 = ~r5;
-    REG_SIODATA32 = (gRfuSIO32Id.unk4 << 16 * (1 - gRfuSIO32Id.unk0))
-                  + (gRfuSIO32Id.unk6 << 16 * gRfuSIO32Id.unk0);
-    if (gRfuSIO32Id.unk0 == 1 && (gRfuSIO32Id.unk2 || r5 == 0x494E))
+        gRfuSIO32Id.send_id = RFU_ID;
+    gRfuSIO32Id.recv_id = ~regSIODATA32;
+    REG_SIODATA32 = (gRfuSIO32Id.send_id << 16 * (1 - gRfuSIO32Id.MS_mode))
+                  + (gRfuSIO32Id.recv_id << 16 * gRfuSIO32Id.MS_mode);
+    if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER && (gRfuSIO32Id.count != 0 || regSIODATA32 == 0x494e))
     {
-        for (r0 = 0; r0 < 600; ++r0)
+        for (delay = 0; delay < 600; ++delay)
             ;
-        if (gRfuSIO32Id.unkA == 0)
+        if (gRfuSIO32Id.lastId == 0)
             REG_SIOCNT |= SIO_ENABLE;
     }
 }
diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c
index b88f21737..0287b358a 100644
--- a/src/librfu_stwi.c
+++ b/src/librfu_stwi.c
@@ -28,8 +28,8 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b
     }
     gSTWIStatus->rxPacket = &interruptStruct->rxPacketAlloc;
     gSTWIStatus->txPacket = &interruptStruct->txPacketAlloc;
-    gSTWIStatus->msMode = 1;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->msMode = AGB_CLK_MASTER;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     gSTWIStatus->ackLength = 0;
@@ -39,7 +39,7 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b
     gSTWIStatus->timerActive = 0;
     gSTWIStatus->error = 0;
     gSTWIStatus->recoveryCount = 0;
-    gSTWIStatus->unk_2c = 0;
+    gSTWIStatus->sending = 0;
     REG_RCNT = 0x100; // TODO: mystery bit? 
     REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
     STWI_init_Callback_M();
@@ -71,7 +71,7 @@ void AgbRFU_SoftReset(void)
     *timerH = 3;
     REG_RCNT = 0x80A0;
     REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     gSTWIStatus->reqActiveCommand = 0;
@@ -81,9 +81,9 @@ void AgbRFU_SoftReset(void)
     gSTWIStatus->timerState = 0;
     gSTWIStatus->timerActive = 0;
     gSTWIStatus->error = 0;
-    gSTWIStatus->msMode = 1;
+    gSTWIStatus->msMode = AGB_CLK_MASTER;
     gSTWIStatus->recoveryCount = 0;
-    gSTWIStatus->unk_2c = 0;
+    gSTWIStatus->sending = 0;
 }
 
 void STWI_set_MS_mode(u8 mode)
@@ -131,12 +131,12 @@ void STWI_set_Callback_S(void (*callbackS)(u16))
 
 void STWI_set_Callback_ID(void (*func)(void)) // name in SDK, but is actually setting a function pointer
 {
-    gSTWIStatus->unk_20 = func;
+    gSTWIStatus->callbackID = func;
 }
 
 u16 STWI_poll_CommandEnd(void)
 {
-    while (gSTWIStatus->unk_2c == TRUE)
+    while (gSTWIStatus->sending == 1)
         ;
     return gSTWIStatus->error;
 }
@@ -195,7 +195,7 @@ void STWI_send_ConfigStatusREQ(void)
     }
 }
 
-void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data)
+void STWI_send_GameConfigREQ(const u8 *serial_gname, const u8 *uname)
 {
     u8 *packetBytes;
     s32 i;
@@ -203,29 +203,28 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data)
     if (!STWI_init(ID_GAME_CONFIG_REQ))
     {
         gSTWIStatus->reqLength = 6;
-        // TODO: what is unk1
         packetBytes = gSTWIStatus->txPacket->rfuPacket8.data;
         packetBytes += sizeof(u32);
-        *(u16 *)packetBytes = *(u16 *)unk1;
+        *(u16 *)packetBytes = *(u16 *)serial_gname;
         packetBytes += sizeof(u16);
-        unk1 += sizeof(u16);
+        serial_gname += sizeof(u16);
         for (i = 0; i < 14; ++i)
         {
-            *packetBytes = *unk1;
+            *packetBytes = *serial_gname;
             ++packetBytes;
-            ++unk1;
+            ++serial_gname;
         }
         for (i = 0; i < 8; ++i)
         {
-            *packetBytes = *data;
+            *packetBytes = *uname;
             ++packetBytes;
-            ++data;
+            ++uname;
         }
         STWI_start_Command();
     }
 }
 
-void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
+void STWI_send_SystemConfigREQ(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer)
 {
     if (!STWI_init(ID_SYSTEM_CONFIG_REQ))
     {
@@ -234,9 +233,9 @@ void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
         gSTWIStatus->reqLength = 1;
         packetBytes = gSTWIStatus->txPacket->rfuPacket8.data;
         packetBytes += sizeof(u32);
-        *packetBytes++ = unk3;
-        *packetBytes++ = unk2;
-        *(u16*)packetBytes = unk1;
+        *packetBytes++ = mcTimer;
+        *packetBytes++ = maxMFrame;
+        *(u16*)packetBytes = availSlotFlag;
         STWI_start_Command();
     }
 }
@@ -499,20 +498,17 @@ static void STWI_intr_timer(void)
         STWI_stop_timer();
         STWI_reset_ClockCounter();
         if (gSTWIStatus->callbackM != NULL)
-            gSTWIStatus->callbackM(255, 0);
+            gSTWIStatus->callbackM(ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ, 0);
         break;
     }
 }
 
-static void STWI_set_timer(u8 unk)
+static void STWI_set_timer(u8 count)
 {
-    vu16 *timerL;
-    vu16 *timerH;
-
-    timerL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
-    timerH = &REG_TMCNT_H(gSTWIStatus->timerSelect);
+    vu16 *timerL = &REG_TMCNT_L(gSTWIStatus->timerSelect);
+    vu16 *timerH = &REG_TMCNT_H(gSTWIStatus->timerSelect);
     REG_IME = 0;
-    switch (unk)
+    switch (count)
     {
     case 50:
         *timerL = 0xFCCB;
@@ -543,25 +539,31 @@ static void STWI_stop_timer(void)
     REG_TMCNT_H(gSTWIStatus->timerSelect) = 0;
 }
 
+/*
+ * Set up STWI to send REQ. Returns 1 if error (see below).
+ */
 static u16 STWI_init(u8 request)
 {
     if (!REG_IME)
     {
+        // Can't start sending if IME is disabled.
         gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error);
         return TRUE;
     }
-    else if (gSTWIStatus->unk_2c == TRUE)
+    else if (gSTWIStatus->sending == 1)
     {
+        // Already sending something. Cancel and error.
         gSTWIStatus->error = ERR_REQ_CMD_SENDING;
-        gSTWIStatus->unk_2c = FALSE;
+        gSTWIStatus->sending = 0;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error);
         return TRUE;
     }
-    else if(!gSTWIStatus->msMode)
+    else if (gSTWIStatus->msMode == AGB_CLK_SLAVE)
     {
+        // Can't send if clock slave
         gSTWIStatus->error = ERR_REQ_CMD_CLOCK_SLAVE;
         if (gSTWIStatus->callbackM != NULL)
             gSTWIStatus->callbackM(request, gSTWIStatus->error, gSTWIStatus);
@@ -569,9 +571,10 @@ static u16 STWI_init(u8 request)
     }
     else
     {
-        gSTWIStatus->unk_2c = TRUE;
+        // Good to go, start sending
+        gSTWIStatus->sending = 1;
         gSTWIStatus->reqActiveCommand = request;
-        gSTWIStatus->state = 0;
+        gSTWIStatus->state = 0; // master send req
         gSTWIStatus->reqLength = 0;
         gSTWIStatus->reqNext = 0;
         gSTWIStatus->ackLength = 0;
@@ -595,7 +598,7 @@ static s32 STWI_start_Command(void)
     // but the cast here is required to avoid register issue
     *(u32 *)gSTWIStatus->txPacket->rfuPacket8.data = 0x99660000 | (gSTWIStatus->reqLength << 8) | gSTWIStatus->reqActiveCommand;
     REG_SIODATA32 = gSTWIStatus->txPacket->rfuPacket32.command;
-    gSTWIStatus->state = 0;
+    gSTWIStatus->state = 0; // master send req
     gSTWIStatus->reqNext = 1;
     imeTemp = REG_IME;
     REG_IME = 0;
@@ -608,7 +611,7 @@ static s32 STWI_start_Command(void)
 
 static s32 STWI_restart_Command(void)
 {
-    if (gSTWIStatus->recoveryCount <= 1)
+    if (gSTWIStatus->recoveryCount < 2)
     {
         ++gSTWIStatus->recoveryCount;
         STWI_start_Command();
@@ -618,17 +621,17 @@ static s32 STWI_restart_Command(void)
         if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_UNK35_REQ || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)
         {
             gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT;
-            gSTWIStatus->unk_2c = 0;
+            gSTWIStatus->sending = 0;
             if (gSTWIStatus->callbackM != NULL)
                 gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error);
         }
         else
         {
             gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT;
-            gSTWIStatus->unk_2c = 0;
+            gSTWIStatus->sending = 0;
             if (gSTWIStatus->callbackM != NULL)
                 gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error);
-            gSTWIStatus->state = 4; // TODO: what's 4
+            gSTWIStatus->state = 4; // error
         }
     }
     return 0;
@@ -636,7 +639,7 @@ static s32 STWI_restart_Command(void)
 
 static s32 STWI_reset_ClockCounter(void)
 {
-    gSTWIStatus->state = 5; // TODO: what is 5
+    gSTWIStatus->state = 5; // slave receive req init
     gSTWIStatus->reqLength = 0;
     gSTWIStatus->reqNext = 0;
     REG_SIODATA32 = (1 << 31);
diff --git a/src/link.c b/src/link.c
index 939a4afc8..34c9ee7ef 100644
--- a/src/link.c
+++ b/src/link.c
@@ -223,7 +223,7 @@ bool8 IsWirelessAdapterConnected(void)
 {
     sub_800B488();
     sub_800E700();
-    if (sub_800BEC0() == 0x8001)
+    if (rfu_LMAN_REQBN_softReset_and_checkID() == 0x8001)
     {
         rfu_REQ_stopMode();
         rfu_waitREQComplete();
diff --git a/src/link_rfu.c b/src/link_rfu.c
deleted file mode 100644
index 9291f574e..000000000
--- a/src/link_rfu.c
+++ /dev/null
@@ -1,5146 +0,0 @@
-#include "global.h"
-#include "malloc.h"
-#include "battle.h"
-#include "berry_blender.h"
-#include "decompress.h"
-#include "event_data.h"
-#include "gpu_regs.h"
-#include "librfu.h"
-#include "link.h"
-#include "link_rfu.h"
-#include "overworld.h"
-#include "random.h"
-#include "palette.h"
-#include "union_room.h"
-#include "string_util.h"
-#include "task.h"
-#include "text.h"
-#include "constants/species.h"
-#include "save.h"
-#include "mystery_gift.h"
-
-extern u16 gHeldKeyCodeToSend;
-
-struct UnkRfuStruct_1 gUnknown_03004140;
-struct UnkRfuStruct_2 gUnknown_03005000;
-
-BSS_DATA u8 gUnknown_03000D74;
-ALIGNED(4) BSS_DATA u8 gUnknown_03000D78[8];
-BSS_DATA u8 gUnknown_03000D80[16];
-BSS_DATA u16 gUnknown_03000D90[8];
-
-EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0;
-EWRAM_DATA ALIGNED(4) struct UnkLinkRfuStruct_02022B14 gUnknown_02022B14 = {};
-EWRAM_DATA ALIGNED(2) u8 gUnknown_02022B22[PLAYER_NAME_LENGTH + 1] = {};
-EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_02022B2C = {};
-EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_02022B44 = {};
-
-// Static ROM declarations
-static void sub_800C000(void);
-static void sub_800C7B4(u16 r8, u16 r6);
-static void sub_800C744(u32 a0);
-static void sub_800CEB0(u16 r6);
-static void sub_800CF34(void);
-static void sub_800D158(void);
-static void sub_800D20C(void);
-static void sub_800D268(void);
-static u8 sub_800D294(void);
-static void sub_800D30C(u8 a0, u8 a1);
-static void sub_800D334(u8 a0);
-static void sub_800D358(u8 a0);
-static void sub_800D434(void);
-static void sub_800D610(void);
-void sub_800D630(void);
-static bool8 sub_800DAC8(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2);
-static void sub_800EAB4(void);
-static void sub_800EAFC(void);
-void sub_800ED34(u16 unused);
-static void sub_800EDBC(u16 unused);
-static void sub_800F048(void);
-static void sub_800F86C(u8 unused);
-static void sub_800FCC4(struct UnkRfuStruct_2_Sub_6c *data);
-void sub_800FD14(u16 command);
-static void rfufunc_80F9F44(void);
-static void sub_800FFB0(void);
-static void rfufunc_80FA020(void);
-bool32 sub_8010454(u32 a0);
-static void sub_8010528(void);
-void sub_8010750(void);
-s32 sub_80107A0(void);
-void sub_801084C(u8 taskId);
-void sub_80109E8(u16 a0);
-void sub_8010A70(void *a0);
-void sub_8010AAC(u8 taskId);
-void sub_8010D0C(u8 taskId);
-void sub_80115EC(s32 a0);
-u8 sub_8011CE4(const u8 *a0, u16 a1);
-void sub_8011D6C(u32 a0);
-void sub_8011E94(u32 a0, u32 a1);
-bool8 sub_8012224(void);
-void sub_801227C(void);
-void sub_801209C(u8 taskId);
-void sub_8011BF8(void);
-void sub_8011BA4(void);
-
-// .rodata
-
-const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal");
-const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz");
-const u8 sWireless_ASCIItoRSETable[] = {
-    0xff, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x37,
-    0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
-    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
-    0x00, 0xab, 0xb5, 0xb6, 0xb1, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xb2, 0xf1, 0x00, 0xae, 0xad, 0xba,
-    0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
-    0xa9, 0xaa, 0x00, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
-    0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1,
-    0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
-    0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
-    0xd2, 0xd3, 0xd4, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
-    0x00, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
-    0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
-    0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
-    0xec, 0xed, 0xee, 0x2d, 0x2f, 0x30, 0x31, 0x32,
-    0x33, 0x34, 0x35, 0x36, 0x50, 0x00, 0x01, 0x02,
-    0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
-    0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
-    0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
-    0x1b, 0xad, 0xb3, 0xb4, 0x00, 0xaf, 0x7d, 0x7f,
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xa0,
-    0xae, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
-    0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
-    0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
-    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
-    0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7e, 0xb0, 0xac,
-    0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
-    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
-    0x2c, 0x2e, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
-    0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94
-};
-const u8 sWireless_RSEtoASCIITable[] = {
-    0x20, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
-    0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94,
-    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c,
-    0x9d, 0x9e, 0x9f, 0xa0, 0xe0, 0xe1, 0xe2, 0xe3,
-    0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
-    0xec, 0xed, 0xee, 0xef, 0xf0, 0x7b, 0xf1, 0x7c,
-    0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x07,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-    0x84, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xa6, 0xdd, 0xa7,
-    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xf2,
-    0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
-    0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0x03,
-    0x04, 0x05, 0x06, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-    0xaf, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
-    0x37, 0x38, 0x39, 0x21, 0xdf, 0xa1, 0xb0, 0xa5,
-    0xde, 0x24, 0x2a, 0xa2, 0xa3, 0x22, 0x23, 0x20,
-    0xa4, 0x20, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45,
-    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
-    0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
-    0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63,
-    0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
-    0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
-    0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x20,
-    0x20, 0x2b, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00
-};
-const struct OamData sWirelessStatusIndicatorOamData =
-{
-    .y = 0,
-    .affineMode = ST_OAM_AFFINE_OFF,
-    .objMode = ST_OAM_OBJ_NORMAL,
-    .bpp = ST_OAM_4BPP,
-    .shape = SPRITE_SHAPE(16x16),
-    .x = 0,
-    .size = SPRITE_SIZE(16x16),
-    .tileNum = 0,
-    .priority = 0,
-    .paletteNum = 0,
-};
-static const union AnimCmd sWirelessStatusIndicatorAnim0[] = {
-    // 3 bars
-    ANIMCMD_FRAME( 4,  5),
-    ANIMCMD_FRAME( 8,  5),
-    ANIMCMD_FRAME(12,  5),
-    ANIMCMD_FRAME(16, 10),
-    ANIMCMD_FRAME(12,  5),
-    ANIMCMD_FRAME( 8,  5),
-    ANIMCMD_JUMP(0)
-};
-static const union AnimCmd sWirelessStatusIndicatorAnim1[] = {
-    // 2 bars
-    ANIMCMD_FRAME( 4,  5),
-    ANIMCMD_FRAME( 8,  5),
-    ANIMCMD_FRAME(12, 10),
-    ANIMCMD_FRAME( 8,  5),
-    ANIMCMD_JUMP(0)
-};
-static const union AnimCmd sWirelessStatusIndicatorAnim2[] = {
-    // 1 bar
-    ANIMCMD_FRAME(4, 5),
-    ANIMCMD_FRAME(8, 5),
-    ANIMCMD_JUMP(0)
-};
-static const union AnimCmd sWirelessStatusIndicatorAnim3[] = {
-    // searching
-    ANIMCMD_FRAME( 4, 10),
-    ANIMCMD_FRAME(20, 10),
-    ANIMCMD_JUMP(0)
-};
-static const union AnimCmd sWirelessStatusIndicatorAnim4[] = {
-    // error
-    ANIMCMD_FRAME(24, 10),
-    ANIMCMD_FRAME( 4, 10),
-    ANIMCMD_JUMP(0)
-};
-static const union AnimCmd *const sWirelessStatusIndicatorAnims[] = {
-    sWirelessStatusIndicatorAnim0,
-    sWirelessStatusIndicatorAnim1,
-    sWirelessStatusIndicatorAnim2,
-    sWirelessStatusIndicatorAnim3,
-    sWirelessStatusIndicatorAnim4
-};
-const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = {
-    gWirelessLinkIconPic, 0x0380, 0xD431
-};
-const struct SpritePalette sWirelessStatusIndicatorSpritePalette = {
-    gWirelessLinkIconPalette, 0xD432
-};
-static const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = {
-    0xD431,
-    0xD432,
-    &sWirelessStatusIndicatorOamData,
-    sWirelessStatusIndicatorAnims,
-    NULL,
-    gDummySpriteAffineAnimTable,
-    SpriteCallbackDummy
-};
-
-const struct UnkLinkRfuStruct_02022B2C gUnknown_082ED608 = {
-    0x04, 0x20, 0x00, 0x00, 0x02,
-    &gUnknown_02022B14,
-    gUnknown_02022B22,
-    0x01, 0x00, 0x258, 0x12c
-};
-const u8 gUnknown_082ED620[] = {
-    0, 3, 2, 1, 0
-};
-const u32 gUnknown_082ED628[] = {
-    0x000000,
-    0x000001,
-    0x000003,
-    0x000007,
-    0x00000f,
-    0x00001f,
-    0x00003f,
-    0x00007f,
-    0x0000ff,
-    0x0001ff,
-    0x0003ff,
-    0x0007ff,
-    0x000fff,
-    0x001fff,
-    0x003fff,
-    0x007fff,
-    0x00ffff,
-    0x01ffff,
-    0x03ffff,
-    0x07ffff,
-    0x0fffff,
-    0x1fffff,
-    0x3fffff,
-    0x7fffff,
-    0xffffff
-};
-const u8 gUnknown_082ED68C[] = {
-    0, 0, 1,
-    1, 2, 2,
-    2, 2, 3
-};
-const u8 gUnknown_082ED695[] = {
-    0, 1, 1, 2,
-    1, 2, 2, 3,
-    1, 2, 2, 3,
-    2, 3, 3, 4
-};
-const u8 gUnknown_082ED6A5[] = {
-    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
-};
-const struct {
-    u8 *buffer;
-    u32 size;
-} gUnknown_082ED6B8[] = {
-    { gBlockSendBuffer, 200 },
-    { gBlockSendBuffer, 200 },
-    { gBlockSendBuffer, 100 },
-    { gBlockSendBuffer, 220 },
-    { gBlockSendBuffer,  40 }
-};
-const u16 gUnknown_082ED6E0[] = {
-    0x0002, 0x7f7d, 0x0000, 0xFFFF
-};
-
-const char sUnref_082ED6E8[][15] = {
-    "RFU WAIT",
-    "RFU BOOT",
-    "RFU ERROR",
-    "RFU RESET",
-    "RFU CONFIG",
-    "RFU START",
-    "RFU SC POLL",
-    "RFU SP POLL",
-    "RFU START",
-    "RFU SEND ERR",
-    "RFU CP POLL"
-};
-const char sUnref_082ED6E9[][16] = {
-    "              ",
-    "RECOVER START ",
-    "DISSCONECT    ",
-    "RECOVER SUUSES",
-    "RECOVER FAILED"
-};
-const TaskFunc gUnknown_082ED7E0[] = {
-    sub_801084C,
-    sub_8010AAC,
-    sub_8010D0C
-};
-const char gUnknown_082ED7EC[] = "PokemonSioInfo";
-const char gUnknown_082ED7FC[] = "LINK LOSS DISCONNECT!";
-const char gUnknown_082ED814[] = "LINK LOSS RECOVERY NOW";
-
-ALIGNED(4) const char gUnknown_082ED82C[31] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',0x00};
-const char gUnknown_082ED84B[16] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',0x00};
-const char gUnknown_082ED85B[9] = {' ',' ',' ',' ',' ',' ',' ',' ',0x00};
-ALIGNED(4) const char gUnknown_082ED864[2] = {' ',0x00};
-const char gUnknown_082ED866[2] = {'*',0x00};
-const char gUnknown_082ED868[8] = "NOWSLOT";
-const char gUnknown_082ED870[12] = "           ";
-const char gUnknown_082ED87C[12] = "CLOCK DRIFT";
-const char gUnknown_082ED888[12] = "BUSY SEND  ";
-const char gUnknown_082ED894[12] = "CMD REJECT ";
-const char gUnknown_082ED8A0[12] = "CLOCK SLAVE";
-const char gUnknown_082ED8A8[3][8] = {
-    "CHILD ",
-    "PARENT",
-    "SEARCH"
-};
-
-// .text
-
-u32 sub_800BEC0(void)
-{
-    u32 r4;
-
-    r4 = rfu_REQBN_softReset_and_checkID();
-    if (r4 == 0x8001)
-    {
-        gUnknown_03004140.unk_08 = 1;
-    }
-    if (gUnknown_03004140.unk_04 != 0x17 && gUnknown_03004140.unk_04 != 0x01)
-    {
-        gUnknown_03004140.unk_05 = 0;
-        gUnknown_03004140.unk_04 = 0;
-    }
-    gUnknown_03004140.unk_07 = 0;
-    gUnknown_03004140.unk_0d = 0;
-    gUnknown_03004140.unk_01 = 0;
-    gUnknown_03004140.unk_00 = 0;
-    gUnknown_03004140.unk_06 = -1;
-    sub_800D610();
-    return r4;
-}
-
-void rfu_REQ_sendData_wrapper(u8 r2)
-{
-    u8 val;
-    if (!gRfuLinkStatus->parentChild)
-    {
-        val = gUnknown_03004140.unk_02;
-        r2 = 0;
-        if (val == 1)
-        {
-            r2 = 1;
-        }
-    }
-    else
-    {
-        gUnknown_03004140.unk_03 = 0;
-    }
-    rfu_REQ_sendData(r2);
-}
-
-s32 sub_800BF4C(void (*func1)(u8, u8), void (*func2)(u16))
-{
-    if (func1 == NULL)
-    {
-        return 4;
-    }
-    CpuFill16(0, &gUnknown_03004140, offsetof(struct UnkRfuStruct_1, filler_48));
-    gUnknown_03004140.unk_06 = -1;
-    gUnknown_03004140.unk_40 = func1;
-    gUnknown_03004140.unk_44 = func2;
-    rfu_setMSCCallback(sub_800CEB0);
-    rfu_setREQCallback(sub_800C7B4);
-    return 0;
-}
-
-void sub_800BFA0(void)
-{
-    CpuFill16(0, &gUnknown_03004140, offsetof(struct UnkRfuStruct_1, unk_40));
-    gUnknown_03004140.unk_06 = -1;
-}
-
-void sub_800BFCC(const struct UnkLinkRfuStruct_02022B2C *unk0)
-{
-    sub_800C000();
-    gUnknown_03004140.unk_04 = 1;
-    gUnknown_03004140.unk_05 = 2;
-    gUnknown_03004140.unk_3c = unk0;
-    gUnknown_03004140.unk_09 = unk0->unk_11;
-    gUnknown_03004140.unk_32 = unk0->unk_12;
-    gUnknown_03004140.unk_18 = unk0->unk_14;
-    if (unk0->unk_10)
-    {
-        gUnknown_03004140.unk_0b = 1;
-    }
-}
-
-static void sub_800C000(void)
-{
-    u8 i;
-
-    gUnknown_03004140.unk_05 = 0;
-    gUnknown_03004140.unk_04 = 0;
-    gUnknown_03004140.unk_06 = -1;
-    gUnknown_03004140.unk_07 = 0;
-    gUnknown_03004140.unk_10 = 0;
-    gUnknown_03004140.unk_0c = 0;
-    gUnknown_03004140.unk_24 = 0;
-    gUnknown_03004140.unk_30 = 0;
-    for (i = 0; i < 4; i++)
-    {
-        gUnknown_03004140.unk_28[i] = 0;
-        gUnknown_03004140.unk_34[i] = 0;
-    }
-}
-
-void sub_800C048(void)
-{
-    gUnknown_03004140.unk_04 = 0x15;
-}
-
-u8 sub_800C054(u8 r5, u16 r7, u16 r8, const u16 *r6)
-{
-    u8 i;
-    const u16 *buffer;
-
-    if (gUnknown_03004140.unk_04 != 0 && (gUnknown_03004140.unk_04 != 0x08 || r5 != 1))
-    {
-        gUnknown_03004140.unk_14 = 1;
-        sub_800D30C(0xf3, 0x01);
-        return 1;
-    }
-    if (!rfu_getMasterSlave())
-    {
-        gUnknown_03004140.unk_14 = 2;
-        sub_800D30C(0xf3, 0x01);
-        return 2;
-    }
-    for (i = 0, buffer = r6; i < 16; i++)
-    {
-        if (*buffer++ == 0xFFFF)
-        {
-            break;
-        }
-    }
-    if (i == 16)
-    {
-        gUnknown_03004140.unk_14 = 4;
-        sub_800D30C(0xf3, 0x01);
-        return 4;
-    }
-    if (r5 > 1)
-    {
-        gUnknown_03004140.unk_07 = 1;
-        r5 = 1;
-        r7 = 0;
-    }
-    else
-    {
-        gUnknown_03004140.unk_07 = 0;
-    }
-    if (r5 != 0)
-    {
-        gUnknown_03004140.unk_04 = 5;
-    }
-    else
-    {
-        gUnknown_03004140.unk_04 = 9;
-        if (gUnknown_03004140.unk_0b)
-        {
-            gUnknown_03004140.unk_0b = 2;
-        }
-    }
-    gUnknown_03004140.unk_06 = r5;
-    gUnknown_03004140.unk_1a = r7;
-    gUnknown_03004140.unk_26 = r8;
-    gUnknown_03004140.unk_20 = r6;
-    return 0;
-}
-
-u8 sub_800C12C(u16 r6, u16 r8)
-{
-    u8 i;
-
-    if (gUnknown_03004140.unk_04 != 0 && (gUnknown_03004140.unk_04 < 9 || gUnknown_03004140.unk_04 > 11))
-    {
-        gUnknown_03004140.unk_14 = 1;
-        sub_800D30C(0xF3, 0x01);
-        return 1;
-    }
-    if (!rfu_getMasterSlave())
-    {
-        gUnknown_03004140.unk_14 = 2;
-        sub_800D30C(0xF3, 0x01);
-        return 2;
-    }
-    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
-    {
-        if (gRfuLinkStatus->partner[i].id == r6)
-        {
-            break;
-        }
-    }
-    if (gRfuLinkStatus->findParentCount == 0 || i == gRfuLinkStatus->findParentCount)
-    {
-        gUnknown_03004140.unk_14 = 3;
-        sub_800D30C(0xF3, 0x01);
-        return 3;
-    }
-    if (gUnknown_03004140.unk_04 == 0 || gUnknown_03004140.unk_04 == 9)
-    {
-        gUnknown_03004140.unk_04 = 12;
-        gUnknown_03004140.unk_05 = 13;
-    }
-    else
-    {
-        gUnknown_03004140.unk_04 = 11;
-        gUnknown_03004140.unk_05 = 12;
-    }
-    gUnknown_03004140.unk_1e = r6;
-    gUnknown_03004140.unk_1a = r8;
-    if (gUnknown_03004140.unk_07 != 0)
-    {
-        gUnknown_03004140.unk_07 = 7;
-    }
-    return 0;
-}
-
-void sub_800C210(u8 a0)
-{
-    u8 i;
-
-    if (a0 & gUnknown_03004140.unk_30)
-    {
-        gUnknown_03004140.unk_30 &= ~a0;
-        for (i = 0; i < 4; i++)
-        {
-            if ((a0 >> i) & 1)
-            {
-                gUnknown_03004140.unk_34[i] = 0;
-            }
-        }
-        i = gRfuLinkStatus->linkLossSlotFlag & a0;
-        if (i)
-        {
-            sub_800D334(i);
-        }
-        gUnknown_03004140.unk_14 = i;
-        sub_800D30C(0x33, i);
-    }
-}
-
-void sub_800C27C(bool8 a0)
-{
-    u8 r2;
-
-    r2 = 0;
-    gUnknown_03004140.unk_07 = 0;
-    if (a0)
-    {
-        sub_800C000();
-        gUnknown_03004140.unk_04 = 23;
-    }
-    else
-    {
-        switch (gUnknown_03004140.unk_04)
-        {
-            case 5:
-                gUnknown_03004140.unk_04 = 8;
-                gUnknown_03004140.unk_05 = 0;
-                r2 = 0x13;
-                break;
-            case 6:
-                gUnknown_03004140.unk_04 = 7;
-                gUnknown_03004140.unk_05 = 8;
-                break;
-            case 7:
-                gUnknown_03004140.unk_04 = 7;
-                gUnknown_03004140.unk_05 = 8;
-                break;
-            case 8:
-                break;
-            case 9:
-                gUnknown_03004140.unk_05 = 0;
-                gUnknown_03004140.unk_04 = 0;
-                r2 = 0x21;
-                break;
-            case 10:
-                gUnknown_03004140.unk_04 = 11;
-                gUnknown_03004140.unk_05 = 0;
-                break;
-            case 11:
-                gUnknown_03004140.unk_04 = 11;
-                gUnknown_03004140.unk_05 = 0;
-                break;
-            case 12:
-                gUnknown_03004140.unk_05 = 0;
-                gUnknown_03004140.unk_04 = 0;
-                r2 = 0x23;
-                break;
-            case 13:
-                gUnknown_03004140.unk_04 = 14;
-                break;
-            case 14:
-                gUnknown_03004140.unk_04 = 14;
-                break;
-            case 15:
-                break;
-            case 16:
-                gUnknown_03004140.unk_04 = gUnknown_03004140.unk_11;
-                gUnknown_03004140.unk_05 = gUnknown_03004140.unk_12;
-                sub_800D334(gRfuLinkStatus->linkLossSlotFlag);
-                gUnknown_03004140.unk_14 = gRfuLinkStatus->linkLossSlotFlag;
-                sub_800D30C(0x33, 0x01);
-                return;
-            case 17:
-                gUnknown_03004140.unk_04 = 18;
-                break;
-            case 18:
-                gUnknown_03004140.unk_04 = 18;
-                break;
-            default:
-                gUnknown_03004140.unk_05 = 0;
-                gUnknown_03004140.unk_04 = 0;
-                r2 = 0x43;
-                break;
-        }
-        if (gUnknown_03004140.unk_04 == 0)
-        {
-            sub_800D30C(r2, 0);
-        }
-    }
-}
-
-bool8 sub_800C36C(u16 a0)
-{
-    bool8 retVal;
-    u8 i;
-    u8 sp0;
-    u8 sp1;
-    u8 sp2;
-    u8 flags;
-
-    retVal = FALSE;
-    rfu_REQBN_watchLink(a0, &sp0, &sp1, &sp2);
-    if (sp0)
-    {
-        gUnknown_03004140.unk_14 = sp0;
-        gUnknown_03004140.unk_16 = sp1;
-        if (gUnknown_03004140.unk_09)
-        {
-            gUnknown_03004140.unk_0a = 1;
-            if (gUnknown_03004140.unk_06 == 0 && sp1 == 0)
-            {
-                gUnknown_03004140.unk_0a = 4;
-            }
-            if (gUnknown_03004140.unk_0a == 1)
-            {
-                for (i = 0; i < 4; i++)
-                {
-                    if ((sp0 >> i) & 1)
-                    {
-                        gUnknown_03004140.unk_30 |= (1 << i);
-                        gUnknown_03004140.unk_34[i] = gUnknown_03004140.unk_32;
-                    }
-                }
-                sub_800D30C(0x31, 0x01);
-            }
-            else
-            {
-                gUnknown_03004140.unk_0a = 0;
-                sub_800D334(sp0);
-                retVal = TRUE;
-                sub_800D30C(0x33, 0x01);
-            }
-        }
-        else
-        {
-            sub_800D334(sp0);
-            retVal = TRUE;
-            sub_800D30C(0x30, 0x02);
-        }
-        sub_800D610();
-    }
-    if (gRfuLinkStatus->parentChild == 1)
-    {
-        if (sp2)
-        {
-            for (i = 0; i < 4; i++)
-            {
-                if ((gUnknown_03004140.unk_30 >> i) & 1 && (sp2 >> i) & 1)
-                {
-                    gUnknown_03004140.unk_34[i] = 0;
-                }
-            }
-            gUnknown_03004140.unk_30 &= ~sp2;
-            gUnknown_03004140.unk_14 = sp2;
-            sub_800D30C(0x32, 0x01);
-        }
-        if (gUnknown_03004140.unk_30)
-        {
-            flags = 0;
-            for (i = 0; i < 4; i++)
-            {
-                if ((gUnknown_03004140.unk_30 >> i) & 1 && gUnknown_03004140.unk_34[i] && --gUnknown_03004140.unk_34[i] == 0)
-                {
-                    gUnknown_03004140.unk_30 &= ~(1 << i);
-                    flags |= (1 << i);
-                }
-            }
-            if (flags)
-            {
-                sub_800D334(flags);
-                retVal = TRUE;
-                gUnknown_03004140.unk_14 = flags;
-                sub_800D30C(0x33, 0x01);
-            }
-        }
-        if (!gUnknown_03004140.unk_30)
-        {
-            gUnknown_03004140.unk_0a = 0;
-        }
-    }
-    return retVal;
-}
-
-void rfu_syncVBlank_(void)
-{
-    if (rfu_syncVBlank())
-    {
-        sub_800D30C(0xF1, 0x00);
-        sub_800D610();
-    }
-}
-
-void sub_800C54C(u32 a0)
-{
-    u8 r2;
-
-    if (gUnknown_03004140.unk_40 == NULL && gUnknown_03004140.unk_04 != 0)
-    {
-        gUnknown_03004140.unk_04 = 0;
-    }
-    else
-    {
-        if (gUnknown_03004140.unk_07 != 0)
-        {
-            sub_800C744(a0);
-        }
-        do
-        {
-            if (gUnknown_03004140.unk_04 != 0)
-            {
-                rfu_waitREQComplete();
-                gUnknown_03004140.unk_0e = 1;
-                switch (gUnknown_03004140.unk_04)
-                {
-                    case 23:
-                        r2 = sub_800BEC0() == 0x8001 ? 0x44 : 0xFF;
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                        sub_800D30C(r2, 0);
-                        break;
-                    case 1:
-                        if (sub_800BEC0() == 0x8001)
-                        {
-                            gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                            gUnknown_03004140.unk_05 = 3;
-                        }
-                        else
-                        {
-                            gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                            sub_800D30C(0xFF, 0);
-                        }
-                        break;
-                    case 2:
-                        rfu_REQ_reset();
-                        break;
-                    case 3:
-                        rfu_REQ_configSystem(gUnknown_03004140.unk_3c->unk_02, gUnknown_03004140.unk_3c->unk_00, gUnknown_03004140.unk_3c->unk_01);
-                        break;
-                    case 4:
-                        rfu_REQ_configGameData(gUnknown_03004140.unk_3c->unk_04, gUnknown_03004140.unk_3c->unk_06, (const u8 *)gUnknown_03004140.unk_3c->unk_08, gUnknown_03004140.unk_3c->unk_0c);
-                        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_03004140.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_03004140.unk_0e = 0;
-            }
-        } while (gUnknown_03004140.unk_04 == 18 || gUnknown_03004140.unk_04 == 19);
-        if (gRfuLinkStatus->parentChild != 1 || !sub_800C36C(0))
-        {
-            sub_800CF34();
-            sub_800D158();
-            sub_800D268();
-            sub_800D434();
-        }
-    }
-}
-
-static void sub_800C744(u32 a0)
-{
-    if (gUnknown_03004140.unk_07 == 5)
-    {
-        gUnknown_03004140.unk_06 = 1;
-        gUnknown_03004140.unk_04 = 5;
-        gUnknown_03004140.unk_1a = gUnknown_03004140.unk_1c;
-        if (gUnknown_03004140.unk_1a)
-        {
-            gUnknown_03004140.unk_07 = 6;
-        }
-        else
-        {
-            gUnknown_03004140.unk_07 = 1;
-        }
-    }
-    if (gUnknown_03004140.unk_07 == 1)
-    {
-        gUnknown_03004140.unk_06 = 1;
-        gUnknown_03004140.unk_04 = 5;
-        gUnknown_03004140.unk_1a = a0 % 140;
-        gUnknown_03004140.unk_1c = 140 - gUnknown_03004140.unk_1a;
-        if (gUnknown_03004140.unk_1a)
-        {
-            gUnknown_03004140.unk_07 = 2;
-        }
-        else
-        {
-            gUnknown_03004140.unk_07 = 3;
-        }
-    }
-    if (gUnknown_03004140.unk_07 == 3)
-    {
-        gUnknown_03004140.unk_06 = 0;
-        gUnknown_03004140.unk_1a = 40;
-        gUnknown_03004140.unk_07 = 4;
-        gUnknown_03004140.unk_04 = 9;
-    }
-}
-
-static void sub_800C7B4(u16 r8, u16 r6)
-{
-    u8 sp0;
-    register struct RfuIntrStruct *stwiRecvBuffer asm("r0");
-    u8 *tmp;
-    u8 i;
-
-    if (gUnknown_03004140.unk_0e != 0)
-    {
-        gUnknown_03004140.unk_0e = 0;
-        switch (r8)
-        {
-            case 16:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                    gUnknown_03004140.unk_05 = 4;
-                }
-                break;
-            case 23:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                    gUnknown_03004140.unk_05 = 0;
-                }
-                break;
-            case 22:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                    sub_800D30C(0x00, 0x00);
-                }
-                break;
-            case 25:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 6;
-                }
-                break;
-            case 26:
-                if (gUnknown_03004140.unk_1a && --gUnknown_03004140.unk_1a == 0)
-                {
-                    gUnknown_03004140.unk_04 = 7;
-                    gUnknown_03004140.unk_05 = 8;
-                }
-                break;
-            case 27:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                    gUnknown_03004140.unk_05 = 0;
-                    if (gUnknown_03004140.unk_07 == 0)
-                    {
-                        sub_800D30C(0x13, 0x00);
-                    }
-                }
-                break;
-            case 28:
-                if (r6 == 0)
-                {
-                    if (gUnknown_03004140.unk_0b == 1 && gUnknown_03004140.unk_1a > 1)
-                    {
-                        gUnknown_03004140.unk_1a--;
-                    }
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 10;
-                }
-                break;
-            case 29:
-                if (r6 == 0)
-                {
-                    sp0 = sub_800D294();
-                    gUnknown_03004140.unk_14 = sp0;
-                    if (sp0)
-                    {
-                        sub_800D30C(0x20, 0x01);
-                    }
-                    if (gUnknown_03004140.unk_0b && gUnknown_03004140.unk_1a != 1 && gRfuLinkStatus->findParentCount == 4)
-                    {
-                        rfu_REQ_endSearchParent();
-                        rfu_waitREQComplete();
-                        gUnknown_03004140.unk_04 = 9;
-                        gUnknown_03004140.unk_0b = 1;
-                    }
-                }
-                if (gUnknown_03004140.unk_1a && --gUnknown_03004140.unk_1a == 0)
-                {
-                    gUnknown_03004140.unk_04 = 11;
-                    gUnknown_03004140.unk_05 = 0;
-                }
-                break;
-            case 30:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                    if (gUnknown_03004140.unk_07 == 0)
-                    {
-                        if (gUnknown_03004140.unk_04 == 0)
-                        {
-                            sub_800D30C(0x21, 0x00);
-                        }
-                    }
-                    else if (gUnknown_03004140.unk_07 != 7)
-                    {
-                        gUnknown_03004140.unk_04 = 5;
-                        gUnknown_03004140.unk_07 = 5;
-                    }
-                }
-                break;
-            case 31:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 13;
-                }
-                break;
-            case 32:
-                if (r6 == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_03004140.unk_10) && !sp0)
-                {
-                    gUnknown_03004140.unk_04 = 14;
-                }
-                if (gUnknown_03004140.unk_1a && --gUnknown_03004140.unk_1a == 0)
-                {
-                    gUnknown_03004140.unk_04 = 14;
-                }
-                break;
-            case 33:
-                if (r6 == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_03004140.unk_10))
-                {
-                    if (!sp0)
-                    {
-                        gUnknown_03004140.unk_04 = 19;
-                        gUnknown_03004140.unk_05 = 15;
-                        gUnknown_03004140.unk_1e = 0x22;
-                        gUnknown_03004140.unk_14 = gUnknown_03004140.unk_10;
-                    }
-                    else
-                    {
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                        gUnknown_03004140.unk_1e = 0x23;
-                        gUnknown_03004140.unk_14 = sp0;
-                        if (gUnknown_03004140.unk_07)
-                        {
-                            gUnknown_03004140.unk_07 = 3;
-                            gUnknown_03004140.unk_04 = 9;
-                        }
-                    }
-                    sub_800D30C(gUnknown_03004140.unk_1e, 0x01);
-                    gUnknown_03004140.unk_1e = 0;
-                }
-                break;
-            case 50:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_14 = gRfuLinkStatus->linkLossSlotFlag;
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 17;
-                    for (gUnknown_03004140.unk_10 = 0; gUnknown_03004140.unk_10 < 4; gUnknown_03004140.unk_10 ++)
-                    {
-                        if ((gRfuLinkStatus->linkLossSlotFlag >> gUnknown_03004140.unk_10) & 1)
-                        {
-                            break;
-                        }
-                    }
-                }
-                break;
-            case 51:
-                if (r6 == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0) && sp0 < 2)
-                {
-                    gUnknown_03004140.unk_04 = 18;
-                }
-                if (gUnknown_03004140.unk_34[gUnknown_03004140.unk_10] && --gUnknown_03004140.unk_34[gUnknown_03004140.unk_10] == 0)
-                {
-                    gUnknown_03004140.unk_04 = 18;
-                }
-                break;
-            case 52:
-                if (r6 == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0))
-                {
-                    if (!sp0)
-                    {
-                        gUnknown_03004140.unk_04 = 19;
-                        gUnknown_03004140.unk_05 = 22;
-                        gUnknown_03004140.unk_1e = 0x32;
-                    }
-                    else
-                    {
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                        sub_800D334(gRfuLinkStatus->linkLossSlotFlag);
-                        gUnknown_03004140.unk_1e = 0x33;
-                    }
-                    gUnknown_03004140.unk_34[gUnknown_03004140.unk_10] = 0;
-                    gUnknown_03004140.unk_30 = 0;
-                    gUnknown_03004140.unk_0a = 0;
-                    sub_800D30C(gUnknown_03004140.unk_1e, 0x01);
-                    gUnknown_03004140.unk_1e = 0;
-                }
-                break;
-            case 39:
-                if (r6 == 0)
-                {
-                    if (gUnknown_03004140.unk_05 == 22)
-                    {
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_11;
-                        gUnknown_03004140.unk_05 = gUnknown_03004140.unk_12;
-                        gUnknown_03004140.unk_02 = 1;
-                        sub_800D30C(0x41, 0x00);
-                    }
-                    else if (gUnknown_03004140.unk_05 == 15)
-                    {
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05;
-                        gUnknown_03004140.unk_02 = 1;
-                        sub_800D30C(0x41, 0x00);
-                        gUnknown_03004140.unk_24 |= 1 << gUnknown_03004140.unk_10;
-                        gUnknown_03004140.unk_28[gUnknown_03004140.unk_10] = gUnknown_03004140.unk_26;
-                        rfu_clearSlot(4, gUnknown_03004140.unk_10);
-                        tmp = &sp0;
-                        *tmp = rfu_NI_CHILD_setSendGameName(gUnknown_03004140.unk_10, 0x0e);
-                        if (*tmp)
-                        {
-                            gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                            sub_800D610();
-                            sub_800D334(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-                            gUnknown_03004140.unk_14 = sp0;
-                            sub_800D30C(0x25, 0x01);
-                        }
-                    }
-                }
-                break;
-            case 61:
-                if (r6 == 0)
-                {
-                    gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                    sub_800D30C(0x42, 0x00);
-                }
-                break;
-        }
-        gUnknown_03004140.unk_0e = 1;
-    }
-    else if (r6 == 3 && gUnknown_03004140.unk_0f && (r8 == 0x24 || r8 == 0x26 || r8 == 0x27))
-    {
-        rfu_REQ_RFUStatus();
-        rfu_waitREQComplete();
-        rfu_getRFUStatus(&sp0);
-        if (sp0 == 0 && gRfuLinkStatus->parentChild == 0)
-        {
-            stwiRecvBuffer = rfu_getSTWIRecvBuffer();
-            stwiRecvBuffer->rxPacketAlloc.rfuPacket8.data[4] = gRfuLinkStatus->connSlotFlag;
-            stwiRecvBuffer->rxPacketAlloc.rfuPacket8.data[5] = 1;
-            sub_800C36C(0x29);
-            r6 = 0;
-        }
-    }
-    switch (r8)
-    {
-        case 48:
-            if (r6 == 0)
-            {
-                stwiRecvBuffer = rfu_getSTWIRecvBuffer();
-                gUnknown_03004140.unk_14 = stwiRecvBuffer->rxPacketAlloc.rfuPacket8.data[8];
-                sub_800D358(gUnknown_03004140.unk_14);
-                if (gUnknown_03004140.unk_30)
-                {
-                    gUnknown_03004140.unk_30 &= ~gUnknown_03004140.unk_14;
-                    for (i = 0; i < 4; i++)
-                    {
-                        if ((gUnknown_03004140.unk_14 >> i) & 1)
-                        {
-                            gUnknown_03004140.unk_34[i] = 0;
-                        }
-                    }
-                    if (gUnknown_03004140.unk_06 == 0)
-                    {
-                        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                    }
-                }
-                sp0 = gUnknown_03004140.unk_00 & gUnknown_03004140.unk_14;
-                for (i = 0; i < 4; i++)
-                {
-                    if ((sp0 >> i) & 1 && gUnknown_03004140.unk_01)
-                    {
-                        gUnknown_03004140.unk_01--;
-                    }
-                }
-                gUnknown_03004140.unk_00 &= ~gUnknown_03004140.unk_14;
-                if (gUnknown_03004140.unk_07)
-                {
-                    if (gRfuLinkStatus->parentChild == 0xFF)
-                    {
-                        if (gUnknown_03004140.unk_07 == 8)
-                        {
-                            gUnknown_03004140.unk_1a = gUnknown_03004140.unk_1c;
-                            gUnknown_03004140.unk_07 = 6;
-                            gUnknown_03004140.unk_04 = 6;
-                        }
-                        else if (gUnknown_03004140.unk_04 != 6 && gUnknown_03004140.unk_04 != 7)
-                        {
-                            gUnknown_03004140.unk_07 = 1;
-                            gUnknown_03004140.unk_04 = 5;
-                        }
-                    }
-                }
-                if (gRfuLinkStatus->parentChild == 0xFF)
-                {
-                    if (gUnknown_03004140.unk_04 == 0)
-                    {
-                        gUnknown_03004140.unk_06 = -1;
-                    }
-                }
-                if (gUnknown_03004140.unk_0e == 0)
-                {
-                    sub_800D30C(0x40, 0x01);
-                }
-            }
-            break;
-        case 38:
-            sub_800D20C();
-            if (gRfuLinkStatus->parentChild != 0xFF)
-            {
-                sub_800D30C(0x50, 0x00);
-            }
-            break;
-        case 16:
-        case 61:
-            if (r6 == 0)
-            {
-                gUnknown_03004140.unk_0d = 0;
-                gUnknown_03004140.unk_01 = 0;
-                gUnknown_03004140.unk_00 = 0;;
-                gUnknown_03004140.unk_06 = -1;
-                sub_800D610();
-                if (r8 == 61)
-                {
-                    sub_800BFA0();
-                }
-            }
-            break;
-    }
-    if (r6 != 0)
-    {
-        if (r8 == 28 && r6 != 0 && gUnknown_03004140.unk_07 == 4)
-        {
-            gRfuLinkStatus->parentChild = 1;
-            gRfuLinkStatus->connSlotFlag = 15;
-            sub_800D334(15);
-            rfu_waitREQComplete();
-            return;
-        }
-        else
-        {
-            gUnknown_03004140.unk_14 = r8;
-            gUnknown_03004140.unk_16 = r6;
-            if (gUnknown_03004140.unk_0e)
-            {
-                gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-            }
-            sub_800D30C(0xf0, 0x02);
-            sub_800D610();
-        }
-    }
-    if (r8 == 0xFF)
-    {
-        sub_800D30C(0xf2, 0x00);
-        sub_800D610();
-    }
-}
-
-static void sub_800CEB0(u16 r6)
-{
-    u8 r7;
-    u8 sp0;
-
-    r7 = gUnknown_03004140.unk_0e;
-    gUnknown_03004140.unk_0e = 0;
-    gUnknown_03004140.unk_0f = 1;
-    if (gRfuLinkStatus->parentChild == 0)
-    {
-        sub_800C36C(r6);
-        if (gUnknown_03004140.unk_02 != 1)
-        {
-            sub_800D610();
-            gUnknown_03004140.unk_0f = 0;
-            gUnknown_03004140.unk_0e = r7;
-            return;
-        }
-    }
-    else
-    {
-        if (!rfu_UNI_PARENT_getDRAC_ACK(&sp0))
-        {
-            gUnknown_03004140.unk_03 |= sp0;
-        }
-    }
-    if (gUnknown_03004140.unk_44 != NULL)
-    {
-        gUnknown_03004140.unk_44(r6);
-        rfu_waitREQComplete();
-        if (gUnknown_03004140.unk_02 == 2)
-        {
-            sub_800D610();
-        }
-    }
-    gUnknown_03004140.unk_0f = 0;
-    gUnknown_03004140.unk_0e = r7;
-}
-
-static void sub_800CF34(void)
-{
-    u8 flags;
-    u8 sp0;
-    u8 i;
-    u8 r5;
-    u8 r4;
-    const u16 *ptr;
-
-    if (gUnknown_03004140.unk_04 == 5 || gUnknown_03004140.unk_04 == 6 || gUnknown_03004140.unk_04 == 7 || gUnknown_03004140.unk_04 == 8)
-    {
-        flags = ((gRfuLinkStatus->connSlotFlag ^ gUnknown_03004140.unk_0c) & gRfuLinkStatus->connSlotFlag) & ~gRfuLinkStatus->getNameFlag;
-        gUnknown_03004140.unk_0c = gRfuLinkStatus->connSlotFlag;
-        if (flags)
-        {
-            gUnknown_03004140.unk_14 = flags;
-            sub_800D30C(0x10, 0x01);
-        }
-        sp0 = 0x00;
-        for (i = 0; i < 4; i++)
-        {
-            r4 = 1 << i;
-            r5 = 0x00;
-            if (flags & r4)
-            {
-                gUnknown_03004140.unk_28[i] = gUnknown_03004140.unk_26;
-                gUnknown_03004140.unk_24 |= r4;
-            }
-            else if (gUnknown_03004140.unk_24 & r4)
-            {
-                if (gRfuSlotStatusNI[i]->recv.state == 0x46)
-                {
-                    if (gRfuSlotStatusNI[i]->recv.dataType == 1)
-                    {
-                        r5 = 0x02;
-                        for (ptr = gUnknown_03004140.unk_20; *ptr != 0xFFFF; ptr++)
-                        {
-                            if (gRfuLinkStatus->partner[i].serialNo == *ptr)
-                            {
-                                gUnknown_03004140.unk_00 |= r4;
-                                gUnknown_03004140.unk_01++;
-                                sp0 |= r4;
-                                r5 |= 0x01;
-                                break;
-                            }
-                        }
-                        if (!(r5 & 0x01))
-                        {
-                            r5 |= 0x04;
-                        }
-                    }
-                }
-                else if (--gUnknown_03004140.unk_28[i] == 0)
-                {
-                    r5 = 0x06;
-                }
-                if (r5 & 0x02)
-                {
-                    gUnknown_03004140.unk_24 &= ~r4;
-                    gUnknown_03004140.unk_28[i] = 0;
-                    rfu_clearSlot(0x08, i);
-                }
-                if (r5 & 0x04)
-                {
-                    gUnknown_03004140.unk_0d |= r4;
-                }
-            }
-        }
-        if (sp0)
-        {
-            gUnknown_03004140.unk_14 = sp0;
-            sub_800D30C(0x11, 0x01);
-        }
-        if (gUnknown_03004140.unk_0d)
-        {
-            r5 = 0x01;
-            if (gRfuLinkStatus->sendSlotUNIFlag && ((gUnknown_03004140.unk_03 & gUnknown_03004140.unk_00) != gUnknown_03004140.unk_00))
-            {
-                r5 = 0x00;
-            }
-            if (r5)
-            {
-                sub_800D334(gUnknown_03004140.unk_0d);
-                gUnknown_03004140.unk_14 = gUnknown_03004140.unk_0d;
-                gUnknown_03004140.unk_0d = 0;
-                sub_800D30C(0x12, 0x01);
-            }
-        }
-        if (gUnknown_03004140.unk_24 == 0 && gUnknown_03004140.unk_04 == 8)
-        {
-            if (gUnknown_03004140.unk_07 == 0)
-            {
-                gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-                sub_800D30C(0x14, 0x00);
-            }
-            else
-            {
-                if (gUnknown_03004140.unk_07 == 2)
-                {
-                    gUnknown_03004140.unk_07 = 3;
-                    gUnknown_03004140.unk_04 = 9;
-                }
-                else
-                {
-                    gUnknown_03004140.unk_07 = 1;
-                    gUnknown_03004140.unk_04 = 5;
-                }
-                if (gUnknown_03004140.unk_00)
-                {
-                    gUnknown_03004140.unk_1a = 0;
-                    gUnknown_03004140.unk_07 = 8;
-                    gUnknown_03004140.unk_04 = 5;
-                }
-            }
-        }
-    }
-}
-
-static void sub_800D158(void)
-{
-    u16 imeBak = REG_IME;
-    REG_IME = 0;
-    if (gUnknown_03004140.unk_04 == 15)
-    {
-        if (--gUnknown_03004140.unk_28[gUnknown_03004140.unk_10] == 0 || gRfuSlotStatusNI[gUnknown_03004140.unk_10]->send.state == 0x27)
-        {
-            sub_800D630();
-            gUnknown_03004140.unk_04 = 24;
-            rfu_clearSlot(4, gUnknown_03004140.unk_10);
-            gUnknown_03004140.unk_24 &= ~(1 << gUnknown_03004140.unk_10);
-            gUnknown_03004140.unk_28[gUnknown_03004140.unk_10] = 0;
-        }
-    }
-    REG_IME = imeBak;
-    if (gUnknown_03004140.unk_04 == 24)
-    {
-        if (gUnknown_03004140.unk_02 == 1)
-        {
-            sub_800D630();
-        }
-        if (gUnknown_03004140.unk_02 == 0)
-        {
-            gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-            sub_800D334(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-            gUnknown_03004140.unk_14 = 0;
-            sub_800D30C(0x25, 0x01);
-        }
-    }
-}
-
-static void sub_800D20C(void)
-{
-    if (gUnknown_03004140.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_03004140.unk_10]->send.state == 0x26)
-    {
-        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-        rfu_clearSlot(4, gUnknown_03004140.unk_10);
-        gUnknown_03004140.unk_24 &= ~(1 << gUnknown_03004140.unk_10);
-        gUnknown_03004140.unk_28[gUnknown_03004140.unk_10] = 0;
-        sub_800D30C(0x24, 0x00);
-    }
-}
-
-static void sub_800D268(void)
-{
-    if (gUnknown_03004140.unk_06 == 0 && gUnknown_03004140.unk_0a == 1)
-    {
-        gUnknown_03004140.unk_11 = gUnknown_03004140.unk_04;
-        gUnknown_03004140.unk_12 = gUnknown_03004140.unk_05;
-        gUnknown_03004140.unk_04 = 16;
-        gUnknown_03004140.unk_05 = 17;
-        gUnknown_03004140.unk_0a = 2;
-    }
-}
-
-static u8 sub_800D294(void)
-{
-    u8 i;
-    const u16 *ptr;
-    u8 flags = 0x00;
-
-    for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
-    {
-        for (ptr = gUnknown_03004140.unk_20; *ptr != 0xFFFF; ptr++)
-        {
-            if (gRfuLinkStatus->partner[i].serialNo == *ptr)
-            {
-                flags |= (1 << i);
-            }
-        }
-    }
-    return flags;
-}
-
-static void sub_800D30C(u8 a0, u8 a1)
-{
-    if (gUnknown_03004140.unk_40 != NULL)
-    {
-        gUnknown_03004140.unk_40(a0, a1);
-    }
-    gUnknown_03004140.unk_14 = gUnknown_03004140.unk_16 = 0;
-}
-
-static void sub_800D334(u8 a0)
-{
-    u8 unk_0e_bak = gUnknown_03004140.unk_0e;
-    gUnknown_03004140.unk_0e = 1;
-    rfu_REQ_disconnect(a0);
-    rfu_waitREQComplete();
-    gUnknown_03004140.unk_0e = unk_0e_bak;
-}
-
-static void sub_800D358(u8 a0)
-{
-    u8 i;
-
-    if (gRfuLinkStatus->sendSlotNIFlag)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            if (gRfuSlotStatusNI[i]->send.state & 0x8000 && gRfuSlotStatusNI[i]->send.bmSlot & a0)
-            {
-                rfu_changeSendTarget(0x20, i, gRfuSlotStatusNI[i]->send.bmSlot & ~a0);
-            }
-        }
-    }
-    if (gRfuLinkStatus->recvSlotNIFlag)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && gRfuSlotStatusNI[i]->recv.bmSlot & a0)
-            {
-                rfu_NI_stopReceivingData(i);
-            }
-        }
-    }
-    if (gRfuLinkStatus->sendSlotUNIFlag)
-    {
-        gRfuLinkStatus->sendSlotUNIFlag &= ~a0;
-        for (i = 0; i < 4; i++)
-        {
-            if (gRfuSlotStatusUNI[i]->send.state == 0x8024 && a0 & gRfuSlotStatusUNI[i]->send.bmSlot)
-            {
-                gRfuSlotStatusUNI[i]->send.bmSlot &= ~a0;
-            }
-        }
-    }
-}
-
-static void sub_800D434(void)
-{
-    u8 i;
-    u8 j;
-    u8 flags;
-
-    if (gUnknown_03004140.unk_18)
-    {
-        if (gRfuLinkStatus->sendSlotNIFlag)
-        {
-            for (i = 0; i < 4; i ++)
-            {
-                if (gRfuSlotStatusNI[i]->send.state & 0x8000)
-                {
-                    flags = 0;
-                    for (j = 0; j < 4; j++)
-                    {
-                        if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > gUnknown_03004140.unk_18)
-                        {
-                            flags |= (1 << j);
-                        }
-                        if (flags)
-                        {
-                            rfu_changeSendTarget(0x20, i, flags ^ gRfuSlotStatusNI[i]->send.bmSlot);
-                        }
-                    }
-                }
-            }
-        }
-        if (gRfuLinkStatus->recvSlotNIFlag)
-        {
-            for (i = 0; i < 4; i++)
-            {
-                if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && gRfuSlotStatusNI[i]->recv.failCounter > gUnknown_03004140.unk_18)
-                {
-                    rfu_NI_stopReceivingData(i);
-                }
-            }
-        }
-    }
-}
-
-void sub_800D52C(void (*func)(u16))
-{
-    gUnknown_03004140.unk_44 = func;
-    rfu_setMSCCallback(sub_800CEB0);
-}
-
-void sub_800D544(void (*func)(u8, u8))
-{
-    gUnknown_03004140.unk_40 = func;
-}
-
-u8 sub_800D550(u8 a0, u16 a1)
-{
-    u16 imeBak;
-    if (gUnknown_03004140.unk_09 && a0 == 0 && gUnknown_03004140.unk_30)
-    {
-        return 5;
-    }
-    imeBak = REG_IME;
-    REG_IME = 0;
-    gUnknown_03004140.unk_09 = a0;
-    gUnknown_03004140.unk_32 = a1;
-    REG_IME = imeBak;
-    return 0;
-}
-
-u8 sub_800D594(u16 a0)
-{
-    if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag)
-    {
-        gUnknown_03004140.unk_14 = 6;
-        sub_800D30C(0xf3, 0x01);
-        return 6;
-    }
-    gUnknown_03004140.unk_18 = a0;
-    return 0;
-}
-
-u8 sub_800D5D0(u8 a0)
-{
-    if (gUnknown_03004140.unk_04 == 9 || gUnknown_03004140.unk_04 == 10 || gUnknown_03004140.unk_04 == 11)
-    {
-        gUnknown_03004140.unk_14 = 7;
-        sub_800D30C(0xf3, 0x01);
-        return 7;
-    }
-    if (a0)
-    {
-        gUnknown_03004140.unk_0b = 1;
-    }
-    else
-    {
-        gUnknown_03004140.unk_0b = 0;
-    }
-    return 0;
-}
-
-static void sub_800D610(void)
-{
-    if (gUnknown_03004140.unk_02)
-    {
-        gUnknown_03004140.unk_02 = 0;
-        sub_800D30C(0x45, 0x00);
-    }
-}
-
-void sub_800D630(void)
-{
-    if (gUnknown_03004140.unk_02 == 0)
-    {
-        sub_800D30C(0x45, 0x00);
-    }
-    else if (gUnknown_03004140.unk_02 == 1)
-    {
-        gUnknown_03004140.unk_02 = 2;
-    }
-}
-
-void sub_800D658(void)
-{
-    if (gUnknown_03004140.unk_07)
-    {
-        switch (gUnknown_03004140.unk_04)
-        {
-            case 5:
-                gUnknown_03004140.unk_07 = 3;
-                gUnknown_03004140.unk_04 = 9;
-                break;
-            case 6:
-                gUnknown_03004140.unk_07 = 2;
-                gUnknown_03004140.unk_1a = 1;
-                break;
-            case 7:
-            case 8:
-                gUnknown_03004140.unk_07 = 2;
-                break;
-            case 9:
-            case 10:
-                gUnknown_03004140.unk_1a = 40;
-                break;
-            case 11:
-                gUnknown_03004140.unk_1a = 40;
-                gUnknown_03004140.unk_04 = 10;
-                break;
-        }
-    }
-}
-
-// TODO: Is there a file boundary here?
-
-void sub_800D6C8(struct UnkRfuStruct_2_Sub_124 *ptr)
-{
-    s32 i;
-    s32 j;
-
-    for (i = 0; i < 32; i++)
-    {
-        for (j = 0; j < 70; j++)
-        {
-            ptr->unk_00[i][j] = 0;
-        }
-    }
-    ptr->unk_8c1 = 0;
-    ptr->unk_8c0 = 0;
-    ptr->unk_8c2 = 0;
-    ptr->unk_8c3 = 0;
-}
-
-void sub_800D724(struct UnkRfuStruct_2_Sub_9e8 *ptr)
-{
-    s32 i;
-    s32 j;
-
-    for (i = 0; i < 40; i++)
-    {
-        for (j = 0; j < 14; j++)
-        {
-            ptr->unk_00[i][j] = 0;
-        }
-    }
-    ptr->unk_231 = 0;
-    ptr->unk_230 = 0;
-    ptr->unk_232 = 0;
-    ptr->unk_233 = 0;
-}
-
-void sub_800D780(struct UnkRfuStruct_Sub_Unused *ptr)
-{
-    s32 i;
-    s32 j;
-
-    for (i = 0; i < 2; i++)
-    {
-        for (j = 0; j < 256; j++)
-        {
-            ptr->unk_00[i][j] = 0;
-        }
-    }
-    ptr->unk_201 = 0;
-    ptr->unk_200 = 0;
-    ptr->unk_202 = 0;
-    ptr->unk_203 = 0;
-}
-
-void sub_800D7D8(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
-{
-    s32 i;
-    u16 imeBak;
-    u8 count;
-
-    if (q1->unk_8c2 < 32)
-    {
-        imeBak = REG_IME;
-        REG_IME = 0;
-        count = 0;
-        for (i = 0; i < 70; i += 14)
-        {
-            if (q2[i] == 0 && q2[i + 1] == 0)
-            {
-                count++;
-            }
-        }
-        if (count != 5)
-        {
-            for (i = 0; i < 70; i++)
-            {
-                q1->unk_00[q1->unk_8c0][i] = q2[i];
-            }
-            q1->unk_8c0++;
-            q1->unk_8c0 %= 32;
-            q1->unk_8c2++;
-            for (i = 0; i < 70; i++)
-            {
-                q2[i] = 0;
-            }
-        }
-        REG_IME = imeBak;
-    }
-    else
-    {
-        q1->unk_8c3 = 1;
-    }
-}
-
-void sub_800D888(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
-{
-    s32 i;
-    u16 imeBak;
-
-    if (q1->unk_232 < 40)
-    {
-        imeBak = REG_IME;
-        REG_IME = 0;
-        for (i = 0; i < 14; i++)
-        {
-            if (q2[i] != 0)
-            {
-                break;
-            }
-        }
-        if (i != 14)
-        {
-            for (i = 0; i < 14; i++)
-            {
-                q1->unk_00[q1->unk_230][i] = q2[i];
-            }
-            q1->unk_230++;
-            q1->unk_230 %= 40;
-            q1->unk_232++;
-            for (i = 0; i < 14; i++)
-            {
-                q2[i] = 0;
-            }
-        }
-        REG_IME = imeBak;
-    }
-    else
-    {
-        q1->unk_233 = 1;
-    }
-}
-
-bool8 sub_800D934(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
-{
-    u16 imeBak;
-    s32 i;
-
-    imeBak = REG_IME;
-    REG_IME = 0;
-    if (q1->unk_8c0 == q1->unk_8c1 || q1->unk_8c3 != 0)
-    {
-        for (i = 0; i < 70; i++)
-        {
-            q2[i] = 0;
-        }
-        REG_IME = imeBak;
-        return FALSE;
-    }
-    for (i = 0; i < 70; i++)
-    {
-        q2[i] = q1->unk_00[q1->unk_8c1][i];
-    }
-    q1->unk_8c1++;
-    q1->unk_8c1 %= 32;
-    q1->unk_8c2--;
-    REG_IME = imeBak;
-    return TRUE;
-}
-
-bool8 sub_800D9DC(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
-{
-    s32 i;
-    u16 imeBak;
-
-    if (q1->unk_230 == q1->unk_231 || q1->unk_233 != 0)
-    {
-        return FALSE;
-    }
-    imeBak = REG_IME;
-    REG_IME = 0;
-    for (i = 0; i < 14; i++)
-    {
-        q2[i] = q1->unk_00[q1->unk_231][i];
-    }
-    q1->unk_231++;
-    q1->unk_231 %= 40;
-    q1->unk_232--;
-    REG_IME = imeBak;
-    return TRUE;
-}
-
-void sub_800DA68(struct UnkRfuStruct_2_Sub_c1c *q1, const u8 *q2)
-{
-    s32 i;
-
-    if (q2[1] == 0)
-    {
-        sub_800DAC8(q1, NULL);
-    }
-    else
-    {
-        for (i = 0; i < 14; i++)
-        {
-            q1->unk_00[q1->unk_1c][i] = q2[i];
-        }
-        q1->unk_1c++;
-        q1->unk_1c %= 2;
-        if (q1->unk_1e < 2)
-        {
-            q1->unk_1e++;
-        }
-        else
-        {
-            q1->unk_1d = q1->unk_1c;
-        }
-    }
-}
-
-static bool8 sub_800DAC8(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2)
-{
-    s32 i;
-
-    if (q1->unk_1e == 0)
-    {
-        return FALSE;
-    }
-    if (q2 != NULL)
-    {
-        for (i = 0; i < 14; i++)
-        {
-            q2[i] = q1->unk_00[q1->unk_1d][i];
-        }
-    }
-    q1->unk_1d++;
-    q1->unk_1d %= 2;
-    q1->unk_1e--;
-    return TRUE;
-}
-
-void sub_800DB18(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
-{
-    s32 i;
-
-    if (q1->unk_202 < 2)
-    {
-        for (i = 0; i < 256; i++)
-        {
-            q1->unk_00[q1->unk_200][i] = q2[i];
-        }
-        q1->unk_200++;
-        q1->unk_200 %= 2;
-        q1->unk_202++;
-    }
-    else
-    {
-        q1->unk_203 = 1;
-    }
-}
-
-bool8 sub_800DB84(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
-{
-    s32 i;
-
-    if (q1->unk_200 == q1->unk_201 || q1->unk_203)
-    {
-        return FALSE;
-    }
-    for (i = 0; i < 256; i++)
-    {
-        q2[i] = q1->unk_00[q1->unk_201][i];
-    }
-    q1->unk_201++;
-    q1->unk_201 %= 2;
-    q1->unk_202--;
-    return TRUE;
-}
-
-void sub_800DBF8(u8 *q1, u8 mode)
-{
-    s32 i;
-    u8 rval;
-    u16 r5 = 0;
-    switch (mode)
-    {
-        case 0:
-            for (i = 0; i < 200; i++)
-            {
-                q1[i] = i + 1;
-                r5 += i + 1;
-            }
-            *((u16 *)(q1 + i)) = r5;
-            break;
-        case 1:
-            for (i = 0; i < 100; i++)
-            {
-                q1[i] = i + 1;
-                r5 += i + 1;
-            }
-            *((u16 *)(q1 + 200)) = r5;
-            break;
-        case 2:
-            for (i = 0; i < 200; i++)
-            {
-                rval = Random();
-                q1[i] = rval;
-                r5 += rval;
-            }
-            *((u16 *)(q1 + i)) = r5;
-            break;
-        case 3:
-            for (i = 0; i < 200; i++)
-            {
-                q1[i] = i + 1 + gUnknown_03000D74;
-                r5 += (i + 1 + gUnknown_03000D74) & 0xFF;
-            }
-            *((u16 *)(q1 + i)) = r5;
-            gUnknown_03000D74++;
-            break;
-    }
-}
-
-// File boundary here maybe?
-
-void PkmnStrToASCII(u8 *q1, const u8 *q2)
-{
-    s32 i;
-
-    for (i = 0; q2[i] != EOS; i++)
-    {
-        q1[i] = sWireless_RSEtoASCIITable[q2[i]];
-    }
-    q1[i] = 0;
-}
-
-void ASCIIToPkmnStr(u8 *q1, const u8 *q2)
-{
-    s32 i;
-
-    for (i = 0; q2[i] != 0; i++)
-    {
-        q1[i] = sWireless_ASCIItoRSETable[q2[i]];
-    }
-    q1[i] = EOS;
-}
-
-#ifdef NONMATCHING
-u8 sub_800DD1C(u8 maxFlags)
-{
-    u8 flagCount = 0;
-    u32 flags = gRfuLinkStatus->connSlotFlag;
-    u8 i;
-
-    if (gRfuLinkStatus->parentChild == 1)
-    {
-        for (i = 0; i < 4; flags >>= 1, i++)
-        {
-            if (flags & 1)
-            {
-                if (maxFlags == flagCount + 1)
-                    return gRfuLinkStatus->strength[i];
-                flagCount++;
-            }
-        }
-    }
-    else
-    {
-        for (i = 0; i < 4; flags >>= 1, i++)
-        {
-            if (flags & 1)
-                return gRfuLinkStatus->strength[i];
-        }
-    }
-    return 0;
-}
-#else
-NAKED u8 sub_800DD1C(u8 maxFlags)
-{
-    asm_unified("\tpush {r4-r7,lr}\n"
-                    "\tlsls r0, 24\n"
-                    "\tlsrs r5, r0, 24\n"
-                    "\tmovs r6, 0\n"
-                    "\tldr r0, =gRfuLinkStatus\n"
-                    "\tldr r4, [r0]\n"
-                    "\tldrb r2, [r4, 0x2]\n"
-                    "\tldrb r1, [r4]\n"
-                    "\tadds r7, r0, 0\n"
-                    "\tcmp r1, 0x1\n"
-                    "\tbne _0800DD72\n"
-                    "\tmovs r3, 0\n"
-                    "\tands r1, r2\n"
-                    "\tcmp r1, 0\n"
-                    "\tbeq _0800DD4E\n"
-                    "\tcmp r5, 0x1\n"
-                    "\tbne _0800DD48\n"
-                    "\tldrb r0, [r4, 0xA]\n"
-                    "\tb _0800DD8C\n"
-                    "\t.pool\n"
-                    "_0800DD48:\n"
-                    "\tadds r0, r6, 0x1\n"
-                    "\tlsls r0, 24\n"
-                    "\tlsrs r6, r0, 24\n"
-                    "_0800DD4E:\n"
-                    "\tlsrs r2, 1\n"
-                    "\tadds r0, r3, 0x1\n"
-                    "\tlsls r0, 24\n"
-                    "\tlsrs r3, r0, 24\n"
-                    "\tcmp r3, 0x3\n"
-                    "\tbhi _0800DD8A\n"
-                    "\tmovs r0, 0x1\n"
-                    "\tands r0, r2\n"
-                    "\tcmp r0, 0\n"
-                    "\tbeq _0800DD4E\n"
-                    "\tadds r0, r6, 0x1\n"
-                    "\tcmp r5, r0\n"
-                    "\tbne _0800DD48\n"
-                    "_0800DD68:\n"
-                    "\tldr r0, [r7]\n"
-                    "\tadds r0, 0xA\n"
-                    "\tadds r0, r3\n"
-                    "\tldrb r0, [r0]\n"
-                    "\tb _0800DD8C\n"
-                    "_0800DD72:\n"
-                    "\tmovs r3, 0\n"
-                    "\tmovs r1, 0x1\n"
-                    "_0800DD76:\n"
-                    "\tadds r0, r2, 0\n"
-                    "\tands r0, r1\n"
-                    "\tcmp r0, 0\n"
-                    "\tbne _0800DD68\n"
-                    "\tlsrs r2, 1\n"
-                    "\tadds r0, r3, 0x1\n"
-                    "\tlsls r0, 24\n"
-                    "\tlsrs r3, r0, 24\n"
-                    "\tcmp r3, 0x3\n"
-                    "\tbls _0800DD76\n"
-                    "_0800DD8A:\n"
-                    "\tmovs r0, 0\n"
-                    "_0800DD8C:\n"
-                    "\tpop {r4-r7}\n"
-                    "\tpop {r1}\n"
-                    "\tbx r1");
-}
-#endif
-
-void sub_800DD94(struct UnkLinkRfuStruct_02022B14 *data, u8 r9, bool32 r2, s32 r3)
-{
-    s32 i;
-
-    for (i = 0; i < 2; i++)
-    {
-        data->unk_00.playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i];
-    }
-    for (i = 0; i < 4; i++)
-    {
-        data->unk_04[i] = r3;
-        r3 >>= 8;
-    }
-    data->playerGender = gSaveBlock2Ptr->playerGender;
-    data->unk_0a_0 = r9;
-    data->unk_0a_7 = r2;
-    data->unk_00.unk_00_0 = 2;
-    data->unk_00.unk_01_2 = 3;
-    data->unk_00.unk_00_4 = 0;
-    data->unk_00.unk_00_5 = 0;
-    data->unk_00.unk_00_6 = 0;
-    data->unk_00.isChampion = FlagGet(FLAG_IS_CHAMPION);
-    data->unk_00.hasNationalDex = IsNationalPokedexEnabled();
-    data->unk_00.gameClear = FlagGet(FLAG_SYS_GAME_CLEAR);
-}
-
-bool8 sub_800DE7C(struct UnkLinkRfuStruct_02022B14 *buff1, u8 *buff2, u8 idx)
-{
-    bool8 retVal;
-
-    if (gUnknown_03004140.unk_06 == 1)
-    {
-        retVal = TRUE;
-        if (sub_8010454(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1))
-        {
-            memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
-            memcpy(buff2, gRfuLinkStatus->partner[idx].uname, PLAYER_NAME_LENGTH + 1);
-        }
-        else
-        {
-            memset(buff1, 0, 0xD);
-            memset(buff2, 0, PLAYER_NAME_LENGTH + 1);
-        }
-    }
-    else
-    {
-        retVal = FALSE;
-        if (sub_8010454(gRfuLinkStatus->partner[idx].serialNo))
-        {
-            memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
-            memcpy(buff2, gRfuLinkStatus->partner[idx].uname, PLAYER_NAME_LENGTH + 1);
-        }
-        else
-        {
-            memset(buff1, 0, 0xD);
-            memset(buff2, 0, PLAYER_NAME_LENGTH + 1);
-        }
-    }
-    return retVal;
-}
-
-bool8 sub_800DF34(struct UnkLinkRfuStruct_02022B14 *buff1, u8 *buff2, u8 idx)
-{
-    bool8 retVal = FALSE;
-    if (gRfuLinkStatus->partner[idx].serialNo == 0x7F7D)
-    {
-        memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
-        memcpy(buff2, gRfuLinkStatus->partner[idx].uname, 8);
-        retVal = TRUE;
-    }
-    else
-    {
-        memset(buff1, 0, 0xD);
-        memset(buff2, 0, 8);
-    }
-    return retVal;
-}
-
-void sub_800DF90(struct UnkLinkRfuStruct_02022B14 *buff1, u8 *buff2)
-{
-    memcpy(buff1, &gUnknown_02022B14, 0xD);
-    memcpy(buff2, gUnknown_02022B22, 8);
-}
-
-void CreateWirelessStatusIndicatorSprite(u8 x, u8 y)
-{
-    u8 sprId;
-
-    if (x == 0 && y == 0)
-    {
-        x = 0xE7;
-        y = 0x08;
-    }
-    if (gRfuLinkStatus->parentChild == 1)
-    {
-        sprId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0);
-        gSprites[sprId].data[7] = 0x1234;
-        gSprites[sprId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag);
-        gSprites[sprId].invisible = TRUE;
-        gWirelessStatusIndicatorSpriteId = sprId;
-    }
-    else
-    {
-        gWirelessStatusIndicatorSpriteId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0);
-        gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0x1234;
-        gSprites[gWirelessStatusIndicatorSpriteId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag);
-        gSprites[gWirelessStatusIndicatorSpriteId].invisible = TRUE;
-    }
-}
-
-void DestroyWirelessStatusIndicatorSprite(void)
-{
-    if (gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234)
-    {
-        gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0;
-        DestroySprite(&gSprites[gWirelessStatusIndicatorSpriteId]);
-        gMain.oamBuffer[125] = gDummyOamData;
-        CpuCopy16(&gDummyOamData, (struct OamData *)OAM + 125, sizeof(struct OamData));
-    }
-}
-
-void LoadWirelessStatusIndicatorSpriteGfx(void)
-{
-    if (GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag) == 0xFFFF)
-    {
-        LoadCompressedSpriteSheet(&sWirelessStatusIndicatorSpriteSheet);
-    }
-    LoadSpritePalette(&sWirelessStatusIndicatorSpritePalette);
-    gWirelessStatusIndicatorSpriteId = 0xFF;
-}
-
-u8 sub_800E124(void)
-{
-    u8 i;
-    u8 flags = gRfuLinkStatus->connSlotFlag;
-    for (i = 0; i < 4; i++)
-    {
-        if (flags & 1)
-        {
-            return gRfuLinkStatus->strength[i];
-        }
-        flags >>= 1;
-    }
-    return 0;
-}
-
-void sub_800E15C(struct Sprite *sprite, s32 signalStrengthAnimNum)
-{
-    if (sprite->data[2] != signalStrengthAnimNum)
-    {
-        sprite->data[2] = signalStrengthAnimNum;
-        sprite->data[3] = 0;
-        sprite->data[4] = 0;
-    }
-}
-
-void sub_800E174(void)
-{
-    if (gWirelessStatusIndicatorSpriteId != 0xFF && gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234)
-    {
-        struct Sprite *sprite = &gSprites[gWirelessStatusIndicatorSpriteId];
-        u8 signalStrength = 255;
-        u8 i = 0;
-        if (gRfuLinkStatus->parentChild == 1)
-        {
-            for (i = 0; i < GetLinkPlayerCount() - 1; i++)
-            {
-                if (signalStrength >= sub_800DD1C(i + 1))
-                {
-                    signalStrength = sub_800DD1C(i + 1);
-                }
-            }
-        }
-        else
-        {
-            signalStrength = sub_800E124();
-        }
-        if (sub_8012224() == TRUE)
-        {
-            sprite->data[0] = 4;
-        }
-        else if (signalStrength < 25)
-        {
-            sprite->data[0] = 3;
-        }
-        else if (signalStrength >= 25 && signalStrength < 127)
-        {
-            sprite->data[0] = 2;
-        }
-        else if (signalStrength >= 127 && signalStrength < 229)
-        {
-            sprite->data[0] = 1;
-        }
-        else if (signalStrength >= 229)
-        {
-            sprite->data[0] = 0;
-        }
-        if (sprite->data[0] != sprite->data[1])
-        {
-            sub_800E15C(sprite, sprite->data[0]);
-            sprite->data[1] = sprite->data[0];
-        }
-        if (sprite->anims[sprite->data[2]][sprite->data[4]].frame.duration < sprite->data[3])
-        {
-            sprite->data[4]++;
-            sprite->data[3] = 0;
-            if (sprite->anims[sprite->data[2]][sprite->data[4]].type == -2)
-            {
-                sprite->data[4] = 0;
-            }
-        }
-        else
-        {
-            sprite->data[3]++;
-        }
-        gMain.oamBuffer[125] = sWirelessStatusIndicatorOamData;
-        gMain.oamBuffer[125].x = sprite->pos1.x + sprite->centerToCornerVecX;
-        gMain.oamBuffer[125].y = sprite->pos1.y + sprite->centerToCornerVecY;
-        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_8011A74() == 1)
-        {
-            DestroyWirelessStatusIndicatorSprite();
-        }
-    }
-}
-
-void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 *name)
-{
-    dest->trainerId = trainerId;
-    StringCopy(dest->trainerName, name);
-}
-
-bool32 NameIsNotEmpty(const u8 *name)
-{
-    s32 i;
-
-    for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++)
-    {
-        if (name[i] != 0)
-        {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-// Save the currently connected players into the trainer records, shifting all previous records down.
-void RecordMixTrainerNames(void)
-{
-    if (gWirelessCommType != 0)
-    {
-        s32 i;
-        s32 j;
-        s32 nextSpace;
-        s32 connectedTrainerRecordIndices[5];
-        struct TrainerNameRecord *newRecords = calloc(20, sizeof(struct TrainerNameRecord));
-
-        // Check if we already have a record saved for connected trainers.
-        for (i = 0; i < GetLinkPlayerCount(); i++)
-        {
-            connectedTrainerRecordIndices[i] = -1;
-            for (j = 0; j < 20; j++)
-            {
-                if ((u16)gLinkPlayers[i].trainerId ==  gSaveBlock1Ptr->trainerNameRecords[j].trainerId && StringCompare(gLinkPlayers[i].name, gSaveBlock1Ptr->trainerNameRecords[j].trainerName) == 0)
-                {
-                    connectedTrainerRecordIndices[i] = j;
-                }
-            }
-        }
-
-        // Save the connected trainers first, at the top of the list.
-        nextSpace = 0;
-        for (i = 0; i < GetLinkPlayerCount(); i++)
-        {
-            if (i != GetMultiplayerId() && gLinkPlayers[i].language != LANGUAGE_JAPANESE)
-            {
-                CopyTrainerRecord(&newRecords[nextSpace], (u16)gLinkPlayers[i].trainerId, gLinkPlayers[i].name);
-
-                // If we already had a record for this trainer, wipe it so that the next step doesn't duplicate it.
-                if (connectedTrainerRecordIndices[i] >= 0)
-                {
-                    memset(gSaveBlock1Ptr->trainerNameRecords[connectedTrainerRecordIndices[i]].trainerName, 0, 8);
-                }
-                nextSpace++;
-            }
-        }
-
-        // Copy all non-empty records to the new list, in the order they appear on the old list. If the list is full,
-        // the last (oldest) records will be dropped.
-        for (i = 0; i < 20; i++)
-        {
-            if (NameIsNotEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName))
-            {
-                CopyTrainerRecord(&newRecords[nextSpace], gSaveBlock1Ptr->trainerNameRecords[i].trainerId, gSaveBlock1Ptr->trainerNameRecords[i].trainerName);
-                if (++nextSpace >= 20)
-                {
-                    break;
-                }
-            }
-        }
-
-        // Finalize the new list, and clean up.
-        memcpy(gSaveBlock1Ptr->trainerNameRecords, newRecords, 20 * sizeof(struct TrainerNameRecord));
-        free(newRecords);
-    }
-}
-
-bool32 sub_800E540(u16 id, u8 *name)
-{
-    s32 i;
-
-    for (i = 0; i < 20; i++)
-    {
-        if (StringCompare(gSaveBlock1Ptr->trainerNameRecords[i].trainerName, name) == 0 && gSaveBlock1Ptr->trainerNameRecords[i].trainerId == id)
-        {
-            return TRUE;
-        }
-        if (!NameIsNotEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName))
-        {
-            return FALSE;
-        }
-    }
-    return FALSE;
-}
-
-void WipeTrainerNameRecords(void)
-{
-    s32 i;
-
-    for (i = 0; i < 20; i++)
-    {
-        gSaveBlock1Ptr->trainerNameRecords[i].trainerId = 0;
-        CpuFill16(0, gSaveBlock1Ptr->trainerNameRecords[i].trainerName, 8);
-    }
-}
-
-void nullsub_5(const void *unused_0, u8 unused_1, u8 unused_2)
-{
-    // debug?
-}
-
-void nullsub_13(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3)
-{
-
-}
-
-void sub_800E604(void)
-{
-    s32 i;
-    u8 unk_ee_bak = gUnknown_03005000.unk_ee;
-    CpuFill16(0, &gUnknown_03005000, sizeof gUnknown_03005000);
-    gUnknown_03005000.unk_ee = unk_ee_bak;
-    gUnknown_03005000.unk_0c = 0xFF;
-    if (gUnknown_03005000.unk_ee != 4)
-    {
-        gUnknown_03005000.unk_ee = 0;
-    }
-    for (i = 0; i < 5; i++)
-    {
-        sub_800FCC4(gUnknown_03005000.unk_80 + i);
-    }
-    sub_800FCC4(&gUnknown_03005000.unk_6c);
-    sub_800D6C8(&gUnknown_03005000.unk_124);
-    sub_800D724(&gUnknown_03005000.unk_9e8);
-    CpuFill16(0, gSendCmd, sizeof gSendCmd);
-    CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
-    CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers);
-}
-
-void sub_800E6D0(void)
-{
-    IntrFunc serialIntr = gIntrTable[1];
-    IntrFunc timerIntr = gIntrTable[2];
-    sub_800E700();
-    rfu_REQ_stopMode();
-    rfu_waitREQComplete();
-    REG_IME = 0;
-    gIntrTable[1] = serialIntr;
-    gIntrTable[2] = timerIntr;
-    REG_IME = INTR_FLAG_VBLANK;
-}
-
-void sub_800E700(void)
-{
-    if (!rfu_initializeAPI((void *)gUnknown_03004140.unk_50, sizeof gUnknown_03004140.unk_50, gIntrTable + 1, TRUE))
-    {
-        gLinkType = 0;
-        sub_800AAF4();
-        sub_80111B0(0);
-        sub_800E604();
-        rfu_setTimerInterrupt(3, gIntrTable + 2);
-    }
-}
-
-void sub_800E748(u8 taskId)
-{
-    sub_8010750();
-    switch (gUnknown_03005000.unk_04)
-    {
-        case 0:
-            sub_800BFCC(&gUnknown_02022B2C);
-            gUnknown_03005000.unk_04 = 1;
-            gTasks[taskId].data[1] = 1;
-            break;
-        case 1:
-            break;
-        case 2:
-            sub_800C054(gUnknown_03005000.unk_0c, 0, 240, gUnknown_082ED6E0);
-            gUnknown_03005000.unk_04 = 3;
-            gTasks[taskId].data[1] = 6;
-            break;
-        case 3:
-            break;
-        case 4:
-            sub_800C27C(FALSE);
-            gUnknown_03005000.unk_04 = 5;
-            break;
-        case 5:
-            break;
-        case 18:
-            gUnknown_03005000.unk_cdb = 0;
-            sub_800D52C(sub_800EDBC);
-            sub_800EAB4();
-            sub_800EAFC();
-            gUnknown_03005000.unk_04 = 20;
-            gTasks[taskId].data[1] = 8;
-            CreateTask(sub_801084C, 5);
-            DestroyTask(taskId);
-            break;
-    }
-}
-
-s32 sub_800E87C(u8 idx)
-{
-    return gUnknown_082ED6A5[idx];
-}
-
-void sub_800E88C(s32 r2, s32 r5)
-{
-    u8 i;
-    u8 r4 = 1;
-    s32 r1 = r2;
-    s32 r6 = 0;
-    if (r5 == -1)
-    {
-        for (i = 0; i < 4; r2 >>= 1, i++)
-        {
-            if (r2 & 1)
-            {
-                gUnknown_03005000.unk_cde[i] = r4;
-                r4++;
-            }
-        }
-    }
-    else
-    {
-        for (i = 0; i < 4; r1 >>= 1, i++)
-        {
-            if (!(r1 & 1))
-            {
-                gUnknown_03005000.unk_cde[i] = 0;
-            }
-        }
-        for (r4 = 4; r4 != 0; r4--)
-        {
-            for (i = 0; i < 4 && gUnknown_03005000.unk_cde[i] != r4; i++);
-            if (i == 4)
-            {
-                r6 = r4;
-            }
-        }
-        for (r5 &= ~r2, i = 0; i < 4; r5 >>= 1, i++)
-        {
-            if (r5 & 1)
-            {
-                gUnknown_03005000.unk_cde[i] = r6++;
-            }
-        }
-    }
-}
-
-void sub_800E94C(u8 taskId)
-{
-    switch (gUnknown_03005000.unk_04)
-    {
-        case 0:
-            sub_800BFCC(&gUnknown_082ED608);
-            gUnknown_03005000.unk_04 = 1;
-            gTasks[taskId].data[1] = 1;
-            break;
-        case 1:
-            break;
-        case 6:
-            sub_800C054(gUnknown_03005000.unk_0c, 0, 0xf0, gUnknown_082ED6E0);
-            gUnknown_03005000.unk_04 = 7;
-            gTasks[taskId].data[1] = 7;
-            break;
-        case 7:
-            break;
-        case 9:
-            gTasks[taskId].data[1] = 10;
-            break;
-        case 11:
-            switch (sub_80107A0())
-            {
-                case 5:
-                    gUnknown_03005000.unk_04 = 12;
-                    break;
-                case 6:
-                case 9:
-                    sub_800D630();
-                    gUnknown_03005000.unk_ce4 = 2;
-                    DestroyTask(taskId);
-                    break;
-            }
-            break;
-        case 12:
-        {
-            u8 r5 = 1 << gUnknown_03005000.unk_c3e;
-            rfu_clearSlot(12, gUnknown_03005000.unk_c3e);
-            rfu_setRecvBuffer(16, gUnknown_03005000.unk_c3e, gUnknown_03005000.unk_c3f, 70);
-            rfu_UNI_setSendData(r5, gUnknown_03005000.unk_4c, 14);
-            gTasks[taskId].data[1] = 8;
-            DestroyTask(taskId);
-            if (gUnknown_02022B44.unk_0f == 0)
-            {
-                sub_801227C();
-                gUnknown_02022B44.unk_0f++;
-            }
-            CreateTask(sub_801084C, 5);
-            break;
-        }
-    }
-}
-
-static void sub_800EAB4(void)
-{
-    u8 i;
-    u8 r5 = gUnknown_03004140.unk_00;
-    for (i = 0; i < 4; i++)
-    {
-        if (r5 & 1)
-        {
-            rfu_setRecvBuffer(16, i, gUnknown_03005000.unk_14[i], 14);
-            rfu_clearSlot(3, i);
-        }
-        r5 >>= 1;
-    }
-}
-
-static void sub_800EAFC(void)
-{
-    u8 r5 = gUnknown_03004140.unk_00;
-    rfu_UNI_setSendData(r5, gUnknown_03005000.unk_c87, 70);
-    gUnknown_03005000.unk_cda = sub_800E87C(r5);
-    gUnknown_03005000.unk_ce2 = r5;
-    sub_800E88C(r5, -1);
-    gUnknown_03005000.unk_0c = 1;
-}
-
-void sub_800EB44(u8 taskId)
-{
-    if (sub_800F7DC()->unk_0a_0 == 0x54 && sub_8011A74() == 4)
-    {
-        rfu_REQ_disconnect(gUnknown_03004140.unk_00);
-        rfu_waitREQComplete();
-        sub_8011A64(0, 0);
-    }
-    switch (gUnknown_03005000.unk_04)
-    {
-        case 0:
-            sub_800BFCC(&gUnknown_02022B2C);
-            gUnknown_03005000.unk_04 = 1;
-            gTasks[taskId].data[1] = 1;
-            break;
-        case 1:
-            break;
-        case 17:
-            sub_800C054(2, 0, 240, gUnknown_082ED6E0);
-            sub_800D52C(sub_800ED34);
-            gUnknown_03005000.unk_04 = 18;
-            break;
-        case 18:
-            break;
-        case 13:
-            if (rfu_UNI_setSendData(1 << gUnknown_03005000.unk_c3e, gUnknown_03005000.unk_4c, 14) == 0)
-            {
-                gUnknown_03005000.unk_0c = 0;
-                DestroyTask(taskId);
-                if (gTasks[taskId].data[7])
-                {
-                    CreateTask(sub_8010D0C, 1);
-                }
-                else
-                {
-                    CreateTask(sub_801084C, 5);
-                }
-            }
-            break;
-        case 14:
-            sub_800C27C(0);
-            gUnknown_03005000.unk_04 = 15;
-            break;
-        case 15:
-            break;
-        case 16:
-            gUnknown_03005000.unk_cdb = 0;
-            sub_800D52C(sub_800EDBC);
-            sub_8011068(1);
-            sub_800EAB4();
-            sub_800EAFC();
-            gUnknown_03005000.unk_04 = 20;
-            gTasks[taskId].data[1] = 8;
-            gUnknown_03005000.unk_0c = 1;
-            CreateTask(sub_801084C, 5);
-            gUnknown_03005000.unk_ce8 = 1;
-            DestroyTask(taskId);
-            break;
-    }
-}
-
-void sub_800ED10(void)
-{
-    sub_800C054(1, 0, 240, gUnknown_082ED6E0);
-}
-
-void sub_800ED28(void)
-{
-    sub_800C27C(FALSE);
-}
-
-void sub_800ED34(u16 unused)
-{
-    s32 i;
-
-    for (i = 0; i < 14; i++)
-    {
-        gUnknown_03005000.unk_4c[i] = 0;
-    }
-    rfu_REQ_recvData();
-    rfu_waitREQComplete();
-    if (gRfuSlotStatusUNI[gUnknown_03005000.unk_c3e]->recv.newDataFlag)
-    {
-        gUnknown_03005000.unk_cd0++;
-        sub_800D7D8(&gUnknown_03005000.unk_124, gUnknown_03005000.unk_c3f);
-        gUnknown_02022B44.unk_06++;
-        sub_800F048();
-        rfu_UNI_readySendData(gUnknown_03005000.unk_c3e);
-        rfu_UNI_clearRecvNewDataFlag(gUnknown_03005000.unk_c3e);
-    }
-    rfu_REQ_sendData_wrapper(1);
-}
-
-static void sub_800EDBC(u16 unused)
-{
-    gUnknown_03005000.unk_cdb = 1;
-}
-
-void sub_800EDD4(void)
-{
-    u8 i;
-
-    sub_800C048();
-    if (gUnknown_03005000.unk_0c == 1)
-    {
-        if (FuncIsActiveTask(sub_800E748) == TRUE)
-        {
-            DestroyTask(gUnknown_03005000.unk_67);
-            sub_800E604();
-        }
-    }
-    else if (gUnknown_03005000.unk_0c == 0)
-    {
-        if (FuncIsActiveTask(sub_800E94C) == TRUE)
-        {
-            DestroyTask(gUnknown_03005000.unk_67);
-            sub_800E604();
-        }
-    }
-    else if (gUnknown_03005000.unk_0c == 2)
-    {
-        if (FuncIsActiveTask(sub_800EB44) == TRUE)
-        {
-            DestroyTask(gUnknown_03005000.unk_67);
-            sub_800E604();
-        }
-    }
-    for (i = 0; i < 3; i++)
-    {
-        if (FuncIsActiveTask(gUnknown_082ED7E0[i]) == TRUE)
-        {
-            DestroyTask(FindTaskIdByFunc(gUnknown_082ED7E0[i]));
-        }
-    }
-}
-
-void sub_800EE78(void)
-{
-    gUnknown_03005000.unk_67 = CreateTask(sub_800E748, 1);
-}
-
-bool8 sub_800EE94(void)
-{
-    if (gUnknown_03005000.unk_04 == 7 && gUnknown_03005000.unk_ccd)
-    {
-        return TRUE;
-    }
-    return FALSE;
-}
-
-bool32 sub_800EEBC(void)
-{
-    if (gUnknown_03005000.unk_04 == 7 && !sub_800C12C(gRfuLinkStatus->partner[gUnknown_03005000.unk_c3d].id, 240))
-    {
-        gUnknown_03005000.unk_04 = 9;
-        return TRUE;
-    }
-    return FALSE;
-}
-
-void sub_800EF00(void)
-{
-    gUnknown_03005000.unk_67 = CreateTask(sub_800E94C, 1);
-}
-
-bool8 sub_800EF1C(void)
-{
-    if (gUnknown_03004140.unk_00)
-    {
-        return TRUE;
-    }
-    return FALSE;
-}
-
-void sub_800EF38(void)
-{
-    gUnknown_03005000.unk_04 = 4;
-    gUnknown_03005000.unk_ce7 = gUnknown_03004140.unk_00;
-}
-
-bool32 sub_800EF58(bool32 a0)
-{
-    if (gUnknown_03005000.unk_04 == 17 || a0)
-    {
-        gUnknown_03005000.unk_04 = 18;
-        return TRUE;
-    }
-    return FALSE;
-}
-
-void sub_800EF7C(void)
-{
-    gUnknown_03005000.unk_04 = 14;
-}
-
-void sub_800EF88(u8 a0)
-{
-    u8 i;
-
-    for (i = 0; i < 4; i++)
-    {
-        if (a0 & 1)
-        {
-            rfu_UNI_readySendData(i);
-            break;
-        }
-        a0 >>= 1;
-    }
-}
-
-void sub_800EFB0(void)
-{
-    s32 i, j;
-
-    for (i = 0; i < 5; i++)
-    {
-        struct UnkRfuStruct_2 *ptr = &gUnknown_03005000;
-        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];
-        }
-    }
-    CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
-}
-
-void sub_800F014(void)
-{
-    s32 i;
-    for (i = 0; i < 7; i++)
-    {
-        gRecvCmds[0][i] = gSendCmd[i];
-    }
-    for (i = 0; i < 7; i++)
-    {
-        gSendCmd[i] = 0;
-    }
-}
-
-static void sub_800F048(void)
-{
-    if (gUnknown_03005000.unk_c3c)
-    {
-        u8 r2 = sub_800DAC8(&gUnknown_03005000.unk_c1c, gUnknown_03005000.unk_4c);
-        if (gUnknown_03005000.unk_c1c.unk_1e == 0)
-        {
-            gUnknown_03005000.unk_c3c = 0;
-        }
-        if (r2)
-        {
-            return;
-        }
-    }
-    if (gUnknown_03005000.unk_c3c == 0)
-    {
-        sub_800D9DC(&gUnknown_03005000.unk_9e8, gUnknown_03005000.unk_4c);
-        sub_800DA68(&gUnknown_03005000.unk_c1c, gUnknown_03005000.unk_4c);
-    }
-}
-
-bool32 IsRfuRecvQueueEmpty(void)
-{
-    s32 i;
-    s32 j;
-
-    if (gRfuLinkStatus->sendSlotUNIFlag == 0)
-    {
-        return FALSE;
-    }
-    for (i = 0; i < 5; i++)
-    {
-        for (j = 0; j < 7; j++)
-        {
-            if (gRecvCmds[i][j] != 0)
-            {
-                return FALSE;
-            }
-        }
-    }
-    return TRUE;
-}
-
-bool32 sub_800F0F8(void)
-{
-    if (gUnknown_03005000.unk_04 < 20)
-    {
-        rfu_REQ_recvData();
-        rfu_waitREQComplete();
-        rfu_REQ_sendData_wrapper(0);
-    }
-    else
-    {
-        gUnknown_03005000.unk_cdb = 0;
-        if ((gUnknown_03005000.unk_ce2 & gRfuLinkStatus->connSlotFlag) == gUnknown_03005000.unk_ce2 && (gUnknown_03005000.unk_ce2 & gRfuLinkStatus->connSlotFlag))
-        {
-            if (!gUnknown_03005000.unk_cdc)
-            {
-                if (gUnknown_03005000.unk_ce3)
-                {
-                    sub_8011D6C(gUnknown_03005000.unk_ce3);
-                    gUnknown_03005000.unk_ce3 = 0;
-                    if (gUnknown_03005000.unk_ce4 == 1)
-                    {
-                        sub_8011A64(2, 0x8000);
-                        sub_8011170(0x8000);
-                        return FALSE;
-                    }
-                    if (!gUnknown_03004140.unk_00)
-                    {
-                        sub_800EDD4();
-                        gReceivedRemoteLinkPlayers = 0;
-                        return FALSE;
-                    }
-                }
-                sub_800EFB0();
-                rfu_UNI_readySendData(gUnknown_03005000.unk_cda);
-                rfu_REQ_sendData_wrapper(1);
-            }
-            else
-            {
-                rfu_REQ_PARENT_resumeRetransmitAndChange();
-            }
-            gUnknown_03005000.unk_0e = 1;
-        }
-    }
-    return FALSE;
-}
-
-bool32 sub_800F1E0(void)
-{
-    u16 i;
-    u16 flags;
-    u8 r0;
-    u16 j;
-    u8 retval;
-
-    if (gUnknown_03005000.unk_04 >= 20 && gUnknown_03005000.unk_0e == 1)
-    {
-        rfu_waitREQComplete();
-        while (gUnknown_03005000.unk_cdb == 0)
-        {
-            if (gUnknown_03005000.unk_ee != 0)
-            {
-                return FALSE;
-            }
-        }
-        rfu_REQ_recvData();
-        rfu_waitREQComplete();
-        if ((gUnknown_03004140.unk_03 & gUnknown_03005000.unk_ce2) == gUnknown_03005000.unk_ce2)
-        {
-            gUnknown_03005000.unk_cdc = 0;
-            gUnknown_02022B44.unk_06++;
-            flags = gUnknown_03004140.unk_00;
-            for (i = 0; i < 4; i++)
-            {
-                if (flags & 1)
-                {
-                    if (gUnknown_03005000.unk_14[i][1])
-                    {
-                        if (gUnknown_03005000.unk_cee[i] != 0xFF && (gUnknown_03005000.unk_14[i][0] >> 5) != ((gUnknown_03005000.unk_cee[i] + 1) & 7))
-                        {
-                            if (++gUnknown_03005000.unk_cea[i] > 4)
-                                sub_8011170(0x8100);
-                        }
-                        else
-                        {
-                            gUnknown_03005000.unk_cee[i] = gUnknown_03005000.unk_14[i][0] / 32;
-                            gUnknown_03005000.unk_cea[i] = 0;
-                            gUnknown_03005000.unk_14[i][0] &= 0x1f;
-                            r0 = gUnknown_03005000.unk_cde[i];
-                            for (j = 0; j < 7; j++)
-                            {
-                                gRecvCmds[r0][j] = (gUnknown_03005000.unk_14[i][(j << 1) + 1] << 8) | gUnknown_03005000.unk_14[i][(j << 1) + 0];
-                                gUnknown_03005000.unk_14[i][(j << 1) + 1] = 0;
-                                gUnknown_03005000.unk_14[i][(j << 1) + 0] = 0;
-                            }
-                        }
-                    }
-                    rfu_UNI_clearRecvNewDataFlag(i);
-                }
-                flags >>= 1;
-            }
-            sub_800F014();
-            sub_800F86C(0);
-            sub_8010528();
-            if (gUnknown_03005000.unk_ce5 && !gUnknown_03005000.unk_cd9)
-            {
-                gUnknown_02022B44.unk_0e = 0;
-                rfu_clearSlot(3, gUnknown_03005000.unk_cda);
-                for (i = 0; i < 4; i++)
-                {
-                    if ((gUnknown_03005000.unk_ce5 >> i) & 1)
-                    {
-                        rfu_setRecvBuffer(0x10, i, gUnknown_03005000.unk_14[i], 14);
-                    }
-                }
-                sub_800E88C(gUnknown_03005000.unk_ce2, gUnknown_03005000.unk_ce2 | gUnknown_03005000.unk_ce5);
-                gUnknown_03005000.unk_ce9 = gUnknown_03005000.unk_ce5;
-                gUnknown_03005000.unk_ce2 |= gUnknown_03005000.unk_ce5;
-                gUnknown_03005000.unk_ce5 = 0;
-                rfu_UNI_setSendData(gUnknown_03005000.unk_ce2, gUnknown_03005000.unk_c87, 70);
-                gUnknown_03005000.unk_cda = sub_800E87C(gUnknown_03005000.unk_ce2);
-                CreateTask(sub_8010AAC, 0);
-            }
-        }
-        else
-        {
-            gUnknown_03005000.unk_cdc = 1;
-            gUnknown_03005000.unk_0e = 0;
-        }
-        gUnknown_03005000.unk_0e = 0;
-    }
-    retval = gUnknown_03005000.unk_cdc;
-    return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE;
-}
-
-void sub_800F498(u16 *a0, u8 *a1)
-{
-    s32 i;
-
-    if (a0[0])
-    {
-        a0[0] |= (gUnknown_03005000.unk_102 << 5);
-        gUnknown_03005000.unk_102 = (gUnknown_03005000.unk_102 + 1) & 7;
-        for (i = 0; i < 7; i++)
-        {
-            a1[2 * i + 1] = a0[i] >> 8;
-            a1[2 * i + 0] = a0[i];
-        }
-    }
-    else
-    {
-        for (i = 0; i < 14; i++)
-            a1[i] = 0;
-    }
-}
-
-bool32 sub_800F4F0(void)
-{
-    u8 i;
-    u8 j;
-    u8 sp00[MAX_RFU_PLAYERS * (2 * (CMD_LENGTH - 1))];
-    u8 sp48[2 * (CMD_LENGTH - 1)];
-    u8 switchval;
-
-    sub_800D934(&gUnknown_03005000.unk_124, sp00);
-    for (i = 0; i < MAX_RFU_PLAYERS; i++)
-    {
-        for (j = 0; j < CMD_LENGTH - 1; j++)
-        {
-            gRecvCmds[i][j] = (sp00[i * 14 + (j << 1) + 1] << 8) | sp00[i * 14 + (j << 1) + 0];
-        }
-    }
-    sub_800F86C(0);
-    if (gUnknown_03004140.unk_02 == 0 && gUnknown_03005000.unk_ce4)
-    {
-        rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-        rfu_waitREQComplete();
-        switchval = sub_8011A74();
-        if (switchval != 1 && switchval != 6 && switchval != 9)
-            sub_8011A64(2, 0x9000);
-        rfu_clearAllSlot();
-        gReceivedRemoteLinkPlayers = FALSE;
-        gUnknown_03005000.linkRfuCallback = NULL;
-        if (gUnknown_03005000.unk_ce4 == 1)
-        {
-            sub_8011A64(2, 0x9000);
-            sub_8011170(0x9000);
-        }
-        gUnknown_03004140.unk_04 = gUnknown_03004140.unk_05 = 0;
-        gUnknown_03005000.unk_ce4 = 0;
-    }
-    if (gUnknown_03005000.unk_cd0)
-    {
-        gUnknown_03005000.unk_cd0--;
-        sub_8010528();
-        sub_800F498(gSendCmd, sp48);
-        sub_800D888(&gUnknown_03005000.unk_9e8, sp48);
-        for (i = 0; i < CMD_LENGTH - 1; i++)
-            gSendCmd[i] = 0;
-    }
-    return IsRfuRecvQueueEmpty();
-}
-
-void sub_800F638(u8 unused, u32 flags)
-{
-    s32 i, j;
-
-    const u8 *r10 = gUnknown_03005000.unk_6c.unk_04;
-    for (i = 0; i < gUnknown_03005000.unk_6c.unk_02; i++)
-    {
-        if (!(flags & 1))
-        {
-            gUnknown_03000D90[0] = (~0x76ff) | i;
-            for (j = 0; j < 7; j++)
-            {
-                gUnknown_03000D90[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0];
-            }
-            for (j = 0; j < 7; j++)
-            {
-                gUnknown_03000D80[2 * j + 1] = gUnknown_03000D90[j] >> 8;
-                gUnknown_03000D80[2 * j + 0] = gUnknown_03000D90[j];
-
-                j++;j--; // Needed to match;
-            }
-            sub_800D888(&gUnknown_03005000.unk_9e8, gUnknown_03000D80);
-            gUnknown_03005000.unk_6c.unk_0c |= (1 << i);
-        }
-        flags >>= 1;
-    }
-}
-
-void sub_800F6FC(u8 a0)
-{
-    if (gUnknown_03005000.unk_0c == 1 && a0)
-        gUnknown_03005000.unk_61[a0] = 1;
-    else
-        gUnknown_03005000.unk_5c[a0] = 1;
-}
-
-void sub_800F728(u8 a0)
-{
-    gUnknown_03005000.unk_5c[a0] = 0;
-    gUnknown_03005000.unk_80[a0].unk_12 = 0;
-}
-
-u8 sub_800F74C(const u8 *a0)
-{
-    u8 i;
-
-    if (gUnknown_03005000.unk_0c == 1)
-        return FALSE;
-    for (i = 0; i < 4; i++)
-    {
-        gUnknown_03005000.unk_cde[i] = a0[i];
-    }
-    return a0[gUnknown_03005000.unk_c3e];
-}
-
-void rfu_func_080F97B8(void)
-{
-    if (gReceivedRemoteLinkPlayers
-        && gHeldKeyCodeToSend != LINK_KEY_CODE_NULL
-        && gLinkTransferringData != TRUE)
-    {
-        gUnknown_03000D78[0]++;
-        gHeldKeyCodeToSend |= (gUnknown_03000D78[0] << 8);
-        sub_800FD14(0xbe00);
-    }
-}
-
-struct UnkLinkRfuStruct_02022B14 *sub_800F7DC(void)
-{
-    return &gUnknown_02022B14;
-}
-
-bool32 IsSendingKeysToRfu(void)
-{
-    return gUnknown_03005000.linkRfuCallback == rfu_func_080F97B8;
-}
-
-void sub_800F804(void)
-{
-    gUnknown_03005000.linkRfuCallback = rfu_func_080F97B8;
-}
-
-void ClearLinkRfuCallback(void)
-{
-    gUnknown_03005000.linkRfuCallback = NULL;
-}
-
-void sub_800F820(void)
-{
-    sub_800FD14(0x4400);
-    if (GetMultiplayerId() == 0)
-        gSendCmd[6] = GetBlenderArrowPosition();
-    gUnknown_020223C0++;
-}
-
-void sub_800F850(void)
-{
-    if (gUnknown_03005000.linkRfuCallback == NULL)
-        gUnknown_03005000.linkRfuCallback = sub_800F820;
-}
-
-static void sub_800F86C(u8 unused)
-{
-    u16 i;
-    u16 j;
-
-    for (i = 0; i < MAX_RFU_PLAYERS; i++)
-    {
-        switch (gRecvCmds[i][0] & 0xff00)
-        {
-        case 0x7800:
-            if (gUnknown_03005000.unk_0c == 0 && gReceivedRemoteLinkPlayers != 0)
-                return;
-            // fallthrough
-        case 0x7700:
-            if (gRfuLinkStatus->parentChild == 0)
-            {
-                gUnknown_03005000.playerCount = gRecvCmds[i][1];
-                gUnknown_03005000.unk_cce = sub_800F74C((u8 *)(gRecvCmds[i] + 2));
-            }
-            break;
-        case 0x8800:
-            if (gUnknown_03005000.unk_80[i].unk_12 == 0)
-            {
-                gUnknown_03005000.unk_80[i].unk_00 = 0;
-                gUnknown_03005000.unk_80[i].unk_02 = gRecvCmds[i][1];
-                gUnknown_03005000.unk_80[i].unk_11 = gRecvCmds[i][2];
-                gUnknown_03005000.unk_80[i].unk_08 = 0;
-                gUnknown_03005000.unk_80[i].unk_12 = 1;
-                gUnknown_03005000.unk_5c[i] = 0;
-            }
-            break;
-        case 0x8900:
-            if (gUnknown_03005000.unk_80[i].unk_12 == 1)
-            {
-                gUnknown_03005000.unk_80[i].unk_00 = gRecvCmds[i][0] & 0xff;
-                gUnknown_03005000.unk_80[i].unk_08 |= (1 << gUnknown_03005000.unk_80[i].unk_00);
-                for (j = 0; j < 6; j++)
-                    gBlockRecvBuffer[i][gUnknown_03005000.unk_80[i].unk_00 * 6 + j] = gRecvCmds[i][j + 1];
-                if (gUnknown_03005000.unk_80[i].unk_08 == gUnknown_082ED628[gUnknown_03005000.unk_80[i].unk_02])
-                {
-                    gUnknown_03005000.unk_80[i].unk_12 = 2;
-                    sub_800F6FC(i);
-                    if (sub_800F7DC()->unk_0a_0 == 0x45 && gReceivedRemoteLinkPlayers != 0 && gUnknown_03005000.unk_0c == 0)
-                        sub_8010A70(gBlockRecvBuffer);
-                }
-            }
-            break;
-        case 0xa100:
-            sub_800FE84(gUnknown_082ED6B8[gRecvCmds[i][1]].buffer, (u16)gUnknown_082ED6B8[gRecvCmds[i][1]].size);
-            break;
-        case 0x5f00:
-            gUnknown_03005000.unk_e4[i] = 1;
-            break;
-        case 0x6600:
-            if (gUnknown_03005000.unk_100 == gRecvCmds[i][1])
-                gUnknown_03005000.unk_e9[i] = 1;
-            break;
-        case 0xed00:
-            if (gUnknown_03005000.unk_0c == 0)
-            {
-                if (gReceivedRemoteLinkPlayers != 0)
-                {
-                    if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag)
-                    {
-                        gReceivedRemoteLinkPlayers = 0;
-                        sub_800D630();
-                        gUnknown_03005000.unk_ce4 = gRecvCmds[i][2];
-                    }
-                    gUnknown_03005000.playerCount = gRecvCmds[i][3];
-                    sub_80109E8(gRecvCmds[i][1]);
-                }
-            }
-            else
-            {
-                sub_800FD14(0xee00);
-                gSendCmd[1] = gRecvCmds[i][1];
-                gSendCmd[2] = gRecvCmds[i][2];
-                gSendCmd[3] = gRecvCmds[i][3];
-            }
-            break;
-        case 0xee00:
-            if (gUnknown_03005000.unk_0c == 1)
-            {
-                gUnknown_03005000.unk_ce3 |= gRecvCmds[i][1];
-                gUnknown_03005000.unk_ce4 = gRecvCmds[i][2];
-                sub_80109E8(gRecvCmds[i][1]);
-            }
-            break;
-        case 0x4400:
-        case 0xbe00:
-            gLinkPartnersHeldKeys[i] = gRecvCmds[i][1];
-            break;
-        }
-        if (gUnknown_03005000.unk_0c == 1 && gUnknown_03005000.unk_61[i])
-        {
-            if (gUnknown_03005000.unk_61[i] == 4)
-            {
-                gUnknown_03005000.unk_5c[i] = 1;
-                gUnknown_03005000.unk_61[i] = 0;
-            }
-            else
-                gUnknown_03005000.unk_61[i]++;
-        }
-    }
-}
-
-bool8 sub_800FC60(void)
-{
-    s32 i;
-
-    for (i = 0; i < 5; i++)
-    {
-        if (gUnknown_03005000.unk_80[i].unk_12)
-            return FALSE;
-    }
-    return TRUE;
-}
-
-bool8 sub_800FC88(void)
-{
-    s32 i;
-
-    for (i = 0; i < gUnknown_03005000.playerCount; i++)
-    {
-        if (gUnknown_03005000.unk_80[i].unk_12 != 2 || gUnknown_03005000.unk_5c[i] != 1)
-            return FALSE;
-    }
-    return TRUE;
-}
-
-static void sub_800FCC4(struct UnkRfuStruct_2_Sub_6c *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;
-}
-
-u8 sub_800FCD8(void)
-{
-    u8 flags = 0;
-    s32 i;
-
-    for (i = 0; i < 5; i++)
-    {
-        if (gUnknown_03005000.unk_80[i].unk_12 == 2 && gUnknown_03005000.unk_5c[i] == 1)
-        {
-            flags |= (1 << i);
-        }
-    }
-    return flags;
-}
-
-void sub_800FD14(u16 command)
-{
-    u8 i;
-    u8 *buff;
-    u8 tmp;
-
-    gSendCmd[0] = command;
-    switch (command)
-    {
-    case 0x8800:
-        gSendCmd[1] = gUnknown_03005000.unk_6c.unk_02;
-        gSendCmd[2] = gUnknown_03005000.unk_6c.unk_11 + 0x80;
-        break;
-    case 0xa100:
-        if (sub_800FC60())
-            gSendCmd[1] = gUnknown_03005000.unk_5a;
-        break;
-    case 0x7700:
-    case 0x7800:
-        tmp = gUnknown_03005000.unk_ce2 ^ gUnknown_03005000.unk_ce3;
-        gUnknown_03005000.playerCount = gUnknown_082ED695[tmp] + 1;
-        gSendCmd[1] = gUnknown_03005000.playerCount;
-        buff = (u8 *)(gSendCmd + 2);
-        for (i = 0; i < 4; i++)
-            buff[i] = gUnknown_03005000.unk_cde[i];
-        break;
-    case 0x6600:
-    case 0x5f00:
-        gSendCmd[1] = gUnknown_03005000.unk_100;
-        break;
-    case 0x4400:
-        gSendCmd[0] = command;
-        gSendCmd[1] = gMain.heldKeys;
-        break;
-    case 0x2f00:
-        for (i = 0; i < 6; i++)
-            gSendCmd[1 + i] = gUnknown_03005000.unk_f2[i];
-        break;
-    case 0xbe00:
-        gSendCmd[1] = gHeldKeyCodeToSend;
-        break;
-    case 0xee00:
-        break;
-    case 0xed00:
-        break;
-    }
-}
-
-void sub_800FE50(void *a0)
-{
-    if (gSendCmd[0] == 0 && !sub_8011A80())
-    {
-        memcpy(gUnknown_03005000.unk_f2, a0, sizeof(gUnknown_03005000.unk_f2));
-        sub_800FD14(0x2f00);
-    }
-}
-
-bool32 sub_800FE84(const u8 *src, size_t size)
-{
-    bool8 r4;
-    if (gUnknown_03005000.linkRfuCallback != NULL)
-        return FALSE;
-    if (gSendCmd[0] != 0)
-        return FALSE;
-    if (gUnknown_03005000.unk_6c.unk_10 != 0)
-    {
-        gUnknown_02022B44.unk_83++;
-        return FALSE;
-    }
-    r4 = (size % 12) != 0;
-    gUnknown_03005000.unk_6c.unk_11 = GetMultiplayerId();
-    gUnknown_03005000.unk_6c.unk_10 = 1;
-    gUnknown_03005000.unk_6c.unk_02 = (size / 12) + r4;
-    gUnknown_03005000.unk_6c.unk_00 = 0;
-    if (size > 0x100)
-        gUnknown_03005000.unk_6c.unk_04 = src;
-    else
-    {
-        if (src != gBlockSendBuffer)
-            memcpy(gBlockSendBuffer, src, size);
-        gUnknown_03005000.unk_6c.unk_04 = gBlockSendBuffer;
-    }
-    sub_800FD14(0x8800);
-    gUnknown_03005000.linkRfuCallback = rfufunc_80F9F44;
-    gUnknown_03005000.unk_5b = 0;
-    return TRUE;
-}
-
-static void rfufunc_80F9F44(void)
-{
-    if (gSendCmd[0] == 0)
-    {
-        sub_800FD14(0x8800);
-        if (gUnknown_03005000.unk_0c == 1)
-        {
-            if (++gUnknown_03005000.unk_5b > 2)
-                gUnknown_03005000.linkRfuCallback = sub_800FFB0;
-        }
-        else
-        {
-            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == 0x8800)
-                gUnknown_03005000.linkRfuCallback = sub_800FFB0;
-        }
-    }
-}
-
-static void sub_800FFB0(void)
-{
-    s32 i;
-    const u8 *src = gUnknown_03005000.unk_6c.unk_04;
-    gSendCmd[0] = 0x8900 | gUnknown_03005000.unk_6c.unk_00;
-    for (i = 0; i < 7; i++)
-        gSendCmd[i + 1] = (src[(i << 1) + gUnknown_03005000.unk_6c.unk_00 * 12 + 1] << 8) | src[(i << 1) + gUnknown_03005000.unk_6c.unk_00 * 12 + 0];
-    gUnknown_03005000.unk_6c.unk_00++;
-    if (gUnknown_03005000.unk_6c.unk_02 <= gUnknown_03005000.unk_6c.unk_00)
-    {
-        gUnknown_03005000.unk_6c.unk_10 = 0;
-        gUnknown_03005000.linkRfuCallback = rfufunc_80FA020;
-    }
-}
-
-static void rfufunc_80FA020(void)
-{
-    const u8 *src = gUnknown_03005000.unk_6c.unk_04;
-    u8 mpId = GetMultiplayerId();
-    s32 i;
-    if (gUnknown_03005000.unk_0c == 0)
-    {
-        gSendCmd[0] = (~0x76ff) | (gUnknown_03005000.unk_6c.unk_02 - 1);
-        for (i = 0; i < 7; i++)
-            gSendCmd[i + 1] = (src[(i << 1) + (gUnknown_03005000.unk_6c.unk_02 - 1) * 12 + 1] << 8) | src[(i << 1) + (gUnknown_03005000.unk_6c.unk_02 - 1) * 12 + 0];
-        if ((u8)gRecvCmds[mpId][0] == gUnknown_03005000.unk_6c.unk_02 - 1)
-        {
-            if (gUnknown_03005000.unk_80[mpId].unk_08 != gUnknown_082ED628[gUnknown_03005000.unk_80[mpId].unk_02])
-            {
-                sub_800F638(mpId, gUnknown_03005000.unk_80[mpId].unk_08);
-                gUnknown_02022B44.unk_64++;
-            }
-            else
-                gUnknown_03005000.linkRfuCallback = NULL;
-        }
-    }
-    else
-        gUnknown_03005000.linkRfuCallback = NULL;
-}
-
-bool8 sub_8010100(u8 a0)
-{
-    gUnknown_03005000.unk_5a = a0;
-    sub_800FD14(0xa100);
-    return TRUE;
-}
-
-void sub_801011C(void)
-{
-    rfu_clearAllSlot();
-    sub_800C048();
-    gReceivedRemoteLinkPlayers = 0;
-    gUnknown_03005000.unk_ef = 1;
-    gUnknown_03005000.linkRfuCallback = NULL;
-}
-
-void sub_8010148(void)
-{
-    rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
-    rfu_waitREQComplete();
-    sub_801011C();
-}
-
-void sub_8010168(void)
-{
-    if (gUnknown_03005000.unk_0c == 0)
-    {
-        sub_800D630();
-        gUnknown_03005000.unk_ce4 = 2;
-    }
-    else
-        gUnknown_03005000.linkRfuCallback = sub_8010148;
-}
-
-void LinkRfu_FatalError(void)
-{
-    sub_800D630();
-    gUnknown_03005000.unk_ce4 = 1;
-    gUnknown_03005000.unk_ce3 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
-}
-
-void sub_80101CC(void)
-{
-    s32 i;
-    u8 playerCount = gUnknown_03005000.playerCount;
-    s32 count = 0;
-
-    for (i = 0; i < MAX_RFU_PLAYERS; i++)
-    {
-        if (gUnknown_03005000.unk_e4[i])
-            count++;
-    }
-    if (count == playerCount)
-    {
-        gBattleTypeFlags &= ~BATTLE_TYPE_20;
-        if (gUnknown_03005000.unk_0c == 0)
-        {
-            gUnknown_03005000.unk_ee = 3;
-            sub_8010168();
-        }
-        else
-            gUnknown_03005000.linkRfuCallback = sub_8010168;
-    }
-}
-
-void sub_801022C(void)
-{
-    if (gSendCmd[0] == 0 && gUnknown_03005000.unk_ce8 == 0)
-    {
-        sub_800FD14(0x5f00);
-        gUnknown_03005000.linkRfuCallback = sub_80101CC;
-    }
-}
-
-void sub_8010264(u8 taskId)
-{
-    if (gUnknown_03005000.linkRfuCallback == NULL)
-    {
-        gUnknown_03005000.unk_cd9 = 1;
-        gUnknown_03005000.linkRfuCallback = sub_801022C;
-        DestroyTask(taskId);
-    }
-}
-
-void task_add_05_task_del_08FA224_when_no_RfuFunc(void)
-{
-    if (!FuncIsActiveTask(sub_8010264))
-        CreateTask(sub_8010264, 5);
-}
-
-void sub_80102B8(void)
-{
-    u8 playerCount;
-    u8 i;
-
-    if (GetMultiplayerId() != 0)
-    {
-        u8 r4 = gUnknown_03005000.unk_124.unk_8c2;
-        if (r4 == 0 && gUnknown_03005000.unk_fe > 0x3c)
-        {
-            sub_800FD14(0x6600);
-            gUnknown_03005000.unk_fe = r4;
-        }
-    }
-    playerCount = GetLinkPlayerCount();
-    for (i = 0; i < playerCount; i++)
-    {
-        if (gUnknown_03005000.unk_e9[i] == 0)
-            break;
-    }
-    if (i == playerCount)
-    {
-        for (i = 0; i < MAX_RFU_PLAYERS; i++)
-            gUnknown_03005000.unk_e9[i] = 0;
-        gUnknown_03005000.unk_100++;
-        gUnknown_03005000.linkRfuCallback = NULL;
-    }
-    gUnknown_03005000.unk_fe++;
-}
-
-void sub_8010358(void)
-{
-    if (gUnknown_03005000.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
-    {
-        sub_800FD14(0x6600);
-        gUnknown_03005000.linkRfuCallback = sub_80102B8;
-    }
-}
-
-void sub_8010390(void)
-{
-    u8 i;
-    u8 playerCount;
-
-    if (GetMultiplayerId() != 0)
-    {
-        if (gUnknown_03005000.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
-        {
-            sub_800FD14(0x6600);
-            gUnknown_03005000.linkRfuCallback = sub_80102B8;
-        }
-    }
-    else
-    {
-        playerCount = GetLinkPlayerCount();
-        for (i = 1; i < playerCount; i++)
-        {
-            if (gUnknown_03005000.unk_e9[i] == 0)
-                break;
-        }
-        if (i == playerCount)
-        {
-            if (gUnknown_03005000.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
-            {
-                sub_800FD14(0x6600);
-                gUnknown_03005000.linkRfuCallback = sub_8010358;
-            }
-        }
-    }
-}
-
-void sub_8010434(void)
-{
-    if (gUnknown_03005000.linkRfuCallback == NULL)
-    {
-        gUnknown_03005000.linkRfuCallback = sub_8010390;
-        gUnknown_03005000.unk_fe = 0;
-    }
-}
-
-bool32 sub_8010454(u32 a0)
-{
-    s32 i;
-    for (i = 0; gUnknown_082ED6E0[i] != a0; i++)
-    {
-        if (gUnknown_082ED6E0[i] == 0xFFFF)
-            return FALSE;
-    }
-    return TRUE;
-}
-
-u8 sub_801048C(bool32 a0)
-{
-    if (a0 == FALSE)
-        return sub_800D550(0, 0);
-    sub_800D550(1, 0x258);
-    return 0;
-}
-
-void sub_80104B0(void)
-{
-    gUnknown_03005000.unk_cd9 = 1;
-    sub_800C27C(FALSE);
-}
-
-u8 rfu_get_multiplayer_id(void)
-{
-    if (gUnknown_03005000.unk_0c == 1)
-        return 0;
-    return gUnknown_03005000.unk_cce;
-}
-
-u8 sub_80104F4(void)
-{
-    return gUnknown_03005000.playerCount;
-}
-
-bool8 IsLinkRfuTaskFinished(void)
-{
-    if (gUnknown_03005000.unk_f1 == 2)
-        return FALSE;
-    return gUnknown_03005000.linkRfuCallback ? FALSE : TRUE;
-}
-
-static void sub_8010528(void)
-{
-    if (gUnknown_03005000.linkRfuCallback)
-        gUnknown_03005000.linkRfuCallback();
-}
-
-bool8 sub_8010540(void)
-{
-    s32 i;
-    bool8 retval = FALSE;
-    for (i = 0; i < 4; i++)
-    {
-        if (gUnknown_03005000.unk_cd1[i] < 5 || gUnknown_03005000.unk_cd1[i] > 6)
-        {
-            if (gRfuSlotStatusNI[i]->recv.state == 0x46 || gRfuSlotStatusNI[i]->recv.state == 0x48)
-            {
-                if (gUnknown_03005000.unk_cd5[i] == 8)
-                {
-                    gUnknown_03005000.unk_cd1[i] = 9;
-                    gUnknown_03005000.unk_cd5[i] = 10;
-                    rfu_clearSlot(8, i);
-                    rfu_NI_setSendData(1 << i, 8, gUnknown_03005000.unk_cd1 + i, 1);
-                    retval = TRUE;
-                }
-
-            }
-            else if (gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->recv.state == 0x47)
-                rfu_clearSlot(8, i);
-            {
-
-            }
-        }
-    }
-    return retval;
-}
-
-bool32 sub_80105EC(void)
-{
-    u8 flags = 0;
-    s32 i;
-    for (i = 0; i < 4; i++)
-    {
-        if (gUnknown_03005000.unk_cd5[i] == 11)
-        {
-            flags |= (1 << i);
-            gUnknown_03005000.unk_cd5[i] = 0;
-        }
-    }
-    if (flags)
-    {
-        rfu_REQ_disconnect(flags);
-        rfu_waitREQComplete();
-    }
-    for (i = 0; i < 4; i++)
-    {
-        if (gUnknown_03005000.unk_cd5[i] == 10 || gUnknown_03005000.unk_cd5[i] == 11)
-            return TRUE;
-    }
-    return FALSE;
-}
-
-bool32 sub_801064C(u16 a0, const u8 *a1)
-{
-    u8 r1 = sub_8011CE4(a1, a0);
-    if (r1 == 0xFF)
-        return TRUE;
-    if (gUnknown_03005000.unk_cd1[r1] == 9)
-        return TRUE;
-    return FALSE;
-}
-
-void sub_8010688(u8 a0, u16 a1, const u8 *a2)
-{
-    u8 r4 = sub_8011CE4(a2, a1);
-    gUnknown_03005000.unk_cd1[r4] = a0;
-    rfu_clearSlot(4, r4);
-    rfu_NI_setSendData(1 << r4, 8, gUnknown_03005000.unk_cd1 + r4, 1);
-}
-
-void sub_80106D4(void)
-{
-    gUnknown_03005000.unk_c85 = 8;
-    rfu_clearSlot(4, gUnknown_03005000.unk_c3e);
-    rfu_NI_setSendData(1 << gUnknown_03005000.unk_c3e, 8, &gUnknown_03005000.unk_c85, 1);
-}
-
-u32 sub_8010714(u16 a0, const u8 *a1)
-{
-    u8 r0 = sub_8011CE4(a1, a0);
-    if (r0 == 0xFF)
-        return 2;
-    if (gRfuSlotStatusNI[r0]->send.state == 0)
-        return 1;
-    return 0;
-}
-
-void sub_8010750(void)
-{
-    s32 i;
-
-    sub_8010540();
-    for (i = 0; i < 4; i++)
-    {
-        if (gRfuSlotStatusNI[i]->send.state == 0x26 || gRfuSlotStatusNI[i]->send.state == 0x27)
-        {
-            if (gUnknown_03005000.unk_cd5[i] == 10)
-                gUnknown_03005000.unk_cd5[i] = 11;
-            rfu_clearSlot(4, i);
-        }
-    }
-}
-
-s32 sub_80107A0(void)
-{
-    s32 retval = 0;
-    if (gUnknown_03005000.unk_c85 == 8)
-    {
-        if (gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->send.state == 0x26 || gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->send.state == 0x27)
-            rfu_clearSlot(4, gUnknown_03005000.unk_c3e);
-    }
-    if (gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->recv.state == 0x46 || gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->recv.state == 0x48)
-    {
-        rfu_clearSlot(8, gUnknown_03005000.unk_c3e);
-        sub_8011A64(gUnknown_03005000.unk_c86, 0);
-        retval = gUnknown_03005000.unk_c86;
-    }
-    else if (gRfuSlotStatusNI[gUnknown_03005000.unk_c3e]->recv.state == 0x47)
-    {
-        rfu_clearSlot(8, gUnknown_03005000.unk_c3e);
-        retval = 6;
-    }
-    return retval;
-}
-
-void sub_801084C(u8 taskId)
-{
-    s32 i;
-
-    if (gUnknown_03005000.unk_f1 == 1 || gUnknown_03005000.unk_f1 == 2)
-    {
-        gUnknown_03005000.unk_ce8 = 0;
-        DestroyTask(taskId);
-    }
-    switch (gTasks[taskId].data[0])
-    {
-        case 0:
-            if (sub_800FC60())
-            {
-                ResetBlockReceivedFlags();
-                sub_800B348();
-                gTasks[taskId].data[0]++;
-            }
-            break;
-        case 1:
-            if (gUnknown_03005000.unk_0c == 1)
-            {
-                if (gReceivedRemoteLinkPlayers)
-                    sub_800FD14(0x7800);
-                else
-                    sub_800FD14(0x7700);
-                gTasks[taskId].data[0] = 101;
-            }
-            else
-                gTasks[taskId].data[0] = 2;
-            break;
-        case 101:
-            if (gSendCmd[0] == 0)
-                gTasks[taskId].data[0] = 2;
-            break;
-        case 2:
-            if (gUnknown_03005000.playerCount)
-                gTasks[taskId].data[0]++;
-            break;
-        case 3:
-            if (gUnknown_03005000.unk_0c == 1)
-            {
-                if (sub_800FC60())
-                {
-                    gUnknown_03005000.unk_5a = 0;
-                    sub_800FD14(0xa100);
-                    gTasks[taskId].data[0]++;
-                }
-            }
-            else
-                gTasks[taskId].data[0]++;
-            break;
-        case 4:
-            if (sub_800FC88())
-                gTasks[taskId].data[0]++;
-            break;
-        case 5:
-            for (i = 0; i < gUnknown_03005000.playerCount; i++)
-            {
-                sub_800B3A4(i);
-                sub_800F728(i);
-            }
-            gTasks[taskId].data[0]++;
-            break;
-        case 6:
-            DestroyTask(taskId);
-            gReceivedRemoteLinkPlayers = 1;
-            gUnknown_03005000.unk_ce8 = 0;
-            sub_800D550(1, 0x258);
-            if (gUnknown_03005000.unk_ce6)
-            {
-                for (i = 0; i < 4; i++)
-                {
-                    if ((gUnknown_03005000.unk_ce6 >> i) & 1)
-                    {
-                        gUnknown_03005000.unk_ce5 = 1 << i;
-                        gUnknown_03005000.unk_ce6 ^= (1 << i);
-                    }
-                }
-            }
-            break;
-    }
-}
-
-void sub_80109E8(u16 a0)
-{
-    s32 i;
-
-    for (i = 0; i < 4; i++)
-    {
-        if ((a0 >> i) & 1)
-            gUnknown_03005000.unk_cde[i] = 0;
-    }
-}
-
-void sub_8010A14(const struct UnkRfuStruct_8010A14 *a0)
-{
-    s32 i;
-    gUnknown_03005000.playerCount = a0->unk_0f;
-    for (i = 0; i < 4; i++)
-        gUnknown_03005000.unk_cde[i] = a0->unk_10[i];
-    for (i = 0; i < MAX_RFU_PLAYERS; i++)
-    {
-        gLinkPlayers[i] = a0->unk_14[i];
-        sub_800B524(gLinkPlayers + i);
-    }
-}
-
-void sub_8010A70(void *a0)
-{
-    if (strcmp(gUnknown_082ED7EC, a0) == 0)
-    {
-        sub_8010A14(a0);
-        CpuFill16(0, a0, sizeof(struct UnkRfuStruct_8010A14));
-        ResetBlockReceivedFlag(0);
-    }
-}
-
-void sub_8010AAC(u8 taskId)
-{
-    s32 i;
-    struct LinkPlayerBlock *r2;
-    struct UnkRfuStruct_8010A14 *r5;
-    u8 r4 = gUnknown_03005000.unk_cde[gUnknown_082ED68C[gUnknown_03005000.unk_ce9]];
-    if (gUnknown_03005000.unk_f1 == 1 || gUnknown_03005000.unk_f1 == 2)
-    {
-        gUnknown_03005000.unk_ce8 = 0;
-        DestroyTask(taskId);
-    }
-    switch (gTasks[taskId].data[0])
-    {
-        case 0:
-            if (gSendCmd[0] == 0)
-            {
-                ResetBlockReceivedFlag(r4);
-                sub_800FD14(0x7800);
-                gTasks[taskId].data[0]++;
-            }
-            break;
-        case 1:
-            if (gSendCmd[0] == 0)
-                gTasks[taskId].data[0]++;
-            break;
-        case 2:
-            if ((GetBlockReceivedStatus() >> r4) & 1)
-            {
-                ResetBlockReceivedFlag(r4);
-                r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4];
-                gLinkPlayers[r4] = r2->linkPlayer;
-                sub_800B524(gLinkPlayers + r4);
-                gTasks[taskId].data[0]++;
-            }
-            break;
-        case 3:
-            r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
-            memcpy(r5->unk_00, gUnknown_082ED7EC, sizeof gUnknown_082ED7EC);
-            r5->unk_0f = gUnknown_03005000.playerCount;
-            for (i = 0; i < 4; i++)
-                r5->unk_10[i] = gUnknown_03005000.unk_cde[i];
-            memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers);
-            gTasks[taskId].data[0]++;
-            // fallthrough
-        case 4:
-            r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
-            r5->unk_0f = gUnknown_03005000.playerCount;
-            for (i = 0; i < 4; i++)
-                r5->unk_10[i] = gUnknown_03005000.unk_cde[i];
-            memcpy(r5->unk_14, 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));
-                ResetBlockReceivedFlag(0);
-                gUnknown_03005000.unk_ce8 = 0;
-                if (gUnknown_03005000.unk_ce6)
-                {
-                    for (i = 0; i < 4; i++)
-                    {
-                        if ((gUnknown_03005000.unk_ce6 >> i) & 1)
-                        {
-                            gUnknown_03005000.unk_ce5 = 1 << i;
-                            gUnknown_03005000.unk_ce6 ^= (1 << i);
-                            gUnknown_03005000.unk_ce8 = 1;
-                            break;
-                        }
-                    }
-                }
-                DestroyTask(taskId);
-            }
-            break;
-    }
-}
-
-void sub_8010D0C(u8 taskId)
-{
-    if (gUnknown_03005000.unk_f1 == 1 || gUnknown_03005000.unk_f1 == 2)
-        DestroyTask(taskId);
-    switch (gTasks[taskId].data[0])
-    {
-        case 0:
-            if (gUnknown_03005000.playerCount)
-            {
-                sub_800B348();
-                SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock));
-                gTasks[taskId].data[0]++;
-            }
-            break;
-        case 1:
-            if (IsLinkTaskFinished())
-                gTasks[taskId].data[0]++;
-            break;
-        case 2:
-            if (GetBlockReceivedStatus() & 1)
-            {
-                sub_8010A14((const struct UnkRfuStruct_8010A14 *)gBlockRecvBuffer);
-                ResetBlockReceivedFlag(0);
-                gReceivedRemoteLinkPlayers = 1;
-                DestroyTask(taskId);
-            }
-            break;
-    }
-}
-
-void sub_8010DB4(void)
-{
-    if (gUnknown_03005000.unk_ee == 1 && gUnknown_03004140.unk_02 == 0)
-    {
-        if (gMain.callback2 == c2_mystery_gift_e_reader_run || gUnknown_03004140.unk_3c->unk_04)
-            gWirelessCommType = 2;
-        SetMainCallback2(CB2_LinkError);
-        gMain.savedCallback = CB2_LinkError;
-        sub_800AF18((gUnknown_03005000.unk_0a << 16) | (gUnknown_03005000.unk_10 << 8) | gUnknown_03005000.unk_12, gUnknown_03005000.unk_124.unk_8c2, gUnknown_03005000.unk_9e8.unk_232, sub_8011A74() == 2);
-        gUnknown_03005000.unk_ee = 2;
-        CloseLink();
-    }
-    else if (gUnknown_03005000.unk_9e8.unk_233 == 1 || gUnknown_03005000.unk_124.unk_8c3 == 1)
-    {
-        if (gUnknown_03004140.unk_02)
-            sub_800D630();
-        sub_8011A64(1, 0x7000);
-        sub_8011170(0x7000);
-    }
-}
-
-void rfu_REQ_recvData_then_sendData(void)
-{
-    if (gUnknown_03004140.unk_06 == 1)
-    {
-        rfu_REQ_recvData();
-        rfu_waitREQComplete();
-        rfu_REQ_sendData_wrapper(0);
-    }
-}
-
-bool32 sub_8010EC0(void)
-{
-    bool32 retval = FALSE;
-    gUnknown_03005000.unk_ccd = 0;
-    sub_800C54C(Random2());
-    if (gUnknown_03005000.unk_ef == 0)
-    {
-        switch (gUnknown_03005000.unk_0c)
-        {
-            case 1:
-                sub_800F0F8();
-                break;
-            case 0:
-                retval = sub_800F4F0();
-                break;
-            case 2:
-                rfu_REQ_recvData_then_sendData();
-                break;
-        }
-    }
-    return retval;
-}
-
-bool32 sub_8010F1C(void)
-{
-    bool32 retval = FALSE;
-    if (gUnknown_03005000.unk_ef == 0)
-    {
-        if (gUnknown_03005000.unk_0c == 1)
-            retval = sub_800F1E0();
-        sub_8010DB4();
-    }
-    return retval;
-}
-
-void sub_8010F48(void)
-{
-    StringCopy(gUnknown_02022B22, gSaveBlock2Ptr->playerName);
-}
-
-void sub_8010F60(void)
-{
-    memset(&gUnknown_02022B14, 0, 0xD);
-    sub_800DD94(&gUnknown_02022B14, 0, 0, 0);
-}
-
-void sub_8010F84(u8 a0, u32 a1, u32 a2)
-{
-    sub_800DD94(&gUnknown_02022B14, a0, a2, a1);
-}
-
-void sub_8010FA0(bool32 a0, bool32 a1)
-{
-    gUnknown_02022B14.unk_00.unk_00_4 = a0;
-    gUnknown_02022B14.unk_00.unk_00_5 = a1;
-}
-
-void sub_8010FCC(u32 type, u32 species, u32 level)
-{
-    gUnknown_02022B14.type = type;
-    gUnknown_02022B14.species = species;
-    gUnknown_02022B14.level = level;
-}
-
-u8 sub_801100C(s32 a0)
-{
-    u8 retval = 0x80;
-    retval |= (gLinkPlayers[a0].gender << 3);
-    retval |= (gLinkPlayers[a0].trainerId & 7);
-    return retval;
-}
-
-void sub_801103C(void)
-{
-    struct UnkLinkRfuStruct_02022B14 *r5 = &gUnknown_02022B14;
-    s32 i;
-
-    for (i = 1; i < GetLinkPlayerCount(); i++)
-        r5->unk_04[i - 1] = sub_801100C(i);
-}
-
-void sub_8011068(u8 a0)
-{
-    gUnknown_02022B14.unk_0a_7 = a0;
-    rfu_REQ_configGameData(0, 2, (const u8 *)&gUnknown_02022B14, gUnknown_02022B22);
-}
-
-void sub_8011090(u8 a0, u32 a1, u32 a2)
-{
-    if (a0)
-        sub_8010F84(a0, a1, a2);
-    rfu_REQ_configGameData(0, 2, (const u8 *)&gUnknown_02022B14, gUnknown_02022B22);
-}
-
-void sub_80110B8(u32 a0)
-{
-    s32 i;
-    u32 r5;
-    u32 r7;
-    s32 r8;
-
-    if (sub_800F7DC()->unk_0a_0 == 0x45)
-    {
-        r5 = 0;
-        r7 = 0;
-        r8 = gUnknown_03005000.unk_ce2 ^ gUnknown_03005000.unk_ce3;
-        for (i = 0; i < 4; i++)
-        {
-            if ((r8 >> i) & 1)
-            {
-                r7 |= ((0x80 | ((gLinkPlayers[gUnknown_03005000.unk_cde[i]].gender & 1) << 3) | (gLinkPlayers[gUnknown_03005000.unk_cde[i]].trainerId & 7)) << (r5 << 3));
-                r5++;
-                if (r5 == a0 - 1)
-                    break;
-            }
-        }
-        sub_8011090(0x45, r7, 0);
-    }
-}
-
-void sub_8011170(u32 a0)
-{
-    if (gUnknown_03005000.unk_ee == 0)
-    {
-        gUnknown_03005000.unk_10 = gUnknown_03004140.unk_14;
-        gUnknown_03005000.unk_12 = gUnknown_03004140.unk_16;
-        gUnknown_03005000.unk_0a = a0;
-        gUnknown_03005000.unk_ee = 1;
-    }
-}
-
-void sub_80111A0(void)
-{
-    gUnknown_03005000.unk_ee = 0;
-}
-
-void sub_80111B0(bool32 a0)
-{
-    if (!a0)
-        gUnknown_03005000.unk_ee = 0;
-    else
-        gUnknown_03005000.unk_ee = 4;
-}
-
-void sub_80111DC(void)
-{
-    sub_8011E94(gUnknown_03004140.unk_00, 1);
-    gUnknown_03005000.linkRfuCallback = NULL;
-}
-
-void sub_80111FC(void)
-{
-    gUnknown_03005000.linkRfuCallback = sub_80111DC;
-}
-
-void sub_801120C(u8 a0, u8 unused1)
-{
-    u8 i;
-    u8 r6 = 0;
-    switch (a0)
-    {
-    case 0x00:
-        gUnknown_03005000.unk_04 = 2;
-        break;
-    case 0x10:
-        break;
-    case 0x11:
-        sub_80115EC(gUnknown_03004140.unk_14);
-        for (i = 0; i < 4; i++)
-        {
-            if ((gUnknown_03004140.unk_14 >> i) & 1)
-            {
-                struct UnkLinkRfuStruct_02022B14 *structPtr = (void *)gRfuLinkStatus->partner[i].gname;
-                if (structPtr->unk_0a_0 == sub_800F7DC()->unk_0a_0)
-                {
-                    gUnknown_03005000.unk_cd1[i] = 0;
-                    gUnknown_03005000.unk_cd5[i] = 0;
-                    rfu_setRecvBuffer(0x20, i, gUnknown_03005000.unk_cd5 + i, 1);
-                }
-                else
-                {
-                    r6 |= (1 << i);
-                }
-            }
-        }
-        if (r6)
-        {
-            rfu_REQ_disconnect(r6);
-            rfu_waitREQComplete();
-        }
-        break;
-    case 0x12:
-        break;
-    case 0x13:
-        break;
-    case 0x14:
-        if (gUnknown_03005000.unk_ce7 != gUnknown_03004140.unk_00)
-        {
-            rfu_REQ_disconnect(gUnknown_03005000.unk_ce7 ^ gUnknown_03004140.unk_00);
-            rfu_waitREQComplete();
-        }
-        gUnknown_03005000.unk_04 = 0x11;
-        break;
-    case 0x31:
-        gUnknown_03005000.unk_f0 = 1;
-        break;
-    case 0x32:
-        gUnknown_03005000.unk_f0 = 3;
-        break;
-    case 0x30:
-    case 0x33:
-        gUnknown_03005000.unk_f0 = 4;
-        gUnknown_03005000.unk_ce2 &= ~gUnknown_03004140.unk_14;
-        if (gReceivedRemoteLinkPlayers == 1)
-        {
-            if (gUnknown_03005000.unk_ce2 == 0)
-                sub_8011170(a0);
-            else
-                sub_80111FC();
-        }
-        sub_8011A64(2, a0);
-        break;
-    case 0x34:
-        break;
-    case 0x42 ... 0x44:
-        break;
-    case 0xf3:
-        sub_8011A64(1, a0);
-        sub_8011170(a0);
-        gUnknown_03005000.unk_ef = 1;
-        break;
-    case 0xf0 ... 0xf2:
-    case 0xff:
-        sub_8011170(a0);
-        sub_8011A64(1, a0);
-        gUnknown_03005000.unk_cdb = 1;
-        break;
-    }
-}
-
-void sub_8011404(u8 a0, u8 unused1)
-{
-    switch (a0)
-    {
-    case 0x00:
-        gUnknown_03005000.unk_04 = 6;
-        break;
-    case 0x20:
-        gUnknown_03005000.unk_ccd = gUnknown_03004140.unk_14;
-        break;
-    case 0x21:
-        break;
-    case 0x22:
-        gUnknown_03005000.unk_c3e = gUnknown_03004140.unk_14;
-        break;
-    case 0x23:
-        sub_8011A64(2, a0);
-        break;
-    case 0x24:
-        gUnknown_03005000.unk_04 = 11;
-        gUnknown_03005000.unk_c85 = 0;
-        gUnknown_03005000.unk_c86 = 0;
-        rfu_setRecvBuffer(0x20, gUnknown_03005000.unk_c3e, &gUnknown_03005000.unk_c86, 1);
-        rfu_setRecvBuffer(0x10, gUnknown_03005000.unk_c3e, gUnknown_03005000.unk_c3f, 70);
-        break;
-    case 0x25:
-        sub_8011A64(2, 0x25);
-        break;
-    case 0x30:
-        gUnknown_03005000.unk_f0 = 2;
-        if (gUnknown_03005000.unk_c86 == 6)
-            break;
-    case 0x33:
-        if (gUnknown_03005000.unk_f0 != 2)
-            gUnknown_03005000.unk_f0 = 4;
-        if (gUnknown_03005000.unk_c86 != 9)
-            sub_8011A64(2, a0);
-        nullsub_5(gUnknown_082ED7FC, 5, 5);
-        if (gReceivedRemoteLinkPlayers == 1)
-            sub_8011170(a0);
-        break;
-    case 0x31:
-        gUnknown_03005000.unk_f0 = 1;
-        nullsub_5(gUnknown_082ED814, 5, 5);
-        break;
-    case 0x32:
-        gUnknown_03005000.unk_f0 = 3;
-        gUnknown_03005000.unk_c3c = 1;
-        break;
-    case 0x34:
-        break;
-    case 0x42 ... 0x44:
-        break;
-    case 0xF3:
-        sub_8011A64(1, a0);
-        sub_8011170(a0);
-        gUnknown_03005000.unk_ef = 1;
-        break;
-    case 0xF0 ... 0xF2:
-    case 0xFF:
-        sub_8011A64(1, a0);
-        sub_8011170(a0);
-        gUnknown_03005000.unk_cdb = 1;
-        break;
-    }
-}
-
-void sub_80115EC(s32 a0)
-{
-    s32 i;
-
-    for (i = 0; i < 4; i++)
-    {
-        if ((a0 >> i) & 1)
-        {
-            gUnknown_03005000.unk_cea[i] = 0;
-            gUnknown_03005000.unk_cee[i] = 0xFF;
-        }
-    }
-}
-
-u8 sub_8011628(s32 a0)
-{
-    u8 ret = 0;
-    u8 i;
-
-    for (i = 0; i < 4; i++)
-    {
-        if ((a0 >> i) & 1)
-        {
-            struct UnkLinkRfuStruct_02022B14 *structPtr = (void *)gRfuLinkStatus->partner[i].gname;
-            if (structPtr->unk_0a_0 == 0x45)
-                ret |= (1 << i);
-        }
-    }
-
-    return ret;
-}
-
-void sub_8011674(u8 a0, u8 unused1)
-{
-    u8 r1;
-
-    switch (a0)
-    {
-    case 0x00:
-        gUnknown_03005000.unk_04 = 0x11;
-        break;
-    case 0x10:
-        sub_8011A64(4, 0);
-        break;
-    case 0x11:
-        if (sub_800F7DC()->unk_0a_0 == 0x45 && gUnknown_03005000.unk_cd9 == 0)
-        {
-            u8 idx = sub_8011628(gUnknown_03004140.unk_14);
-            if (idx != 0)
-            {
-                r1 = 1 << sub_800E87C(idx);
-                if (gUnknown_03005000.unk_ce6 == 0 && gUnknown_03005000.unk_ce8 == 0)
-                {
-                    gUnknown_03005000.unk_ce5 = r1;
-                    gUnknown_03005000.unk_ce6 |= (r1 ^ idx);
-                    gUnknown_03005000.unk_ce8 = 1;
-                }
-                else
-                {
-                    gUnknown_03005000.unk_ce6 |= idx;
-                }
-            }
-            if (idx != gUnknown_03004140.unk_14)
-            {
-                gUnknown_03005000.unk_ce3 |= (idx ^ gUnknown_03004140.unk_14);
-                gUnknown_03005000.unk_ce4 = 2;
-            }
-        }
-        else if (sub_800F7DC()->unk_0a_0 == 0x54)
-        {
-            rfu_REQ_disconnect(gUnknown_03004140.unk_00);
-            rfu_waitREQComplete();
-        }
-        sub_80115EC(gUnknown_03004140.unk_14);
-        break;
-    case 0x12:
-        break;
-    case 0x13:
-        break;
-    case 0x14:
-        if (sub_800F7DC()->unk_0a_0 != 0x45 && gUnknown_03004140.unk_01 > 1)
-        {
-            r1 = 1 << sub_800E87C(gUnknown_03004140.unk_14);
-            rfu_REQ_disconnect(gUnknown_03004140.unk_00 ^ r1);
-            rfu_waitREQComplete();
-        }
-        if (gUnknown_03005000.unk_04 == 0xF)
-            gUnknown_03005000.unk_04 = 0x10;
-        break;
-        break;
-    case 0x20:
-        gUnknown_03005000.unk_ccd = gUnknown_03004140.unk_14;
-        break;
-    case 0x21:
-        break;
-    case 0x22:
-        gUnknown_03005000.unk_c3e = gUnknown_03004140.unk_14;
-        break;
-    case 0x23:
-        gUnknown_03005000.unk_04 = 0x12;
-        if (gUnknown_03005000.unk_ccf < 2)
-        {
-            gUnknown_03005000.unk_ccf++;
-            CreateTask(sub_801209C, 2);
-        }
-        else
-        {
-            sub_8011A64(2, a0);
-        }
-        break;
-    case 0x24:
-        gUnknown_03005000.unk_04 = 0xD;
-        sub_8011A64(3, 0);
-        rfu_setRecvBuffer(0x10, gUnknown_03005000.unk_c3e, gUnknown_03005000.unk_c3f, 70);
-        break;
-    case 0x25:
-        sub_8011A64(2, a0);
-        break;
-    case 0x31:
-        if (gUnknown_03004140.unk_00 & gUnknown_03004140.unk_14)
-            gUnknown_03005000.unk_f0 = 1;
-        break;
-    case 0x32:
-        gUnknown_03005000.unk_f0 = 3;
-        if (gRfuLinkStatus->parentChild == 0)
-            gUnknown_03005000.unk_c3c = 1;
-        break;
-    case 0x30:
-        gUnknown_03005000.unk_f0 = 2;
-    case 0x33:
-        if (gUnknown_03005000.unk_f0 != 2)
-            gUnknown_03005000.unk_f0 = 4;
-        if (gUnknown_03005000.unk_0c == 1)
-        {
-            if (gReceivedRemoteLinkPlayers == 1)
-            {
-                gUnknown_03005000.unk_ce2 &= ~(gUnknown_03004140.unk_14);
-                if (gUnknown_03005000.unk_ce2 == 0)
-                    sub_8011170(a0);
-                else
-                    sub_80111FC();
-            }
-        }
-        else if (gUnknown_03005000.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1)
-        {
-            sub_8011170(a0);
-            sub_800C27C(0);
-        }
-
-        if (gRfuLinkStatus->parentChild == 0xFF && gUnknown_03004140.unk_07 == 0 && FuncIsActiveTask(sub_800EB44) == TRUE)
-            gUnknown_03005000.unk_04 = 0x11;
-
-        sub_8011A64(2, a0);
-        break;
-    case 0x40:
-        gUnknown_03005000.unk_ce3 = 0;
-        break;
-    case 0x42 ... 0x44:
-        break;
-    case 0xF3:
-        sub_8011A64(1, a0);
-        sub_8011170(a0);
-        gUnknown_03005000.unk_ef = 1;
-        break;
-    case 0xF0 ... 0xF2:
-    case 0xFF:
-        sub_8011170(a0);
-        sub_8011A64(1, a0);
-        gUnknown_03005000.unk_cdb = 0;
-        break;
-    }
-}
-
-void sub_8011A50(void)
-{
-    gUnknown_03005000.unk_ce4 = 2;
-}
-
-void sub_8011A64(u8 a0, u16 a1)
-{
-    gUnknown_03005000.unk_f1 = a0;
-    gUnknown_03005000.unk_0a = a1;
-}
-
-u8 sub_8011A74(void)
-{
-    return gUnknown_03005000.unk_f1;
-}
-
-bool32 sub_8011A80(void)
-{
-    u32 var = sub_8011A74() - 1;
-    if (var < 2)
-        return TRUE;
-    else
-        return FALSE;
-}
-
-bool32 sub_8011A9C(void)
-{
-    return gUnknown_03005000.unk_ce8;
-}
-
-bool8 Rfu_IsMaster(void)
-{
-    return gUnknown_03005000.unk_0c;
-}
-
-void RfuVSync(void)
-{
-    rfu_syncVBlank_();
-}
-
-void sub_8011AC8(void)
-{
-    CpuFill32(0, gRecvCmds, sizeof(gRecvCmds));
-}
-
-void sub_8011AE8(void)
-{
-    LoadOam();
-    ProcessSpriteCopyRequests();
-    TransferPlttBuffer();
-}
-
-void sub_8011AFC(void)
-{
-    s32 i;
-
-    ResetSpriteData();
-    FreeAllSpritePalettes();
-    ResetTasks();
-    ResetPaletteFade();
-    SetVBlankCallback(sub_8011AE8);
-    if (IsWirelessAdapterConnected())
-    {
-        gLinkType = LINKTYPE_0x1111;
-        sub_800B488();
-        OpenLink();
-        SeedRng(gMain.vblankCounter2);
-        for (i = 0; i < 4; i++)
-            gSaveBlock2Ptr->playerTrainerId[i] = Random() % 256;
-
-        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG2_ON | DISPCNT_OBJ_1D_MAP);
-        RunTasks();
-        AnimateSprites();
-        BuildOamBuffer();
-        UpdatePaletteFade();
-        sub_8011BA4();
-        SetMainCallback2(sub_8011BF8);
-    }
-}
-
-bool32 sub_8011B90(void)
-{
-    return FuncIsActiveTask(sub_800EB44);
-}
-
-void sub_8011BA4(void)
-{
-    if (!FuncIsActiveTask(nullsub_89))
-        gUnknown_03005000.unk_66 = CreateTask(nullsub_89, 0);
-}
-
-void sub_8011BD0(void)
-{
-     if (FuncIsActiveTask(nullsub_89) == TRUE)
-        DestroyTask(gUnknown_03005000.unk_66);
-}
-
-void sub_8011BF8(void)
-{
-    RunTasks();
-    AnimateSprites();
-    BuildOamBuffer();
-    UpdatePaletteFade();
-}
-
-void sub_8011C10(u32 a0)
-{
-    gUnknown_03005000.unk_0c = 1;
-    sub_8010F48();
-    sub_800BF4C(sub_801120C, NULL);
-    gUnknown_02022B2C = gUnknown_082ED608;
-    gUnknown_02022B2C.unk_02 = gUnknown_082ED620[a0 - 1];
-    sub_800EE78();
-}
-
-void sub_8011C5C(void)
-{
-    gUnknown_03005000.unk_0c = 0;
-    sub_8010F48();
-    sub_800BF4C(sub_8011404, sub_800ED34);
-    sub_800EF00();
-}
-
-void sub_8011C84(void)
-{
-    gUnknown_03005000.unk_0c = 2;
-    sub_8010F48();
-    sub_800BF4C(sub_8011674, NULL);
-    gUnknown_02022B2C = gUnknown_082ED608;
-    gUnknown_02022B2C.unk_11 = 0;
-    gUnknown_02022B2C.unk_12 = 0x258;
-    gUnknown_03005000.unk_67 = CreateTask(sub_800EB44, 1);
-}
-
-static u16 ReadU16(const void *ptr)
-{
-    const u8 *ptr_ = ptr;
-    return (ptr_[1] << 8) | (ptr_[0]);
-}
-
-u8 sub_8011CE4(const u8 *a0, u16 a1)
-{
-    u8 i;
-    u8 ret = 0xFF;
-
-    for (i = 0; i < 4; i++)
-    {
-        u16 trainerId = ReadU16(gRfuLinkStatus->partner[i].gname + 2);
-        if (sub_8010454(gRfuLinkStatus->partner[i].serialNo)
-            && !StringCompare(a0, gRfuLinkStatus->partner[i].uname)
-            && a1 == trainerId)
-        {
-            ret = i;
-            if (gRfuLinkStatus->partner[i].slot != 0xFF)
-                break;
-        }
-    }
-
-    return ret;
-}
-
-void sub_8011D6C(u32 a0)
-{
-    rfu_REQ_disconnect(a0);
-    rfu_waitREQComplete();
-    gUnknown_03005000.unk_ce2 &= ~(a0);
-    rfu_clearSlot(1, gUnknown_03005000.unk_cda);
-    rfu_UNI_setSendData(gUnknown_03005000.unk_ce2, gUnknown_03005000.unk_c87, 70);
-    gUnknown_03005000.unk_cda = sub_800E87C(gUnknown_03005000.unk_ce2);
-}
-
-void sub_8011DC0(const u8 *ptr, u16 a1)
-{
-    u8 var = sub_8011CE4(ptr, a1);
-    if (var != 0xFF)
-        sub_8011D6C(1 << var);
-}
-
-void sub_8011DE0(u32 a0)
-{
-    if (a0 != 0)
-    {
-        s32 i;
-        u8 var = 0;
-
-        for (i = 0; i < 4; i++)
-        {
-            if (gUnknown_03005000.unk_cde[i] == a0 && (gUnknown_03005000.unk_ce2 >> i) & 1)
-                var |= 1 << i;
-        }
-        if (var)
-            sub_8011E94(var, 2);
-    }
-}
-
-void sub_8011E2C(u8 taskId)
-{
-    if (gSendCmd[0] == 0 && gUnknown_03005000.unk_ce8 == 0)
-    {
-        sub_800FD14(0xED00);
-        gSendCmd[1] = gTasks[taskId].data[0];
-        gSendCmd[2] = gTasks[taskId].data[1];
-        gUnknown_03005000.playerCount -= gUnknown_082ED695[gTasks[taskId].data[0]];
-        gSendCmd[3] = gUnknown_03005000.playerCount;
-        DestroyTask(taskId);
-    }
-}
-
-void sub_8011E94(u32 a0, u32 a1)
-{
-    u8 taskId = FindTaskIdByFunc(sub_8011E2C);
-    if (taskId == 0xFF)
-    {
-        taskId = CreateTask(sub_8011E2C, 5);
-        gTasks[taskId].data[0] = a0;
-    }
-    else
-    {
-        gTasks[taskId].data[0] |= a0;
-    }
-
-    gTasks[taskId].data[1] = a1;
-}
-
-void sub_8011EF4(u8 taskId)
-{
-    s16 *data = gTasks[taskId].data;
-
-    if (sub_800EE94())
-    {
-        u8 id = sub_8011CE4((u8*)data, ReadU16(&data[8]));
-        if (id != 0xFF)
-        {
-            if (gRfuLinkStatus->partner[id].slot != 0xFF)
-            {
-                gUnknown_03005000.unk_c3d = id;
-                if (sub_800EEBC())
-                    DestroyTask(taskId);
-            }
-            else if (sub_800F7DC()->unk_0a_0 == 0x15 || sub_800F7DC()->unk_0a_0 == 0x16)
-            {
-                data[15]++;
-            }
-            else
-            {
-                sub_8011A64(2, 0x7000);
-                DestroyTask(taskId);
-            }
-        }
-        else
-        {
-            data[15]++;
-            gUnknown_03005000.unk_c3d = id;
-        }
-    }
-    else
-    {
-        data[15]++;
-    }
-
-    if (data[15] > 240)
-    {
-        sub_8011A64(2, 0x7000);
-        DestroyTask(taskId);
-    }
-}
-
-void sub_8011FC8(const u8 *src, u16 trainerId)
-{
-    u8 taskId;
-    s16 *data;
-
-    gUnknown_03005000.unk_f1 = 0;
-    taskId = CreateTask(sub_8011EF4, 3);
-    data = gTasks[taskId].data;
-    StringCopy((u8*)(data), src);
-    data[8] = trainerId;
-}
-
-bool32 sub_801200C(s16 a1, struct UnkLinkRfuStruct_02022B14 *structPtr)
-{
-    if (sub_800F7DC()->unk_0a_0 == 0x45)
-    {
-        if (structPtr->unk_0a_0 != 0x45)
-            return TRUE;
-    }
-    else if (structPtr->unk_0a_0 != 0x40)
-    {
-        return TRUE;
-    }
-    else if (a1 == 0x44)
-    {
-        struct UnkLinkRfuStruct_02022B14 *structPtr2 = &gUnknown_03005000.unk_10A;
-        if (structPtr2->species == SPECIES_EGG)
-        {
-            if (structPtr->species == structPtr2->species)
-                return FALSE;
-            else
-                return TRUE;
-        }
-        else if (structPtr->species != structPtr2->species
-                 || structPtr->level != structPtr2->level
-                 || structPtr->type != structPtr2->type)
-        {
-            return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-
-void sub_801209C(u8 taskId)
-{
-    if (gUnknown_03005000.unk_f1 == 4)
-        DestroyTask(taskId);
-
-    if (++gTasks[taskId].data[0] > 300)
-    {
-        sub_8011A64(2, 0x7000);
-        DestroyTask(taskId);
-    }
-
-    if (gUnknown_03005000.unk_ccd != 0 && gUnknown_03004140.unk_06 == 0)
-    {
-        u16 trainerId = ReadU16(gUnknown_03005000.unk_10A.unk_00.playerTrainerId);
-        u8 id = sub_8011CE4(gUnknown_03005000.playerName, trainerId);
-        if (id != 0xFF)
-        {
-            if (!sub_801200C(gTasks[taskId].data[1], (void *)gRfuLinkStatus->partner[id].gname))
-            {
-                if (gRfuLinkStatus->partner[id].slot != 0xFF && !sub_800C12C(gRfuLinkStatus->partner[id].id, 0x5A))
-                {
-                    gUnknown_03005000.unk_04 = 0xA;
-                    DestroyTask(taskId);
-                }
-            }
-            else
-            {
-                sub_8011A64(2, 0x7000);
-                DestroyTask(taskId);
-            }
-        }
-    }
-}
-
-void sub_8012188(const u8 *name, struct UnkLinkRfuStruct_02022B14 *structPtr, u8 a2)
-{
-    u8 taskId, taskId2;
-
-    gUnknown_03005000.unk_ccf = 0;
-    gUnknown_03005000.unk_f1 = 0;
-    StringCopy(gUnknown_03005000.playerName, name);
-    memcpy(&gUnknown_03005000.unk_10A, structPtr, 0xD);
-    sub_800D658();
-    taskId = CreateTask(sub_801209C, 2);
-    gTasks[taskId].data[1] = a2;
-    taskId2 = FindTaskIdByFunc(sub_800EB44);
-    if (a2 == 0x45)
-    {
-        if (taskId2 != 0xFF)
-            gTasks[taskId2].data[7] = 1;
-    }
-    else
-    {
-        if (taskId2 != 0xFF)
-            gTasks[taskId2].data[7] = 0;
-    }
-}
-
-bool8 sub_8012224(void)
-{
-    if (gUnknown_03005000.unk_f0 == 1)
-        return TRUE;
-    else
-        return FALSE;
-}
-
-bool32 sub_8012240(void)
-{
-    s32 i;
-
-    for (i = 0; i < 4; i++)
-    {
-        if ((gUnknown_03004140.unk_00 >> i) & 1 && gUnknown_03005000.unk_cd1[i] == 0)
-            return FALSE;
-    }
-
-    return TRUE;
-}
-
-void sub_801227C(void)
-{
-    s32 i;
-
-    for (i = 0; i < 20; i++)
-        nullsub_5(gUnknown_082ED82C, 0, i);
-}
-
-void sub_801229C(void)
-{
-    s32 i, j;
-
-    nullsub_13(GetBlockReceivedStatus(), 0x1C, 0x13, 2);
-    nullsub_13(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1);
-    nullsub_13(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1);
-    if (gUnknown_03005000.unk_0c == 1)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            if ((gRfuLinkStatus->getNameFlag >> i) & 1)
-            {
-                nullsub_13(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
-                nullsub_5((void*)gRfuLinkStatus->partner[i].gname, 6, i + 3);
-                nullsub_5(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
-            }
-        }
-        for (i = 0; i < 4; i++)
-        {
-            for (j = 0; j < 14; j++)
-            {
-                nullsub_13(gUnknown_03005000.unk_14[i][j], j * 2, i + 11, 2);
-            }
-        }
-        nullsub_5(gUnknown_082ED868, 1, 0xF);
-    }
-    else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            nullsub_13(0, 1, i + 3, 4);
-            nullsub_5(gUnknown_082ED84B, 6, i + 3);
-            nullsub_5(gUnknown_082ED85B, 0x16, i + 3);
-        }
-        nullsub_13(gRfuLinkStatus->partner[gUnknown_03005000.unk_c3e].serialNo, 1, 3, 4);
-        nullsub_5((void*)gRfuLinkStatus->partner[gUnknown_03005000.unk_c3e].gname, 6, 3);
-        nullsub_5(gRfuLinkStatus->partner[gUnknown_03005000.unk_c3e].uname, 0x16, 3);
-    }
-    else
-    {
-        for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
-        {
-            if (gRfuLinkStatus->partner[i].slot != 0xFF)
-            {
-                nullsub_13(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
-                nullsub_13(gRfuLinkStatus->partner[i].id, 6, i + 3, 4);
-                nullsub_5(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
-            }
-        }
-        for (; i < 4; i++)
-        {
-            nullsub_13(0, 1, i + 3, 4);
-            nullsub_5(gUnknown_082ED84B, 6, i + 3);
-            nullsub_5(gUnknown_082ED85B, 0x16, i + 3);
-        }
-    }
-}
-
-u32 sub_80124C0(void)
-{
-    return gUnknown_03005000.unk_9e8.unk_232;
-}
-
-u32 GetRfuRecvQueueLength(void)
-{
-    return gUnknown_03005000.unk_124.unk_8c2;
-}
diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c
new file mode 100644
index 000000000..bef398525
--- /dev/null
+++ b/src/link_rfu_2.c
@@ -0,0 +1,2813 @@
+#include "global.h"
+#include "malloc.h"
+#include "battle.h"
+#include "berry_blender.h"
+#include "decompress.h"
+#include "event_data.h"
+#include "gpu_regs.h"
+#include "librfu.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "overworld.h"
+#include "random.h"
+#include "palette.h"
+#include "union_room.h"
+#include "string_util.h"
+#include "task.h"
+#include "text.h"
+#include "constants/species.h"
+#include "save.h"
+#include "mystery_gift.h"
+
+extern u16 gHeldKeyCodeToSend;
+
+u32 gf_rfu_REQ_api[RFU_API_BUFF_SIZE_RAM / 4];
+struct UnkRfuStruct_2 Rfu;
+
+BSS_DATA u8 gUnknown_03000D78[8];
+BSS_DATA u8 gUnknown_03000D80[16];
+BSS_DATA u16 gUnknown_03000D90[8];
+
+EWRAM_DATA struct GFtgtGname gUnknown_02022B14 = {};
+EWRAM_DATA ALIGNED(2) u8 gUnknown_02022B22[RFU_USER_NAME_LENGTH] = {};
+EWRAM_DATA INIT_PARAM gUnknown_02022B2C = {};
+EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_02022B44 = {};
+
+// Static ROM declarations
+
+// .rodata
+
+const INIT_PARAM gUnknown_082ED608 = {
+    0x04, 0x20, 0x00, 0x00, 0x02,
+    (u8 *)&gUnknown_02022B14,
+    gUnknown_02022B22,
+    0x01, 0x00, 0x258, 0x12c
+};
+const u8 gUnknown_082ED620[] = {
+    0, 3, 2, 1, 0
+};
+const u32 gUnknown_082ED628[] = {
+    0x000000,
+    0x000001,
+    0x000003,
+    0x000007,
+    0x00000f,
+    0x00001f,
+    0x00003f,
+    0x00007f,
+    0x0000ff,
+    0x0001ff,
+    0x0003ff,
+    0x0007ff,
+    0x000fff,
+    0x001fff,
+    0x003fff,
+    0x007fff,
+    0x00ffff,
+    0x01ffff,
+    0x03ffff,
+    0x07ffff,
+    0x0fffff,
+    0x1fffff,
+    0x3fffff,
+    0x7fffff,
+    0xffffff
+};
+const u8 gUnknown_082ED68C[] = {
+    0, 0, 1,
+    1, 2, 2,
+    2, 2, 3
+};
+const u8 gUnknown_082ED695[] = {
+    0, 1, 1, 2,
+    1, 2, 2, 3,
+    1, 2, 2, 3,
+    2, 3, 3, 4
+};
+const u8 gUnknown_082ED6A5[] = {
+    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
+};
+const struct {
+    u8 *buffer;
+    u32 size;
+} gUnknown_082ED6B8[] = {
+    { gBlockSendBuffer, 200 },
+    { gBlockSendBuffer, 200 },
+    { gBlockSendBuffer, 100 },
+    { gBlockSendBuffer, 220 },
+    { gBlockSendBuffer,  40 }
+};
+const u16 gUnknown_082ED6E0[] = {
+    0x0002, 0x7f7d, 0x0000, 0xFFFF
+};
+
+const char sUnref_082ED6E8[][15] = {
+    "RFU WAIT",
+    "RFU BOOT",
+    "RFU ERROR",
+    "RFU RESET",
+    "RFU CONFIG",
+    "RFU START",
+    "RFU SC POLL",
+    "RFU SP POLL",
+    "RFU START",
+    "RFU SEND ERR",
+    "RFU CP POLL"
+};
+const char sUnref_082ED6E9[][16] = {
+    "              ",
+    "RECOVER START ",
+    "DISSCONECT    ",
+    "RECOVER SUUSES",
+    "RECOVER FAILED"
+};
+const TaskFunc gUnknown_082ED7E0[] = {
+    sub_801084C,
+    sub_8010AAC,
+    sub_8010D0C
+};
+const char gUnknown_082ED7EC[] = "PokemonSioInfo";
+const char gUnknown_082ED7FC[] = "LINK LOSS DISCONNECT!";
+const char gUnknown_082ED814[] = "LINK LOSS RECOVERY NOW";
+
+ALIGNED(4) const char gUnknown_082ED82C[31] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',0x00};
+const char gUnknown_082ED84B[16] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',0x00};
+const char gUnknown_082ED85B[9] = {' ',' ',' ',' ',' ',' ',' ',' ',0x00};
+ALIGNED(4) const char gUnknown_082ED864[2] = {' ',0x00};
+const char gUnknown_082ED866[2] = {'*',0x00};
+const char gUnknown_082ED868[8] = "NOWSLOT";
+const char gUnknown_082ED870[12] = "           ";
+const char gUnknown_082ED87C[12] = "CLOCK DRIFT";
+const char gUnknown_082ED888[12] = "BUSY SEND  ";
+const char gUnknown_082ED894[12] = "CMD REJECT ";
+const char gUnknown_082ED8A0[12] = "CLOCK SLAVE";
+const char gUnknown_082ED8A8[3][8] = {
+    "CHILD ",
+    "PARENT",
+    "SEARCH"
+};
+
+// .text
+
+void nullsub_5(const void *unused_0, u8 unused_1, u8 unused_2)
+{
+    // debug?
+}
+
+void nullsub_13(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3)
+{
+
+}
+
+void sub_800E604(void)
+{
+    s32 i;
+    u8 unk_ee_bak = Rfu.unk_ee;
+    CpuFill16(0, &Rfu, sizeof Rfu);
+    Rfu.unk_ee = unk_ee_bak;
+    Rfu.unk_0c = 0xFF;
+    if (Rfu.unk_ee != 4)
+    {
+        Rfu.unk_ee = 0;
+    }
+    for (i = 0; i < 5; i++)
+    {
+        sub_800FCC4(Rfu.unk_80 + i);
+    }
+    sub_800FCC4(&Rfu.unk_6c);
+    sub_800D6C8(&Rfu.unk_124);
+    sub_800D724(&Rfu.unk_9e8);
+    CpuFill16(0, gSendCmd, sizeof gSendCmd);
+    CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
+    CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers);
+}
+
+void sub_800E6D0(void)
+{
+    IntrFunc serialIntr = gIntrTable[1];
+    IntrFunc timerIntr = gIntrTable[2];
+    sub_800E700();
+    rfu_REQ_stopMode();
+    rfu_waitREQComplete();
+    REG_IME = 0;
+    gIntrTable[1] = serialIntr;
+    gIntrTable[2] = timerIntr;
+    REG_IME = INTR_FLAG_VBLANK;
+}
+
+void sub_800E700(void)
+{
+    if (!rfu_initializeAPI((void *)gf_rfu_REQ_api, sizeof gf_rfu_REQ_api, gIntrTable + 1, TRUE))
+    {
+        gLinkType = 0;
+        sub_800AAF4();
+        sub_80111B0(0);
+        sub_800E604();
+        rfu_setTimerInterrupt(3, gIntrTable + 2);
+    }
+}
+
+void sub_800E748(u8 taskId)
+{
+    sub_8010750();
+    switch (Rfu.unk_04)
+    {
+        case 0:
+            rfu_LMAN_initializeRFU(&gUnknown_02022B2C);
+            Rfu.unk_04 = 1;
+            gTasks[taskId].data[1] = 1;
+            break;
+        case 1:
+            break;
+        case 2:
+            rfu_LMAN_establishConnection(Rfu.unk_0c, 0, 240, (u16 *)gUnknown_082ED6E0);
+            Rfu.unk_04 = 3;
+            gTasks[taskId].data[1] = 6;
+            break;
+        case 3:
+            break;
+        case 4:
+            rfu_LMAN_stopManager(FALSE);
+            Rfu.unk_04 = 5;
+            break;
+        case 5:
+            break;
+        case 18:
+            Rfu.unk_cdb = 0;
+            rfu_LMAN_setMSCCallback(sub_800EDBC);
+            sub_800EAB4();
+            sub_800EAFC();
+            Rfu.unk_04 = 20;
+            gTasks[taskId].data[1] = 8;
+            CreateTask(sub_801084C, 5);
+            DestroyTask(taskId);
+            break;
+    }
+}
+
+s32 sub_800E87C(u8 idx)
+{
+    return gUnknown_082ED6A5[idx];
+}
+
+void sub_800E88C(s32 r2, s32 r5)
+{
+    u8 i;
+    u8 r4 = 1;
+    s32 r1 = r2;
+    s32 r6 = 0;
+    if (r5 == -1)
+    {
+        for (i = 0; i < 4; r2 >>= 1, i++)
+        {
+            if (r2 & 1)
+            {
+                Rfu.unk_cde[i] = r4;
+                r4++;
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < 4; r1 >>= 1, i++)
+        {
+            if (!(r1 & 1))
+            {
+                Rfu.unk_cde[i] = 0;
+            }
+        }
+        for (r4 = 4; r4 != 0; r4--)
+        {
+            for (i = 0; i < 4 && Rfu.unk_cde[i] != r4; i++);
+            if (i == 4)
+            {
+                r6 = r4;
+            }
+        }
+        for (r5 &= ~r2, i = 0; i < 4; r5 >>= 1, i++)
+        {
+            if (r5 & 1)
+            {
+                Rfu.unk_cde[i] = r6++;
+            }
+        }
+    }
+}
+
+void sub_800E94C(u8 taskId)
+{
+    switch (Rfu.unk_04)
+    {
+        case 0:
+            rfu_LMAN_initializeRFU((INIT_PARAM *)&gUnknown_082ED608);
+            Rfu.unk_04 = 1;
+            gTasks[taskId].data[1] = 1;
+            break;
+        case 1:
+            break;
+        case 6:
+            rfu_LMAN_establishConnection(Rfu.unk_0c, 0, 0xf0, (u16 *)gUnknown_082ED6E0);
+            Rfu.unk_04 = 7;
+            gTasks[taskId].data[1] = 7;
+            break;
+        case 7:
+            break;
+        case 9:
+            gTasks[taskId].data[1] = 10;
+            break;
+        case 11:
+            switch (sub_80107A0())
+            {
+                case 5:
+                    Rfu.unk_04 = 12;
+                    break;
+                case 6:
+                case 9:
+                    rfu_LMAN_requestChangeAgbClockMaster();
+                    Rfu.unk_ce4 = 2;
+                    DestroyTask(taskId);
+                    break;
+            }
+            break;
+        case 12:
+        {
+            u8 r5 = 1 << Rfu.unk_c3e;
+            rfu_clearSlot(12, Rfu.unk_c3e);
+            rfu_setRecvBuffer(16, Rfu.unk_c3e, Rfu.unk_c3f, 70);
+            rfu_UNI_setSendData(r5, Rfu.unk_4c, 14);
+            gTasks[taskId].data[1] = 8;
+            DestroyTask(taskId);
+            if (gUnknown_02022B44.unk_0f == 0)
+            {
+                sub_801227C();
+                gUnknown_02022B44.unk_0f++;
+            }
+            CreateTask(sub_801084C, 5);
+            break;
+        }
+    }
+}
+
+void sub_800EAB4(void)
+{
+    u8 i;
+    u8 r5 = lman.acceptSlot_flag;
+    for (i = 0; i < 4; i++)
+    {
+        if (r5 & 1)
+        {
+            rfu_setRecvBuffer(16, i, Rfu.unk_14[i], 14);
+            rfu_clearSlot(3, i);
+        }
+        r5 >>= 1;
+    }
+}
+
+void sub_800EAFC(void)
+{
+    u8 r5 = lman.acceptSlot_flag;
+    rfu_UNI_setSendData(r5, Rfu.unk_c87, 70);
+    Rfu.unk_cda = sub_800E87C(r5);
+    Rfu.unk_ce2 = r5;
+    sub_800E88C(r5, -1);
+    Rfu.unk_0c = 1;
+}
+
+void sub_800EB44(u8 taskId)
+{
+    if (sub_800F7DC()->activity == 0x54 && sub_8011A74() == 4)
+    {
+        rfu_REQ_disconnect(lman.acceptSlot_flag);
+        rfu_waitREQComplete();
+        sub_8011A64(0, 0);
+    }
+    switch (Rfu.unk_04)
+    {
+        case 0:
+            rfu_LMAN_initializeRFU(&gUnknown_02022B2C);
+            Rfu.unk_04 = 1;
+            gTasks[taskId].data[1] = 1;
+            break;
+        case 1:
+            break;
+        case 17:
+            rfu_LMAN_establishConnection(2, 0, 240, (u16 *)gUnknown_082ED6E0);
+            rfu_LMAN_setMSCCallback(sub_800ED34);
+            Rfu.unk_04 = 18;
+            break;
+        case 18:
+            break;
+        case 13:
+            if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, 14) == 0)
+            {
+                Rfu.unk_0c = 0;
+                DestroyTask(taskId);
+                if (gTasks[taskId].data[7])
+                {
+                    CreateTask(sub_8010D0C, 1);
+                }
+                else
+                {
+                    CreateTask(sub_801084C, 5);
+                }
+            }
+            break;
+        case 14:
+            rfu_LMAN_stopManager(0);
+            Rfu.unk_04 = 15;
+            break;
+        case 15:
+            break;
+        case 16:
+            Rfu.unk_cdb = 0;
+            rfu_LMAN_setMSCCallback(sub_800EDBC);
+            sub_8011068(1);
+            sub_800EAB4();
+            sub_800EAFC();
+            Rfu.unk_04 = 20;
+            gTasks[taskId].data[1] = 8;
+            Rfu.unk_0c = 1;
+            CreateTask(sub_801084C, 5);
+            Rfu.unk_ce8 = 1;
+            DestroyTask(taskId);
+            break;
+    }
+}
+
+void sub_800ED10(void)
+{
+    rfu_LMAN_establishConnection(1, 0, 240, (u16 *)gUnknown_082ED6E0);
+}
+
+void sub_800ED28(void)
+{
+    rfu_LMAN_stopManager(FALSE);
+}
+
+void sub_800ED34(u16 unused)
+{
+    s32 i;
+
+    for (i = 0; i < 14; i++)
+    {
+        Rfu.unk_4c[i] = 0;
+    }
+    rfu_REQ_recvData();
+    rfu_waitREQComplete();
+    if (gRfuSlotStatusUNI[Rfu.unk_c3e]->recv.newDataFlag)
+    {
+        Rfu.unk_cd0++;
+        sub_800D7D8(&Rfu.unk_124, Rfu.unk_c3f);
+        gUnknown_02022B44.unk_06++;
+        sub_800F048();
+        rfu_UNI_readySendData(Rfu.unk_c3e);
+        rfu_UNI_clearRecvNewDataFlag(Rfu.unk_c3e);
+    }
+    rfu_LMAN_REQ_sendData(1);
+}
+
+void sub_800EDBC(u16 unused)
+{
+    Rfu.unk_cdb = 1;
+}
+
+void sub_800EDD4(void)
+{
+    u8 i;
+
+    rfu_LMAN_powerDownRFU();
+    if (Rfu.unk_0c == 1)
+    {
+        if (FuncIsActiveTask(sub_800E748) == TRUE)
+        {
+            DestroyTask(Rfu.unk_67);
+            sub_800E604();
+        }
+    }
+    else if (Rfu.unk_0c == 0)
+    {
+        if (FuncIsActiveTask(sub_800E94C) == TRUE)
+        {
+            DestroyTask(Rfu.unk_67);
+            sub_800E604();
+        }
+    }
+    else if (Rfu.unk_0c == 2)
+    {
+        if (FuncIsActiveTask(sub_800EB44) == TRUE)
+        {
+            DestroyTask(Rfu.unk_67);
+            sub_800E604();
+        }
+    }
+    for (i = 0; i < 3; i++)
+    {
+        if (FuncIsActiveTask(gUnknown_082ED7E0[i]) == TRUE)
+        {
+            DestroyTask(FindTaskIdByFunc(gUnknown_082ED7E0[i]));
+        }
+    }
+}
+
+void sub_800EE78(void)
+{
+    Rfu.unk_67 = CreateTask(sub_800E748, 1);
+}
+
+bool8 sub_800EE94(void)
+{
+    if (Rfu.unk_04 == 7 && Rfu.unk_ccd)
+    {
+        return TRUE;
+    }
+    return FALSE;
+}
+
+bool32 sub_800EEBC(void)
+{
+    if (Rfu.unk_04 == 7 && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[Rfu.unk_c3d].id, 240))
+    {
+        Rfu.unk_04 = 9;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_800EF00(void)
+{
+    Rfu.unk_67 = CreateTask(sub_800E94C, 1);
+}
+
+bool8 sub_800EF1C(void)
+{
+    if (lman.acceptSlot_flag)
+    {
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_800EF38(void)
+{
+    Rfu.unk_04 = 4;
+    Rfu.unk_ce7 = lman.acceptSlot_flag;
+}
+
+bool32 sub_800EF58(bool32 a0)
+{
+    if (Rfu.unk_04 == 17 || a0)
+    {
+        Rfu.unk_04 = 18;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_800EF7C(void)
+{
+    Rfu.unk_04 = 14;
+}
+
+void sub_800EF88(u8 a0)
+{
+    u8 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if (a0 & 1)
+        {
+            rfu_UNI_readySendData(i);
+            break;
+        }
+        a0 >>= 1;
+    }
+}
+
+void sub_800EFB0(void)
+{
+    s32 i, j;
+
+    for (i = 0; i < 5; i++)
+    {
+        struct UnkRfuStruct_2 *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];
+        }
+    }
+    CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
+}
+
+void sub_800F014(void)
+{
+    s32 i;
+    for (i = 0; i < 7; i++)
+    {
+        gRecvCmds[0][i] = gSendCmd[i];
+    }
+    for (i = 0; i < 7; i++)
+    {
+        gSendCmd[i] = 0;
+    }
+}
+
+void sub_800F048(void)
+{
+    if (Rfu.unk_c3c)
+    {
+        u8 r2 = sub_800DAC8(&Rfu.unk_c1c, Rfu.unk_4c);
+        if (Rfu.unk_c1c.unk_1e == 0)
+        {
+            Rfu.unk_c3c = 0;
+        }
+        if (r2)
+        {
+            return;
+        }
+    }
+    if (Rfu.unk_c3c == 0)
+    {
+        sub_800D9DC(&Rfu.unk_9e8, Rfu.unk_4c);
+        sub_800DA68(&Rfu.unk_c1c, Rfu.unk_4c);
+    }
+}
+
+bool32 IsRfuRecvQueueEmpty(void)
+{
+    s32 i;
+    s32 j;
+
+    if (gRfuLinkStatus->sendSlotUNIFlag == 0)
+    {
+        return FALSE;
+    }
+    for (i = 0; i < 5; i++)
+    {
+        for (j = 0; j < 7; j++)
+        {
+            if (gRecvCmds[i][j] != 0)
+            {
+                return FALSE;
+            }
+        }
+    }
+    return TRUE;
+}
+
+bool32 sub_800F0F8(void)
+{
+    if (Rfu.unk_04 < 20)
+    {
+        rfu_REQ_recvData();
+        rfu_waitREQComplete();
+        rfu_LMAN_REQ_sendData(0);
+    }
+    else
+    {
+        Rfu.unk_cdb = 0;
+        if ((Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag) == Rfu.unk_ce2 && (Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag))
+        {
+            if (!Rfu.unk_cdc)
+            {
+                if (Rfu.unk_ce3)
+                {
+                    sub_8011D6C(Rfu.unk_ce3);
+                    Rfu.unk_ce3 = 0;
+                    if (Rfu.unk_ce4 == 1)
+                    {
+                        sub_8011A64(2, 0x8000);
+                        sub_8011170(0x8000);
+                        return FALSE;
+                    }
+                    if (!lman.acceptSlot_flag)
+                    {
+                        sub_800EDD4();
+                        gReceivedRemoteLinkPlayers = 0;
+                        return FALSE;
+                    }
+                }
+                sub_800EFB0();
+                rfu_UNI_readySendData(Rfu.unk_cda);
+                rfu_LMAN_REQ_sendData(1);
+            }
+            else
+            {
+                rfu_REQ_PARENT_resumeRetransmitAndChange();
+            }
+            Rfu.unk_0e = 1;
+        }
+    }
+    return FALSE;
+}
+
+bool32 sub_800F1E0(void)
+{
+    u16 i;
+    u16 flags;
+    u8 r0;
+    u16 j;
+    u8 retval;
+
+    if (Rfu.unk_04 >= 20 && Rfu.unk_0e == 1)
+    {
+        rfu_waitREQComplete();
+        while (Rfu.unk_cdb == 0)
+        {
+            if (Rfu.unk_ee != 0)
+            {
+                return FALSE;
+            }
+        }
+        rfu_REQ_recvData();
+        rfu_waitREQComplete();
+        if ((lman.parentAck_flag & Rfu.unk_ce2) == Rfu.unk_ce2)
+        {
+            Rfu.unk_cdc = 0;
+            gUnknown_02022B44.unk_06++;
+            flags = lman.acceptSlot_flag;
+            for (i = 0; i < 4; i++)
+            {
+                if (flags & 1)
+                {
+                    if (Rfu.unk_14[i][1])
+                    {
+                        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_8011170(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];
+                            for (j = 0; j < 7; j++)
+                            {
+                                gRecvCmds[r0][j] = (Rfu.unk_14[i][(j << 1) + 1] << 8) | Rfu.unk_14[i][(j << 1) + 0];
+                                Rfu.unk_14[i][(j << 1) + 1] = 0;
+                                Rfu.unk_14[i][(j << 1) + 0] = 0;
+                            }
+                        }
+                    }
+                    rfu_UNI_clearRecvNewDataFlag(i);
+                }
+                flags >>= 1;
+            }
+            sub_800F014();
+            sub_800F86C(0);
+            sub_8010528();
+            if (Rfu.unk_ce5 && !Rfu.unk_cd9)
+            {
+                gUnknown_02022B44.unk_0e = 0;
+                rfu_clearSlot(3, Rfu.unk_cda);
+                for (i = 0; i < 4; i++)
+                {
+                    if ((Rfu.unk_ce5 >> i) & 1)
+                    {
+                        rfu_setRecvBuffer(0x10, i, Rfu.unk_14[i], 14);
+                    }
+                }
+                sub_800E88C(Rfu.unk_ce2, Rfu.unk_ce2 | Rfu.unk_ce5);
+                Rfu.unk_ce9 = Rfu.unk_ce5;
+                Rfu.unk_ce2 |= Rfu.unk_ce5;
+                Rfu.unk_ce5 = 0;
+                rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, 70);
+                Rfu.unk_cda = sub_800E87C(Rfu.unk_ce2);
+                CreateTask(sub_8010AAC, 0);
+            }
+        }
+        else
+        {
+            Rfu.unk_cdc = 1;
+            Rfu.unk_0e = 0;
+        }
+        Rfu.unk_0e = 0;
+    }
+    retval = Rfu.unk_cdc;
+    return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE;
+}
+
+void sub_800F498(u16 *a0, u8 *a1)
+{
+    s32 i;
+
+    if (a0[0])
+    {
+        a0[0] |= (Rfu.unk_102 << 5);
+        Rfu.unk_102 = (Rfu.unk_102 + 1) & 7;
+        for (i = 0; i < 7; i++)
+        {
+            a1[2 * i + 1] = a0[i] >> 8;
+            a1[2 * i + 0] = a0[i];
+        }
+    }
+    else
+    {
+        for (i = 0; i < 14; i++)
+            a1[i] = 0;
+    }
+}
+
+bool32 sub_800F4F0(void)
+{
+    u8 i;
+    u8 j;
+    u8 sp00[MAX_RFU_PLAYERS * (2 * (CMD_LENGTH - 1))];
+    u8 sp48[2 * (CMD_LENGTH - 1)];
+    u8 switchval;
+
+    sub_800D934(&Rfu.unk_124, sp00);
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        for (j = 0; j < CMD_LENGTH - 1; j++)
+        {
+            gRecvCmds[i][j] = (sp00[i * 14 + (j << 1) + 1] << 8) | sp00[i * 14 + (j << 1) + 0];
+        }
+    }
+    sub_800F86C(0);
+    if (lman.childClockSlave_flag == 0 && Rfu.unk_ce4)
+    {
+        rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
+        rfu_waitREQComplete();
+        switchval = sub_8011A74();
+        if (switchval != 1 && switchval != 6 && switchval != 9)
+            sub_8011A64(2, 0x9000);
+        rfu_clearAllSlot();
+        gReceivedRemoteLinkPlayers = FALSE;
+        Rfu.linkRfuCallback = NULL;
+        if (Rfu.unk_ce4 == 1)
+        {
+            sub_8011A64(2, 0x9000);
+            sub_8011170(0x9000);
+        }
+        lman.state = lman.next_state = 0;
+        Rfu.unk_ce4 = 0;
+    }
+    if (Rfu.unk_cd0)
+    {
+        Rfu.unk_cd0--;
+        sub_8010528();
+        sub_800F498(gSendCmd, sp48);
+        sub_800D888(&Rfu.unk_9e8, sp48);
+        for (i = 0; i < CMD_LENGTH - 1; i++)
+            gSendCmd[i] = 0;
+    }
+    return IsRfuRecvQueueEmpty();
+}
+
+void sub_800F638(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++)
+    {
+        if (!(flags & 1))
+        {
+            gUnknown_03000D90[0] = (~0x76ff) | i;
+            for (j = 0; j < 7; j++)
+            {
+                gUnknown_03000D90[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0];
+            }
+            for (j = 0; j < 7; j++)
+            {
+                gUnknown_03000D80[2 * j + 1] = gUnknown_03000D90[j] >> 8;
+                gUnknown_03000D80[2 * j + 0] = gUnknown_03000D90[j];
+
+                j++;j--; // Needed to match;
+            }
+            sub_800D888(&Rfu.unk_9e8, gUnknown_03000D80);
+            Rfu.unk_6c.unk_0c |= (1 << i);
+        }
+        flags >>= 1;
+    }
+}
+
+void sub_800F6FC(u8 a0)
+{
+    if (Rfu.unk_0c == 1 && a0)
+        Rfu.unk_61[a0] = 1;
+    else
+        Rfu.unk_5c[a0] = 1;
+}
+
+void sub_800F728(u8 a0)
+{
+    Rfu.unk_5c[a0] = 0;
+    Rfu.unk_80[a0].unk_12 = 0;
+}
+
+u8 sub_800F74C(const u8 *a0)
+{
+    u8 i;
+
+    if (Rfu.unk_0c == 1)
+        return FALSE;
+    for (i = 0; i < 4; i++)
+    {
+        Rfu.unk_cde[i] = a0[i];
+    }
+    return a0[Rfu.unk_c3e];
+}
+
+void rfu_func_080F97B8(void)
+{
+    if (gReceivedRemoteLinkPlayers
+        && gHeldKeyCodeToSend != LINK_KEY_CODE_NULL
+        && gLinkTransferringData != TRUE)
+    {
+        gUnknown_03000D78[0]++;
+        gHeldKeyCodeToSend |= (gUnknown_03000D78[0] << 8);
+        sub_800FD14(0xbe00);
+    }
+}
+
+struct GFtgtGname *sub_800F7DC(void)
+{
+    return &gUnknown_02022B14;
+}
+
+bool32 IsSendingKeysToRfu(void)
+{
+    return Rfu.linkRfuCallback == rfu_func_080F97B8;
+}
+
+void sub_800F804(void)
+{
+    Rfu.linkRfuCallback = rfu_func_080F97B8;
+}
+
+void ClearLinkRfuCallback(void)
+{
+    Rfu.linkRfuCallback = NULL;
+}
+
+void sub_800F820(void)
+{
+    sub_800FD14(0x4400);
+    if (GetMultiplayerId() == 0)
+        gSendCmd[6] = GetBlenderArrowPosition();
+    gUnknown_020223C0++;
+}
+
+void sub_800F850(void)
+{
+    if (Rfu.linkRfuCallback == NULL)
+        Rfu.linkRfuCallback = sub_800F820;
+}
+
+void sub_800F86C(u8 unused)
+{
+    u16 i;
+    u16 j;
+
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        switch (gRecvCmds[i][0] & 0xff00)
+        {
+        case 0x7800:
+            if (Rfu.unk_0c == 0 && gReceivedRemoteLinkPlayers != 0)
+                return;
+            // fallthrough
+        case 0x7700:
+            if (gRfuLinkStatus->parentChild == 0)
+            {
+                Rfu.playerCount = gRecvCmds[i][1];
+                Rfu.unk_cce = sub_800F74C((u8 *)(gRecvCmds[i] + 2));
+            }
+            break;
+        case 0x8800:
+            if (Rfu.unk_80[i].unk_12 == 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.unk_5c[i] = 0;
+            }
+            break;
+        case 0x8900:
+            if (Rfu.unk_80[i].unk_12 == 1)
+            {
+                Rfu.unk_80[i].unk_00 = gRecvCmds[i][0] & 0xff;
+                Rfu.unk_80[i].unk_08 |= (1 << Rfu.unk_80[i].unk_00);
+                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_082ED628[Rfu.unk_80[i].unk_02])
+                {
+                    Rfu.unk_80[i].unk_12 = 2;
+                    sub_800F6FC(i);
+                    if (sub_800F7DC()->activity == 0x45 && gReceivedRemoteLinkPlayers != 0 && Rfu.unk_0c == 0)
+                        sub_8010A70(gBlockRecvBuffer);
+                }
+            }
+            break;
+        case 0xa100:
+            sub_800FE84(gUnknown_082ED6B8[gRecvCmds[i][1]].buffer, (u16)gUnknown_082ED6B8[gRecvCmds[i][1]].size);
+            break;
+        case 0x5f00:
+            Rfu.unk_e4[i] = 1;
+            break;
+        case 0x6600:
+            if (Rfu.unk_100 == gRecvCmds[i][1])
+                Rfu.unk_e9[i] = 1;
+            break;
+        case 0xed00:
+            if (Rfu.unk_0c == 0)
+            {
+                if (gReceivedRemoteLinkPlayers != 0)
+                {
+                    if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag)
+                    {
+                        gReceivedRemoteLinkPlayers = 0;
+                        rfu_LMAN_requestChangeAgbClockMaster();
+                        Rfu.unk_ce4 = gRecvCmds[i][2];
+                    }
+                    Rfu.playerCount = gRecvCmds[i][3];
+                    sub_80109E8(gRecvCmds[i][1]);
+                }
+            }
+            else
+            {
+                sub_800FD14(0xee00);
+                gSendCmd[1] = gRecvCmds[i][1];
+                gSendCmd[2] = gRecvCmds[i][2];
+                gSendCmd[3] = gRecvCmds[i][3];
+            }
+            break;
+        case 0xee00:
+            if (Rfu.unk_0c == 1)
+            {
+                Rfu.unk_ce3 |= gRecvCmds[i][1];
+                Rfu.unk_ce4 = gRecvCmds[i][2];
+                sub_80109E8(gRecvCmds[i][1]);
+            }
+            break;
+        case 0x4400:
+        case 0xbe00:
+            gLinkPartnersHeldKeys[i] = gRecvCmds[i][1];
+            break;
+        }
+        if (Rfu.unk_0c == 1 && Rfu.unk_61[i])
+        {
+            if (Rfu.unk_61[i] == 4)
+            {
+                Rfu.unk_5c[i] = 1;
+                Rfu.unk_61[i] = 0;
+            }
+            else
+                Rfu.unk_61[i]++;
+        }
+    }
+}
+
+bool8 sub_800FC60(void)
+{
+    s32 i;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (Rfu.unk_80[i].unk_12)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+bool8 sub_800FC88(void)
+{
+    s32 i;
+
+    for (i = 0; i < Rfu.playerCount; i++)
+    {
+        if (Rfu.unk_80[i].unk_12 != 2 || Rfu.unk_5c[i] != 1)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+void sub_800FCC4(struct UnkRfuStruct_2_Sub_6c *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;
+}
+
+u8 sub_800FCD8(void)
+{
+    u8 flags = 0;
+    s32 i;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (Rfu.unk_80[i].unk_12 == 2 && Rfu.unk_5c[i] == 1)
+        {
+            flags |= (1 << i);
+        }
+    }
+    return flags;
+}
+
+void sub_800FD14(u16 command)
+{
+    u8 i;
+    u8 *buff;
+    u8 tmp;
+
+    gSendCmd[0] = command;
+    switch (command)
+    {
+    case 0x8800:
+        gSendCmd[1] = Rfu.unk_6c.unk_02;
+        gSendCmd[2] = Rfu.unk_6c.unk_11 + 0x80;
+        break;
+    case 0xa100:
+        if (sub_800FC60())
+            gSendCmd[1] = Rfu.unk_5a;
+        break;
+    case 0x7700:
+    case 0x7800:
+        tmp = Rfu.unk_ce2 ^ Rfu.unk_ce3;
+        Rfu.playerCount = gUnknown_082ED695[tmp] + 1;
+        gSendCmd[1] = Rfu.playerCount;
+        buff = (u8 *)(gSendCmd + 2);
+        for (i = 0; i < 4; i++)
+            buff[i] = Rfu.unk_cde[i];
+        break;
+    case 0x6600:
+    case 0x5f00:
+        gSendCmd[1] = Rfu.unk_100;
+        break;
+    case 0x4400:
+        gSendCmd[0] = command;
+        gSendCmd[1] = gMain.heldKeys;
+        break;
+    case 0x2f00:
+        for (i = 0; i < 6; i++)
+            gSendCmd[1 + i] = Rfu.unk_f2[i];
+        break;
+    case 0xbe00:
+        gSendCmd[1] = gHeldKeyCodeToSend;
+        break;
+    case 0xee00:
+        break;
+    case 0xed00:
+        break;
+    }
+}
+
+void sub_800FE50(void *a0)
+{
+    if (gSendCmd[0] == 0 && !sub_8011A80())
+    {
+        memcpy(Rfu.unk_f2, a0, sizeof(Rfu.unk_f2));
+        sub_800FD14(0x2f00);
+    }
+}
+
+bool32 sub_800FE84(const u8 *src, size_t size)
+{
+    bool8 r4;
+    if (Rfu.linkRfuCallback != NULL)
+        return FALSE;
+    if (gSendCmd[0] != 0)
+        return FALSE;
+    if (Rfu.unk_6c.unk_10 != 0)
+    {
+        gUnknown_02022B44.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;
+    else
+    {
+        if (src != gBlockSendBuffer)
+            memcpy(gBlockSendBuffer, src, size);
+        Rfu.unk_6c.unk_04 = gBlockSendBuffer;
+    }
+    sub_800FD14(0x8800);
+    Rfu.linkRfuCallback = rfufunc_80F9F44;
+    Rfu.unk_5b = 0;
+    return TRUE;
+}
+
+void rfufunc_80F9F44(void)
+{
+    if (gSendCmd[0] == 0)
+    {
+        sub_800FD14(0x8800);
+        if (Rfu.unk_0c == 1)
+        {
+            if (++Rfu.unk_5b > 2)
+                Rfu.linkRfuCallback = sub_800FFB0;
+        }
+        else
+        {
+            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == 0x8800)
+                Rfu.linkRfuCallback = sub_800FFB0;
+        }
+    }
+}
+
+void sub_800FFB0(void)
+{
+    s32 i;
+    const u8 *src = Rfu.unk_6c.unk_04;
+    gSendCmd[0] = 0x8900 | Rfu.unk_6c.unk_00;
+    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)
+    {
+        Rfu.unk_6c.unk_10 = 0;
+        Rfu.linkRfuCallback = rfufunc_80FA020;
+    }
+}
+
+void rfufunc_80FA020(void)
+{
+    const u8 *src = Rfu.unk_6c.unk_04;
+    u8 mpId = GetMultiplayerId();
+    s32 i;
+    if (Rfu.unk_0c == 0)
+    {
+        gSendCmd[0] = (~0x76ff) | (Rfu.unk_6c.unk_02 - 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)
+        {
+            if (Rfu.unk_80[mpId].unk_08 != gUnknown_082ED628[Rfu.unk_80[mpId].unk_02])
+            {
+                sub_800F638(mpId, Rfu.unk_80[mpId].unk_08);
+                gUnknown_02022B44.unk_64++;
+            }
+            else
+                Rfu.linkRfuCallback = NULL;
+        }
+    }
+    else
+        Rfu.linkRfuCallback = NULL;
+}
+
+bool8 sub_8010100(u8 a0)
+{
+    Rfu.unk_5a = a0;
+    sub_800FD14(0xa100);
+    return TRUE;
+}
+
+void sub_801011C(void)
+{
+    rfu_clearAllSlot();
+    rfu_LMAN_powerDownRFU();
+    gReceivedRemoteLinkPlayers = 0;
+    Rfu.unk_ef = 1;
+    Rfu.linkRfuCallback = NULL;
+}
+
+void sub_8010148(void)
+{
+    rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
+    rfu_waitREQComplete();
+    sub_801011C();
+}
+
+void sub_8010168(void)
+{
+    if (Rfu.unk_0c == 0)
+    {
+        rfu_LMAN_requestChangeAgbClockMaster();
+        Rfu.unk_ce4 = 2;
+    }
+    else
+        Rfu.linkRfuCallback = sub_8010148;
+}
+
+void LinkRfu_FatalError(void)
+{
+    rfu_LMAN_requestChangeAgbClockMaster();
+    Rfu.unk_ce4 = 1;
+    Rfu.unk_ce3 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
+}
+
+void sub_80101CC(void)
+{
+    s32 i;
+    u8 playerCount = Rfu.playerCount;
+    s32 count = 0;
+
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        if (Rfu.unk_e4[i])
+            count++;
+    }
+    if (count == playerCount)
+    {
+        gBattleTypeFlags &= ~BATTLE_TYPE_20;
+        if (Rfu.unk_0c == 0)
+        {
+            Rfu.unk_ee = 3;
+            sub_8010168();
+        }
+        else
+            Rfu.linkRfuCallback = sub_8010168;
+    }
+}
+
+void sub_801022C(void)
+{
+    if (gSendCmd[0] == 0 && Rfu.unk_ce8 == 0)
+    {
+        sub_800FD14(0x5f00);
+        Rfu.linkRfuCallback = sub_80101CC;
+    }
+}
+
+void sub_8010264(u8 taskId)
+{
+    if (Rfu.linkRfuCallback == NULL)
+    {
+        Rfu.unk_cd9 = 1;
+        Rfu.linkRfuCallback = sub_801022C;
+        DestroyTask(taskId);
+    }
+}
+
+void task_add_05_task_del_08FA224_when_no_RfuFunc(void)
+{
+    if (!FuncIsActiveTask(sub_8010264))
+        CreateTask(sub_8010264, 5);
+}
+
+void sub_80102B8(void)
+{
+    u8 playerCount;
+    u8 i;
+
+    if (GetMultiplayerId() != 0)
+    {
+        u8 r4 = Rfu.unk_124.unk_8c2;
+        if (r4 == 0 && Rfu.unk_fe > 0x3c)
+        {
+            sub_800FD14(0x6600);
+            Rfu.unk_fe = r4;
+        }
+    }
+    playerCount = GetLinkPlayerCount();
+    for (i = 0; i < playerCount; i++)
+    {
+        if (Rfu.unk_e9[i] == 0)
+            break;
+    }
+    if (i == playerCount)
+    {
+        for (i = 0; i < MAX_RFU_PLAYERS; i++)
+            Rfu.unk_e9[i] = 0;
+        Rfu.unk_100++;
+        Rfu.linkRfuCallback = NULL;
+    }
+    Rfu.unk_fe++;
+}
+
+void sub_8010358(void)
+{
+    if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+    {
+        sub_800FD14(0x6600);
+        Rfu.linkRfuCallback = sub_80102B8;
+    }
+}
+
+void sub_8010390(void)
+{
+    u8 i;
+    u8 playerCount;
+
+    if (GetMultiplayerId() != 0)
+    {
+        if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+        {
+            sub_800FD14(0x6600);
+            Rfu.linkRfuCallback = sub_80102B8;
+        }
+    }
+    else
+    {
+        playerCount = GetLinkPlayerCount();
+        for (i = 1; i < playerCount; i++)
+        {
+            if (Rfu.unk_e9[i] == 0)
+                break;
+        }
+        if (i == playerCount)
+        {
+            if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0)
+            {
+                sub_800FD14(0x6600);
+                Rfu.linkRfuCallback = sub_8010358;
+            }
+        }
+    }
+}
+
+void sub_8010434(void)
+{
+    if (Rfu.linkRfuCallback == NULL)
+    {
+        Rfu.linkRfuCallback = sub_8010390;
+        Rfu.unk_fe = 0;
+    }
+}
+
+bool32 sub_8010454(u32 a0)
+{
+    s32 i;
+    for (i = 0; gUnknown_082ED6E0[i] != a0; i++)
+    {
+        if (gUnknown_082ED6E0[i] == 0xFFFF)
+            return FALSE;
+    }
+    return TRUE;
+}
+
+u8 sub_801048C(bool32 a0)
+{
+    if (a0 == FALSE)
+        return rfu_LMAN_setLinkRecovery(0, 0);
+    rfu_LMAN_setLinkRecovery(1, 0x258);
+    return 0;
+}
+
+void sub_80104B0(void)
+{
+    Rfu.unk_cd9 = 1;
+    rfu_LMAN_stopManager(FALSE);
+}
+
+u8 rfu_get_multiplayer_id(void)
+{
+    if (Rfu.unk_0c == 1)
+        return 0;
+    return Rfu.unk_cce;
+}
+
+u8 sub_80104F4(void)
+{
+    return Rfu.playerCount;
+}
+
+bool8 IsLinkRfuTaskFinished(void)
+{
+    if (Rfu.unk_f1 == 2)
+        return FALSE;
+    return Rfu.linkRfuCallback ? FALSE : TRUE;
+}
+
+void sub_8010528(void)
+{
+    if (Rfu.linkRfuCallback)
+        Rfu.linkRfuCallback();
+}
+
+bool8 sub_8010540(void)
+{
+    s32 i;
+    bool8 retval = FALSE;
+    for (i = 0; i < 4; i++)
+    {
+        if (Rfu.unk_cd1[i] < 5 || Rfu.unk_cd1[i] > 6)
+        {
+            if (gRfuSlotStatusNI[i]->recv.state == 0x46 || gRfuSlotStatusNI[i]->recv.state == 0x48)
+            {
+                if (Rfu.unk_cd5[i] == 8)
+                {
+                    Rfu.unk_cd1[i] = 9;
+                    Rfu.unk_cd5[i] = 10;
+                    rfu_clearSlot(8, i);
+                    rfu_NI_setSendData(1 << i, 8, Rfu.unk_cd1 + i, 1);
+                    retval = TRUE;
+                }
+
+            }
+            else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == 0x47)
+                rfu_clearSlot(8, i);
+            {
+
+            }
+        }
+    }
+    return retval;
+}
+
+bool32 sub_80105EC(void)
+{
+    u8 flags = 0;
+    s32 i;
+    for (i = 0; i < 4; i++)
+    {
+        if (Rfu.unk_cd5[i] == 11)
+        {
+            flags |= (1 << i);
+            Rfu.unk_cd5[i] = 0;
+        }
+    }
+    if (flags)
+    {
+        rfu_REQ_disconnect(flags);
+        rfu_waitREQComplete();
+    }
+    for (i = 0; i < 4; i++)
+    {
+        if (Rfu.unk_cd5[i] == 10 || Rfu.unk_cd5[i] == 11)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+bool32 sub_801064C(u16 a0, const u8 *a1)
+{
+    u8 r1 = sub_8011CE4(a1, a0);
+    if (r1 == 0xFF)
+        return TRUE;
+    if (Rfu.unk_cd1[r1] == 9)
+        return TRUE;
+    return FALSE;
+}
+
+void sub_8010688(u8 a0, u16 a1, const u8 *a2)
+{
+    u8 r4 = sub_8011CE4(a2, a1);
+    Rfu.unk_cd1[r4] = a0;
+    rfu_clearSlot(4, r4);
+    rfu_NI_setSendData(1 << r4, 8, Rfu.unk_cd1 + r4, 1);
+}
+
+void sub_80106D4(void)
+{
+    Rfu.unk_c85 = 8;
+    rfu_clearSlot(4, Rfu.unk_c3e);
+    rfu_NI_setSendData(1 << Rfu.unk_c3e, 8, &Rfu.unk_c85, 1);
+}
+
+u32 sub_8010714(u16 a0, const u8 *a1)
+{
+    u8 r0 = sub_8011CE4(a1, a0);
+    if (r0 == 0xFF)
+        return 2;
+    if (gRfuSlotStatusNI[r0]->send.state == 0)
+        return 1;
+    return 0;
+}
+
+void sub_8010750(void)
+{
+    s32 i;
+
+    sub_8010540();
+    for (i = 0; i < 4; i++)
+    {
+        if (gRfuSlotStatusNI[i]->send.state == 0x26 || gRfuSlotStatusNI[i]->send.state == 0x27)
+        {
+            if (Rfu.unk_cd5[i] == 10)
+                Rfu.unk_cd5[i] = 11;
+            rfu_clearSlot(4, i);
+        }
+    }
+}
+
+s32 sub_80107A0(void)
+{
+    s32 retval = 0;
+    if (Rfu.unk_c85 == 8)
+    {
+        if (gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == 0x26 || gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == 0x27)
+            rfu_clearSlot(4, Rfu.unk_c3e);
+    }
+    if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == 0x46 || gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == 0x48)
+    {
+        rfu_clearSlot(8, Rfu.unk_c3e);
+        sub_8011A64(Rfu.unk_c86, 0);
+        retval = Rfu.unk_c86;
+    }
+    else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == 0x47)
+    {
+        rfu_clearSlot(8, Rfu.unk_c3e);
+        retval = 6;
+    }
+    return retval;
+}
+
+void sub_801084C(u8 taskId)
+{
+    s32 i;
+
+    if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2)
+    {
+        Rfu.unk_ce8 = 0;
+        DestroyTask(taskId);
+    }
+    switch (gTasks[taskId].data[0])
+    {
+        case 0:
+            if (sub_800FC60())
+            {
+                ResetBlockReceivedFlags();
+                sub_800B348();
+                gTasks[taskId].data[0]++;
+            }
+            break;
+        case 1:
+            if (Rfu.unk_0c == 1)
+            {
+                if (gReceivedRemoteLinkPlayers)
+                    sub_800FD14(0x7800);
+                else
+                    sub_800FD14(0x7700);
+                gTasks[taskId].data[0] = 101;
+            }
+            else
+                gTasks[taskId].data[0] = 2;
+            break;
+        case 101:
+            if (gSendCmd[0] == 0)
+                gTasks[taskId].data[0] = 2;
+            break;
+        case 2:
+            if (Rfu.playerCount)
+                gTasks[taskId].data[0]++;
+            break;
+        case 3:
+            if (Rfu.unk_0c == 1)
+            {
+                if (sub_800FC60())
+                {
+                    Rfu.unk_5a = 0;
+                    sub_800FD14(0xa100);
+                    gTasks[taskId].data[0]++;
+                }
+            }
+            else
+                gTasks[taskId].data[0]++;
+            break;
+        case 4:
+            if (sub_800FC88())
+                gTasks[taskId].data[0]++;
+            break;
+        case 5:
+            for (i = 0; i < Rfu.playerCount; i++)
+            {
+                sub_800B3A4(i);
+                sub_800F728(i);
+            }
+            gTasks[taskId].data[0]++;
+            break;
+        case 6:
+            DestroyTask(taskId);
+            gReceivedRemoteLinkPlayers = 1;
+            Rfu.unk_ce8 = 0;
+            rfu_LMAN_setLinkRecovery(1, 0x258);
+            if (Rfu.unk_ce6)
+            {
+                for (i = 0; i < 4; i++)
+                {
+                    if ((Rfu.unk_ce6 >> i) & 1)
+                    {
+                        Rfu.unk_ce5 = 1 << i;
+                        Rfu.unk_ce6 ^= (1 << i);
+                    }
+                }
+            }
+            break;
+    }
+}
+
+void sub_80109E8(u16 a0)
+{
+    s32 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if ((a0 >> i) & 1)
+            Rfu.unk_cde[i] = 0;
+    }
+}
+
+void sub_8010A14(const struct UnkRfuStruct_8010A14 *a0)
+{
+    s32 i;
+    Rfu.playerCount = a0->unk_0f;
+    for (i = 0; i < 4; i++)
+        Rfu.unk_cde[i] = a0->unk_10[i];
+    for (i = 0; i < MAX_RFU_PLAYERS; i++)
+    {
+        gLinkPlayers[i] = a0->unk_14[i];
+        sub_800B524(gLinkPlayers + i);
+    }
+}
+
+void sub_8010A70(void *a0)
+{
+    if (strcmp(gUnknown_082ED7EC, a0) == 0)
+    {
+        sub_8010A14(a0);
+        CpuFill16(0, a0, sizeof(struct UnkRfuStruct_8010A14));
+        ResetBlockReceivedFlag(0);
+    }
+}
+
+void sub_8010AAC(u8 taskId)
+{
+    s32 i;
+    struct LinkPlayerBlock *r2;
+    struct UnkRfuStruct_8010A14 *r5;
+    u8 r4 = Rfu.unk_cde[gUnknown_082ED68C[Rfu.unk_ce9]];
+    if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2)
+    {
+        Rfu.unk_ce8 = 0;
+        DestroyTask(taskId);
+    }
+    switch (gTasks[taskId].data[0])
+    {
+        case 0:
+            if (gSendCmd[0] == 0)
+            {
+                ResetBlockReceivedFlag(r4);
+                sub_800FD14(0x7800);
+                gTasks[taskId].data[0]++;
+            }
+            break;
+        case 1:
+            if (gSendCmd[0] == 0)
+                gTasks[taskId].data[0]++;
+            break;
+        case 2:
+            if ((GetBlockReceivedStatus() >> r4) & 1)
+            {
+                ResetBlockReceivedFlag(r4);
+                r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4];
+                gLinkPlayers[r4] = r2->linkPlayer;
+                sub_800B524(gLinkPlayers + r4);
+                gTasks[taskId].data[0]++;
+            }
+            break;
+        case 3:
+            r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
+            memcpy(r5->unk_00, gUnknown_082ED7EC, sizeof gUnknown_082ED7EC);
+            r5->unk_0f = Rfu.playerCount;
+            for (i = 0; i < 4; i++)
+                r5->unk_10[i] = Rfu.unk_cde[i];
+            memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers);
+            gTasks[taskId].data[0]++;
+            // fallthrough
+        case 4:
+            r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer;
+            r5->unk_0f = Rfu.playerCount;
+            for (i = 0; i < 4; i++)
+                r5->unk_10[i] = Rfu.unk_cde[i];
+            memcpy(r5->unk_14, 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));
+                ResetBlockReceivedFlag(0);
+                Rfu.unk_ce8 = 0;
+                if (Rfu.unk_ce6)
+                {
+                    for (i = 0; i < 4; i++)
+                    {
+                        if ((Rfu.unk_ce6 >> i) & 1)
+                        {
+                            Rfu.unk_ce5 = 1 << i;
+                            Rfu.unk_ce6 ^= (1 << i);
+                            Rfu.unk_ce8 = 1;
+                            break;
+                        }
+                    }
+                }
+                DestroyTask(taskId);
+            }
+            break;
+    }
+}
+
+void sub_8010D0C(u8 taskId)
+{
+    if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2)
+        DestroyTask(taskId);
+    switch (gTasks[taskId].data[0])
+    {
+        case 0:
+            if (Rfu.playerCount)
+            {
+                sub_800B348();
+                SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock));
+                gTasks[taskId].data[0]++;
+            }
+            break;
+        case 1:
+            if (IsLinkTaskFinished())
+                gTasks[taskId].data[0]++;
+            break;
+        case 2:
+            if (GetBlockReceivedStatus() & 1)
+            {
+                sub_8010A14((const struct UnkRfuStruct_8010A14 *)gBlockRecvBuffer);
+                ResetBlockReceivedFlag(0);
+                gReceivedRemoteLinkPlayers = 1;
+                DestroyTask(taskId);
+            }
+            break;
+    }
+}
+
+void sub_8010DB4(void)
+{
+    if (Rfu.unk_ee == 1 && lman.childClockSlave_flag == 0)
+    {
+        if (gMain.callback2 == c2_mystery_gift_e_reader_run || lman.init_param->mboot_flag)
+            gWirelessCommType = 2;
+        SetMainCallback2(CB2_LinkError);
+        gMain.savedCallback = CB2_LinkError;
+        sub_800AF18((Rfu.unk_0a << 16) | (Rfu.unk_10 << 8) | Rfu.unk_12, Rfu.unk_124.unk_8c2, Rfu.unk_9e8.unk_232, sub_8011A74() == 2);
+        Rfu.unk_ee = 2;
+        CloseLink();
+    }
+    else if (Rfu.unk_9e8.unk_233 == 1 || Rfu.unk_124.unk_8c3 == 1)
+    {
+        if (lman.childClockSlave_flag)
+            rfu_LMAN_requestChangeAgbClockMaster();
+        sub_8011A64(1, 0x7000);
+        sub_8011170(0x7000);
+    }
+}
+
+void rfu_REQ_recvData_then_sendData(void)
+{
+    if (lman.parent_child == 1)
+    {
+        rfu_REQ_recvData();
+        rfu_waitREQComplete();
+        rfu_LMAN_REQ_sendData(0);
+    }
+}
+
+bool32 sub_8010EC0(void)
+{
+    bool32 retval = FALSE;
+    Rfu.unk_ccd = 0;
+    rfu_LMAN_manager_entity(Random2());
+    if (Rfu.unk_ef == 0)
+    {
+        switch (Rfu.unk_0c)
+        {
+            case 1:
+                sub_800F0F8();
+                break;
+            case 0:
+                retval = sub_800F4F0();
+                break;
+            case 2:
+                rfu_REQ_recvData_then_sendData();
+                break;
+        }
+    }
+    return retval;
+}
+
+bool32 sub_8010F1C(void)
+{
+    bool32 retval = FALSE;
+    if (Rfu.unk_ef == 0)
+    {
+        if (Rfu.unk_0c == 1)
+            retval = sub_800F1E0();
+        sub_8010DB4();
+    }
+    return retval;
+}
+
+void sub_8010F48(void)
+{
+    StringCopy(gUnknown_02022B22, gSaveBlock2Ptr->playerName);
+}
+
+void sub_8010F60(void)
+{
+    memset(&gUnknown_02022B14, 0, 0xD);
+    sub_800DD94(&gUnknown_02022B14, 0, 0, 0);
+}
+
+void sub_8010F84(u8 a0, u32 a1, u32 a2)
+{
+    sub_800DD94(&gUnknown_02022B14, a0, a2, a1);
+}
+
+void sub_8010FA0(bool32 a0, bool32 a1)
+{
+    gUnknown_02022B14.unk_00.hasNews = a0;
+    gUnknown_02022B14.unk_00.hasCard = a1;
+}
+
+void sub_8010FCC(u32 type, u32 species, u32 level)
+{
+    gUnknown_02022B14.type = type;
+    gUnknown_02022B14.species = species;
+    gUnknown_02022B14.level = level;
+}
+
+u8 sub_801100C(s32 a0)
+{
+    u8 retval = 0x80;
+    retval |= (gLinkPlayers[a0].gender << 3);
+    retval |= (gLinkPlayers[a0].trainerId & 7);
+    return retval;
+}
+
+void sub_801103C(void)
+{
+    struct GFtgtGname *r5 = &gUnknown_02022B14;
+    s32 i;
+
+    for (i = 1; i < GetLinkPlayerCount(); i++)
+        r5->child_sprite_gender[i - 1] = sub_801100C(i);
+}
+
+void sub_8011068(u8 a0)
+{
+    gUnknown_02022B14.started = a0;
+    rfu_REQ_configGameData(0, 2, (const u8 *)&gUnknown_02022B14, gUnknown_02022B22);
+}
+
+void sub_8011090(u8 a0, u32 a1, u32 a2)
+{
+    if (a0)
+        sub_8010F84(a0, a1, a2);
+    rfu_REQ_configGameData(0, 2, (const u8 *)&gUnknown_02022B14, gUnknown_02022B22);
+}
+
+void sub_80110B8(u32 a0)
+{
+    s32 i;
+    u32 r5;
+    u32 r7;
+    s32 r8;
+
+    if (sub_800F7DC()->activity == 0x45)
+    {
+        r5 = 0;
+        r7 = 0;
+        r8 = Rfu.unk_ce2 ^ Rfu.unk_ce3;
+        for (i = 0; i < 4; i++)
+        {
+            if ((r8 >> i) & 1)
+            {
+                r7 |= ((0x80 | ((gLinkPlayers[Rfu.unk_cde[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.unk_cde[i]].trainerId & 7)) << (r5 << 3));
+                r5++;
+                if (r5 == a0 - 1)
+                    break;
+            }
+        }
+        sub_8011090(0x45, r7, 0);
+    }
+}
+
+void sub_8011170(u32 a0)
+{
+    if (Rfu.unk_ee == 0)
+    {
+        Rfu.unk_10 = lman.param[0];
+        Rfu.unk_12 = lman.param[1];
+        Rfu.unk_0a = a0;
+        Rfu.unk_ee = 1;
+    }
+}
+
+void sub_80111A0(void)
+{
+    Rfu.unk_ee = 0;
+}
+
+void sub_80111B0(bool32 a0)
+{
+    if (!a0)
+        Rfu.unk_ee = 0;
+    else
+        Rfu.unk_ee = 4;
+}
+
+void sub_80111DC(void)
+{
+    sub_8011E94(lman.acceptSlot_flag, 1);
+    Rfu.linkRfuCallback = NULL;
+}
+
+void sub_80111FC(void)
+{
+    Rfu.linkRfuCallback = sub_80111DC;
+}
+
+void sub_801120C(u8 a0, u8 unused1)
+{
+    u8 i;
+    u8 r6 = 0;
+    switch (a0)
+    {
+    case 0x00:
+        Rfu.unk_04 = 2;
+        break;
+    case 0x10:
+        break;
+    case 0x11:
+        sub_80115EC(lman.param[0]);
+        for (i = 0; i < 4; i++)
+        {
+            if ((lman.param[0] >> i) & 1)
+            {
+                struct GFtgtGname *structPtr = (void *)gRfuLinkStatus->partner[i].gname;
+                if (structPtr->activity == sub_800F7DC()->activity)
+                {
+                    Rfu.unk_cd1[i] = 0;
+                    Rfu.unk_cd5[i] = 0;
+                    rfu_setRecvBuffer(0x20, i, Rfu.unk_cd5 + i, 1);
+                }
+                else
+                {
+                    r6 |= (1 << i);
+                }
+            }
+        }
+        if (r6)
+        {
+            rfu_REQ_disconnect(r6);
+            rfu_waitREQComplete();
+        }
+        break;
+    case 0x12:
+        break;
+    case 0x13:
+        break;
+    case 0x14:
+        if (Rfu.unk_ce7 != lman.acceptSlot_flag)
+        {
+            rfu_REQ_disconnect(Rfu.unk_ce7 ^ lman.acceptSlot_flag);
+            rfu_waitREQComplete();
+        }
+        Rfu.unk_04 = 0x11;
+        break;
+    case 0x31:
+        Rfu.unk_f0 = 1;
+        break;
+    case 0x32:
+        Rfu.unk_f0 = 3;
+        break;
+    case 0x30:
+    case 0x33:
+        Rfu.unk_f0 = 4;
+        Rfu.unk_ce2 &= ~lman.param[0];
+        if (gReceivedRemoteLinkPlayers == 1)
+        {
+            if (Rfu.unk_ce2 == 0)
+                sub_8011170(a0);
+            else
+                sub_80111FC();
+        }
+        sub_8011A64(2, a0);
+        break;
+    case 0x34:
+        break;
+    case 0x42 ... 0x44:
+        break;
+    case 0xf3:
+        sub_8011A64(1, a0);
+        sub_8011170(a0);
+        Rfu.unk_ef = 1;
+        break;
+    case 0xf0 ... 0xf2:
+    case 0xff:
+        sub_8011170(a0);
+        sub_8011A64(1, a0);
+        Rfu.unk_cdb = 1;
+        break;
+    }
+}
+
+void sub_8011404(u8 a0, u8 unused1)
+{
+    switch (a0)
+    {
+    case 0x00:
+        Rfu.unk_04 = 6;
+        break;
+    case 0x20:
+        Rfu.unk_ccd = lman.param[0];
+        break;
+    case 0x21:
+        break;
+    case 0x22:
+        Rfu.unk_c3e = lman.param[0];
+        break;
+    case 0x23:
+        sub_8011A64(2, a0);
+        break;
+    case 0x24:
+        Rfu.unk_04 = 11;
+        Rfu.unk_c85 = 0;
+        Rfu.unk_c86 = 0;
+        rfu_setRecvBuffer(0x20, Rfu.unk_c3e, &Rfu.unk_c86, 1);
+        rfu_setRecvBuffer(0x10, Rfu.unk_c3e, Rfu.unk_c3f, 70);
+        break;
+    case 0x25:
+        sub_8011A64(2, 0x25);
+        break;
+    case 0x30:
+        Rfu.unk_f0 = 2;
+        if (Rfu.unk_c86 == 6)
+            break;
+    case 0x33:
+        if (Rfu.unk_f0 != 2)
+            Rfu.unk_f0 = 4;
+        if (Rfu.unk_c86 != 9)
+            sub_8011A64(2, a0);
+        nullsub_5(gUnknown_082ED7FC, 5, 5);
+        if (gReceivedRemoteLinkPlayers == 1)
+            sub_8011170(a0);
+        break;
+    case 0x31:
+        Rfu.unk_f0 = 1;
+        nullsub_5(gUnknown_082ED814, 5, 5);
+        break;
+    case 0x32:
+        Rfu.unk_f0 = 3;
+        Rfu.unk_c3c = 1;
+        break;
+    case 0x34:
+        break;
+    case 0x42 ... 0x44:
+        break;
+    case 0xF3:
+        sub_8011A64(1, a0);
+        sub_8011170(a0);
+        Rfu.unk_ef = 1;
+        break;
+    case 0xF0 ... 0xF2:
+    case 0xFF:
+        sub_8011A64(1, a0);
+        sub_8011170(a0);
+        Rfu.unk_cdb = 1;
+        break;
+    }
+}
+
+void sub_80115EC(s32 a0)
+{
+    s32 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if ((a0 >> i) & 1)
+        {
+            Rfu.unk_cea[i] = 0;
+            Rfu.unk_cee[i] = 0xFF;
+        }
+    }
+}
+
+u8 sub_8011628(s32 a0)
+{
+    u8 ret = 0;
+    u8 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if ((a0 >> i) & 1)
+        {
+            struct GFtgtGname *structPtr = (void *)gRfuLinkStatus->partner[i].gname;
+            if (structPtr->activity == 0x45)
+                ret |= (1 << i);
+        }
+    }
+
+    return ret;
+}
+
+void sub_8011674(u8 a0, u8 unused1)
+{
+    u8 r1;
+
+    switch (a0)
+    {
+    case 0x00:
+        Rfu.unk_04 = 0x11;
+        break;
+    case 0x10:
+        sub_8011A64(4, 0);
+        break;
+    case 0x11:
+        if (sub_800F7DC()->activity == 0x45 && Rfu.unk_cd9 == 0)
+        {
+            u8 idx = sub_8011628(lman.param[0]);
+            if (idx != 0)
+            {
+                r1 = 1 << sub_800E87C(idx);
+                if (Rfu.unk_ce6 == 0 && Rfu.unk_ce8 == 0)
+                {
+                    Rfu.unk_ce5 = r1;
+                    Rfu.unk_ce6 |= (r1 ^ idx);
+                    Rfu.unk_ce8 = 1;
+                }
+                else
+                {
+                    Rfu.unk_ce6 |= idx;
+                }
+            }
+            if (idx != lman.param[0])
+            {
+                Rfu.unk_ce3 |= (idx ^ lman.param[0]);
+                Rfu.unk_ce4 = 2;
+            }
+        }
+        else if (sub_800F7DC()->activity == 0x54)
+        {
+            rfu_REQ_disconnect(lman.acceptSlot_flag);
+            rfu_waitREQComplete();
+        }
+        sub_80115EC(lman.param[0]);
+        break;
+    case 0x12:
+        break;
+    case 0x13:
+        break;
+    case 0x14:
+        if (sub_800F7DC()->activity != 0x45 && lman.acceptCount > 1)
+        {
+            r1 = 1 << sub_800E87C(lman.param[0]);
+            rfu_REQ_disconnect(lman.acceptSlot_flag ^ r1);
+            rfu_waitREQComplete();
+        }
+        if (Rfu.unk_04 == 0xF)
+            Rfu.unk_04 = 0x10;
+        break;
+        break;
+    case 0x20:
+        Rfu.unk_ccd = lman.param[0];
+        break;
+    case 0x21:
+        break;
+    case 0x22:
+        Rfu.unk_c3e = lman.param[0];
+        break;
+    case 0x23:
+        Rfu.unk_04 = 0x12;
+        if (Rfu.unk_ccf < 2)
+        {
+            Rfu.unk_ccf++;
+            CreateTask(sub_801209C, 2);
+        }
+        else
+        {
+            sub_8011A64(2, a0);
+        }
+        break;
+    case 0x24:
+        Rfu.unk_04 = 0xD;
+        sub_8011A64(3, 0);
+        rfu_setRecvBuffer(0x10, Rfu.unk_c3e, Rfu.unk_c3f, 70);
+        break;
+    case 0x25:
+        sub_8011A64(2, a0);
+        break;
+    case 0x31:
+        if (lman.acceptSlot_flag & lman.param[0])
+            Rfu.unk_f0 = 1;
+        break;
+    case 0x32:
+        Rfu.unk_f0 = 3;
+        if (gRfuLinkStatus->parentChild == 0)
+            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)
+        {
+            if (gReceivedRemoteLinkPlayers == 1)
+            {
+                Rfu.unk_ce2 &= ~(lman.param[0]);
+                if (Rfu.unk_ce2 == 0)
+                    sub_8011170(a0);
+                else
+                    sub_80111FC();
+            }
+        }
+        else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1)
+        {
+            sub_8011170(a0);
+            rfu_LMAN_stopManager(0);
+        }
+
+        if (gRfuLinkStatus->parentChild == 0xFF && lman.pcswitch_flag == 0 && FuncIsActiveTask(sub_800EB44) == TRUE)
+            Rfu.unk_04 = 0x11;
+
+        sub_8011A64(2, a0);
+        break;
+    case 0x40:
+        Rfu.unk_ce3 = 0;
+        break;
+    case 0x42 ... 0x44:
+        break;
+    case 0xF3:
+        sub_8011A64(1, a0);
+        sub_8011170(a0);
+        Rfu.unk_ef = 1;
+        break;
+    case 0xF0 ... 0xF2:
+    case 0xFF:
+        sub_8011170(a0);
+        sub_8011A64(1, a0);
+        Rfu.unk_cdb = 0;
+        break;
+    }
+}
+
+void sub_8011A50(void)
+{
+    Rfu.unk_ce4 = 2;
+}
+
+void sub_8011A64(u8 a0, u16 a1)
+{
+    Rfu.unk_f1 = a0;
+    Rfu.unk_0a = a1;
+}
+
+u8 sub_8011A74(void)
+{
+    return Rfu.unk_f1;
+}
+
+bool32 sub_8011A80(void)
+{
+    u32 var = sub_8011A74() - 1;
+    if (var < 2)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool32 sub_8011A9C(void)
+{
+    return Rfu.unk_ce8;
+}
+
+bool8 Rfu_IsMaster(void)
+{
+    return Rfu.unk_0c;
+}
+
+void RfuVSync(void)
+{
+    rfu_LMAN_syncVBlank();
+}
+
+void sub_8011AC8(void)
+{
+    CpuFill32(0, gRecvCmds, sizeof(gRecvCmds));
+}
+
+void sub_8011AE8(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void sub_8011AFC(void)
+{
+    s32 i;
+
+    ResetSpriteData();
+    FreeAllSpritePalettes();
+    ResetTasks();
+    ResetPaletteFade();
+    SetVBlankCallback(sub_8011AE8);
+    if (IsWirelessAdapterConnected())
+    {
+        gLinkType = LINKTYPE_0x1111;
+        sub_800B488();
+        OpenLink();
+        SeedRng(gMain.vblankCounter2);
+        for (i = 0; i < 4; i++)
+            gSaveBlock2Ptr->playerTrainerId[i] = Random() % 256;
+
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG2_ON | DISPCNT_OBJ_1D_MAP);
+        RunTasks();
+        AnimateSprites();
+        BuildOamBuffer();
+        UpdatePaletteFade();
+        sub_8011BA4();
+        SetMainCallback2(sub_8011BF8);
+    }
+}
+
+bool32 sub_8011B90(void)
+{
+    return FuncIsActiveTask(sub_800EB44);
+}
+
+void sub_8011BA4(void)
+{
+    if (!FuncIsActiveTask(nullsub_89))
+        Rfu.unk_66 = CreateTask(nullsub_89, 0);
+}
+
+void sub_8011BD0(void)
+{
+     if (FuncIsActiveTask(nullsub_89) == TRUE)
+        DestroyTask(Rfu.unk_66);
+}
+
+void sub_8011BF8(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+void sub_8011C10(u32 a0)
+{
+    Rfu.unk_0c = 1;
+    sub_8010F48();
+    rfu_LMAN_initializeManager(sub_801120C, NULL);
+    gUnknown_02022B2C = gUnknown_082ED608;
+    gUnknown_02022B2C.availSlot_flag = gUnknown_082ED620[a0 - 1];
+    sub_800EE78();
+}
+
+void sub_8011C5C(void)
+{
+    Rfu.unk_0c = 0;
+    sub_8010F48();
+    rfu_LMAN_initializeManager(sub_8011404, sub_800ED34);
+    sub_800EF00();
+}
+
+void sub_8011C84(void)
+{
+    Rfu.unk_0c = 2;
+    sub_8010F48();
+    rfu_LMAN_initializeManager(sub_8011674, NULL);
+    gUnknown_02022B2C = gUnknown_082ED608;
+    gUnknown_02022B2C.linkRecovery_enable = 0;
+    gUnknown_02022B2C.linkRecovery_period = 0x258;
+    Rfu.unk_67 = CreateTask(sub_800EB44, 1);
+}
+
+u16 ReadU16(const void *ptr)
+{
+    const u8 *ptr_ = ptr;
+    return (ptr_[1] << 8) | (ptr_[0]);
+}
+
+u8 sub_8011CE4(const u8 *a0, u16 a1)
+{
+    u8 i;
+    u8 ret = 0xFF;
+
+    for (i = 0; i < 4; i++)
+    {
+        u16 trainerId = ReadU16(gRfuLinkStatus->partner[i].gname + 2);
+        if (sub_8010454(gRfuLinkStatus->partner[i].serialNo)
+            && !StringCompare(a0, gRfuLinkStatus->partner[i].uname)
+            && a1 == trainerId)
+        {
+            ret = i;
+            if (gRfuLinkStatus->partner[i].slot != 0xFF)
+                break;
+        }
+    }
+
+    return ret;
+}
+
+void sub_8011D6C(u32 a0)
+{
+    rfu_REQ_disconnect(a0);
+    rfu_waitREQComplete();
+    Rfu.unk_ce2 &= ~(a0);
+    rfu_clearSlot(1, Rfu.unk_cda);
+    rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, 70);
+    Rfu.unk_cda = sub_800E87C(Rfu.unk_ce2);
+}
+
+void sub_8011DC0(const u8 *ptr, u16 a1)
+{
+    u8 var = sub_8011CE4(ptr, a1);
+    if (var != 0xFF)
+        sub_8011D6C(1 << var);
+}
+
+void sub_8011DE0(u32 a0)
+{
+    if (a0 != 0)
+    {
+        s32 i;
+        u8 var = 0;
+
+        for (i = 0; i < 4; i++)
+        {
+            if (Rfu.unk_cde[i] == a0 && (Rfu.unk_ce2 >> i) & 1)
+                var |= 1 << i;
+        }
+        if (var)
+            sub_8011E94(var, 2);
+    }
+}
+
+void sub_8011E2C(u8 taskId)
+{
+    if (gSendCmd[0] == 0 && Rfu.unk_ce8 == 0)
+    {
+        sub_800FD14(0xED00);
+        gSendCmd[1] = gTasks[taskId].data[0];
+        gSendCmd[2] = gTasks[taskId].data[1];
+        Rfu.playerCount -= gUnknown_082ED695[gTasks[taskId].data[0]];
+        gSendCmd[3] = Rfu.playerCount;
+        DestroyTask(taskId);
+    }
+}
+
+void sub_8011E94(u32 a0, u32 a1)
+{
+    u8 taskId = FindTaskIdByFunc(sub_8011E2C);
+    if (taskId == 0xFF)
+    {
+        taskId = CreateTask(sub_8011E2C, 5);
+        gTasks[taskId].data[0] = a0;
+    }
+    else
+    {
+        gTasks[taskId].data[0] |= a0;
+    }
+
+    gTasks[taskId].data[1] = a1;
+}
+
+void sub_8011EF4(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    if (sub_800EE94())
+    {
+        u8 id = sub_8011CE4((u8*)data, ReadU16(&data[8]));
+        if (id != 0xFF)
+        {
+            if (gRfuLinkStatus->partner[id].slot != 0xFF)
+            {
+                Rfu.unk_c3d = id;
+                if (sub_800EEBC())
+                    DestroyTask(taskId);
+            }
+            else if (sub_800F7DC()->activity == 0x15 || sub_800F7DC()->activity == 0x16)
+            {
+                data[15]++;
+            }
+            else
+            {
+                sub_8011A64(2, 0x7000);
+                DestroyTask(taskId);
+            }
+        }
+        else
+        {
+            data[15]++;
+            Rfu.unk_c3d = id;
+        }
+    }
+    else
+    {
+        data[15]++;
+    }
+
+    if (data[15] > 240)
+    {
+        sub_8011A64(2, 0x7000);
+        DestroyTask(taskId);
+    }
+}
+
+void sub_8011FC8(const u8 *src, u16 trainerId)
+{
+    u8 taskId;
+    s16 *data;
+
+    Rfu.unk_f1 = 0;
+    taskId = CreateTask(sub_8011EF4, 3);
+    data = gTasks[taskId].data;
+    StringCopy((u8*)(data), src);
+    data[8] = trainerId;
+}
+
+bool32 sub_801200C(s16 a1, struct GFtgtGname *structPtr)
+{
+    if (sub_800F7DC()->activity == 0x45)
+    {
+        if (structPtr->activity != 0x45)
+            return TRUE;
+    }
+    else if (structPtr->activity != 0x40)
+    {
+        return TRUE;
+    }
+    else if (a1 == 0x44)
+    {
+        struct GFtgtGname *structPtr2 = &Rfu.unk_10A;
+        if (structPtr2->species == SPECIES_EGG)
+        {
+            if (structPtr->species == structPtr2->species)
+                return FALSE;
+            else
+                return TRUE;
+        }
+        else if (structPtr->species != structPtr2->species
+                 || structPtr->level != structPtr2->level
+                 || structPtr->type != structPtr2->type)
+        {
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+void sub_801209C(u8 taskId)
+{
+    if (Rfu.unk_f1 == 4)
+        DestroyTask(taskId);
+
+    if (++gTasks[taskId].data[0] > 300)
+    {
+        sub_8011A64(2, 0x7000);
+        DestroyTask(taskId);
+    }
+
+    if (Rfu.unk_ccd != 0 && lman.parent_child == 0)
+    {
+        u16 trainerId = ReadU16(Rfu.unk_10A.unk_00.playerTrainerId);
+        u8 id = sub_8011CE4(Rfu.playerName, trainerId);
+        if (id != 0xFF)
+        {
+            if (!sub_801200C(gTasks[taskId].data[1], (void *)gRfuLinkStatus->partner[id].gname))
+            {
+                if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 0x5A))
+                {
+                    Rfu.unk_04 = 0xA;
+                    DestroyTask(taskId);
+                }
+            }
+            else
+            {
+                sub_8011A64(2, 0x7000);
+                DestroyTask(taskId);
+            }
+        }
+    }
+}
+
+void sub_8012188(const u8 *name, struct GFtgtGname *structPtr, u8 a2)
+{
+    u8 taskId, taskId2;
+
+    Rfu.unk_ccf = 0;
+    Rfu.unk_f1 = 0;
+    StringCopy(Rfu.playerName, name);
+    memcpy(&Rfu.unk_10A, structPtr, 0xD);
+    rfu_LMAN_forceChangeSP();
+    taskId = CreateTask(sub_801209C, 2);
+    gTasks[taskId].data[1] = a2;
+    taskId2 = FindTaskIdByFunc(sub_800EB44);
+    if (a2 == 0x45)
+    {
+        if (taskId2 != 0xFF)
+            gTasks[taskId2].data[7] = 1;
+    }
+    else
+    {
+        if (taskId2 != 0xFF)
+            gTasks[taskId2].data[7] = 0;
+    }
+}
+
+bool8 sub_8012224(void)
+{
+    if (Rfu.unk_f0 == 1)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+bool32 sub_8012240(void)
+{
+    s32 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if ((lman.acceptSlot_flag >> i) & 1 && Rfu.unk_cd1[i] == 0)
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+void sub_801227C(void)
+{
+    s32 i;
+
+    for (i = 0; i < 20; i++)
+        nullsub_5(gUnknown_082ED82C, 0, i);
+}
+
+void sub_801229C(void)
+{
+    s32 i, j;
+
+    nullsub_13(GetBlockReceivedStatus(), 0x1C, 0x13, 2);
+    nullsub_13(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1);
+    nullsub_13(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1);
+    if (Rfu.unk_0c == 1)
+    {
+        for (i = 0; i < 4; i++)
+        {
+            if ((gRfuLinkStatus->getNameFlag >> i) & 1)
+            {
+                nullsub_13(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
+                nullsub_5((void*)gRfuLinkStatus->partner[i].gname, 6, i + 3);
+                nullsub_5(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
+            }
+        }
+        for (i = 0; i < 4; i++)
+        {
+            for (j = 0; j < 14; j++)
+            {
+                nullsub_13(Rfu.unk_14[i][j], j * 2, i + 11, 2);
+            }
+        }
+        nullsub_5(gUnknown_082ED868, 1, 0xF);
+    }
+    else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0)
+    {
+        for (i = 0; i < 4; i++)
+        {
+            nullsub_13(0, 1, i + 3, 4);
+            nullsub_5(gUnknown_082ED84B, 6, i + 3);
+            nullsub_5(gUnknown_082ED85B, 0x16, i + 3);
+        }
+        nullsub_13(gRfuLinkStatus->partner[Rfu.unk_c3e].serialNo, 1, 3, 4);
+        nullsub_5((void*)gRfuLinkStatus->partner[Rfu.unk_c3e].gname, 6, 3);
+        nullsub_5(gRfuLinkStatus->partner[Rfu.unk_c3e].uname, 0x16, 3);
+    }
+    else
+    {
+        for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
+        {
+            if (gRfuLinkStatus->partner[i].slot != 0xFF)
+            {
+                nullsub_13(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
+                nullsub_13(gRfuLinkStatus->partner[i].id, 6, i + 3, 4);
+                nullsub_5(gRfuLinkStatus->partner[i].uname, 0x16, i + 3);
+            }
+        }
+        for (; i < 4; i++)
+        {
+            nullsub_13(0, 1, i + 3, 4);
+            nullsub_5(gUnknown_082ED84B, 6, i + 3);
+            nullsub_5(gUnknown_082ED85B, 0x16, i + 3);
+        }
+    }
+}
+
+u32 sub_80124C0(void)
+{
+    return Rfu.unk_9e8.unk_232;
+}
+
+u32 GetRfuRecvQueueLength(void)
+{
+    return Rfu.unk_124.unk_8c2;
+}
diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c
new file mode 100644
index 000000000..535deeca6
--- /dev/null
+++ b/src/link_rfu_3.c
@@ -0,0 +1,938 @@
+#include "global.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "link_rfu.h"
+#include "string_util.h"
+#include "random.h"
+#include "text.h"
+#include "event_data.h"
+
+EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0;
+
+static u8 gUnknown_03000D74;
+
+const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal");
+const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz");
+
+const u8 sWireless_ASCIItoRSETable[] = {
+    0xff, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x37,
+    0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+    0x00, 0xab, 0xb5, 0xb6, 0xb1, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xb2, 0xf1, 0x00, 0xae, 0xad, 0xba,
+    0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
+    0xa9, 0xaa, 0x00, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1,
+    0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
+    0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
+    0xd2, 0xd3, 0xd4, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
+    0x00, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+    0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
+    0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
+    0xec, 0xed, 0xee, 0x2d, 0x2f, 0x30, 0x31, 0x32,
+    0x33, 0x34, 0x35, 0x36, 0x50, 0x00, 0x01, 0x02,
+    0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+    0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
+    0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
+    0x1b, 0xad, 0xb3, 0xb4, 0x00, 0xaf, 0x7d, 0x7f,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xa0,
+    0xae, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+    0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+    0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+    0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7e, 0xb0, 0xac,
+    0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
+    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
+    0x2c, 0x2e, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
+    0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94
+};
+
+const u8 sWireless_RSEtoASCIITable[] = {
+    0x20, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
+    0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94,
+    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c,
+    0x9d, 0x9e, 0x9f, 0xa0, 0xe0, 0xe1, 0xe2, 0xe3,
+    0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
+    0xec, 0xed, 0xee, 0xef, 0xf0, 0x7b, 0xf1, 0x7c,
+    0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x07,
+    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+    0x84, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xa6, 0xdd, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xf2,
+    0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
+    0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+    0xaf, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+    0x37, 0x38, 0x39, 0x21, 0xdf, 0xa1, 0xb0, 0xa5,
+    0xde, 0x24, 0x2a, 0xa2, 0xa3, 0x22, 0x23, 0x20,
+    0xa4, 0x20, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45,
+    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+    0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
+    0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63,
+    0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
+    0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
+    0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x20,
+    0x20, 0x2b, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00
+};
+
+const struct OamData sWirelessStatusIndicatorOamData =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(16x16),
+    .x = 0,
+    .size = SPRITE_SIZE(16x16),
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+};
+
+const union AnimCmd sWirelessStatusIndicatorAnim0[] = {
+    // 3 bars
+    ANIMCMD_FRAME( 4,  5),
+    ANIMCMD_FRAME( 8,  5),
+    ANIMCMD_FRAME(12,  5),
+    ANIMCMD_FRAME(16, 10),
+    ANIMCMD_FRAME(12,  5),
+    ANIMCMD_FRAME( 8,  5),
+    ANIMCMD_JUMP(0)
+};
+
+const union AnimCmd sWirelessStatusIndicatorAnim1[] = {
+    // 2 bars
+    ANIMCMD_FRAME( 4,  5),
+    ANIMCMD_FRAME( 8,  5),
+    ANIMCMD_FRAME(12, 10),
+    ANIMCMD_FRAME( 8,  5),
+    ANIMCMD_JUMP(0)
+};
+
+const union AnimCmd sWirelessStatusIndicatorAnim2[] = {
+    // 1 bar
+    ANIMCMD_FRAME(4, 5),
+    ANIMCMD_FRAME(8, 5),
+    ANIMCMD_JUMP(0)
+};
+
+const union AnimCmd sWirelessStatusIndicatorAnim3[] = {
+    // searching
+    ANIMCMD_FRAME( 4, 10),
+    ANIMCMD_FRAME(20, 10),
+    ANIMCMD_JUMP(0)
+};
+
+const union AnimCmd sWirelessStatusIndicatorAnim4[] = {
+    // error
+    ANIMCMD_FRAME(24, 10),
+    ANIMCMD_FRAME( 4, 10),
+    ANIMCMD_JUMP(0)
+};
+
+const union AnimCmd *const sWirelessStatusIndicatorAnims[] = {
+    sWirelessStatusIndicatorAnim0,
+    sWirelessStatusIndicatorAnim1,
+    sWirelessStatusIndicatorAnim2,
+    sWirelessStatusIndicatorAnim3,
+    sWirelessStatusIndicatorAnim4
+};
+
+const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = {
+    gWirelessLinkIconPic, 0x0380, 0xD431
+};
+
+const struct SpritePalette sWirelessStatusIndicatorSpritePalette = {
+    gWirelessLinkIconPalette, 0xD432
+};
+
+const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = {
+    0xD431,
+    0xD432,
+    &sWirelessStatusIndicatorOamData,
+    sWirelessStatusIndicatorAnims,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCallbackDummy
+};
+
+void sub_800D6C8(struct UnkRfuStruct_2_Sub_124 *ptr)
+{
+    s32 i;
+    s32 j;
+
+    for (i = 0; i < 32; i++)
+    {
+        for (j = 0; j < 70; j++)
+        {
+            ptr->unk_00[i][j] = 0;
+        }
+    }
+    ptr->unk_8c1 = 0;
+    ptr->unk_8c0 = 0;
+    ptr->unk_8c2 = 0;
+    ptr->unk_8c3 = 0;
+}
+
+void sub_800D724(struct UnkRfuStruct_2_Sub_9e8 *ptr)
+{
+    s32 i;
+    s32 j;
+
+    for (i = 0; i < 40; i++)
+    {
+        for (j = 0; j < 14; j++)
+        {
+            ptr->unk_00[i][j] = 0;
+        }
+    }
+    ptr->unk_231 = 0;
+    ptr->unk_230 = 0;
+    ptr->unk_232 = 0;
+    ptr->unk_233 = 0;
+}
+
+void sub_800D780(struct UnkRfuStruct_Sub_Unused *ptr)
+{
+    s32 i;
+    s32 j;
+
+    for (i = 0; i < 2; i++)
+    {
+        for (j = 0; j < 256; j++)
+        {
+            ptr->unk_00[i][j] = 0;
+        }
+    }
+    ptr->unk_201 = 0;
+    ptr->unk_200 = 0;
+    ptr->unk_202 = 0;
+    ptr->unk_203 = 0;
+}
+
+void sub_800D7D8(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
+{
+    s32 i;
+    u16 imeBak;
+    u8 count;
+
+    if (q1->unk_8c2 < 32)
+    {
+        imeBak = REG_IME;
+        REG_IME = 0;
+        count = 0;
+        for (i = 0; i < 70; i += 14)
+        {
+            if (q2[i] == 0 && q2[i + 1] == 0)
+            {
+                count++;
+            }
+        }
+        if (count != 5)
+        {
+            for (i = 0; i < 70; i++)
+            {
+                q1->unk_00[q1->unk_8c0][i] = q2[i];
+            }
+            q1->unk_8c0++;
+            q1->unk_8c0 %= 32;
+            q1->unk_8c2++;
+            for (i = 0; i < 70; i++)
+            {
+                q2[i] = 0;
+            }
+        }
+        REG_IME = imeBak;
+    }
+    else
+    {
+        q1->unk_8c3 = 1;
+    }
+}
+
+void sub_800D888(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
+{
+    s32 i;
+    u16 imeBak;
+
+    if (q1->unk_232 < 40)
+    {
+        imeBak = REG_IME;
+        REG_IME = 0;
+        for (i = 0; i < 14; i++)
+        {
+            if (q2[i] != 0)
+            {
+                break;
+            }
+        }
+        if (i != 14)
+        {
+            for (i = 0; i < 14; i++)
+            {
+                q1->unk_00[q1->unk_230][i] = q2[i];
+            }
+            q1->unk_230++;
+            q1->unk_230 %= 40;
+            q1->unk_232++;
+            for (i = 0; i < 14; i++)
+            {
+                q2[i] = 0;
+            }
+        }
+        REG_IME = imeBak;
+    }
+    else
+    {
+        q1->unk_233 = 1;
+    }
+}
+
+bool8 sub_800D934(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2)
+{
+    u16 imeBak;
+    s32 i;
+
+    imeBak = REG_IME;
+    REG_IME = 0;
+    if (q1->unk_8c0 == q1->unk_8c1 || q1->unk_8c3 != 0)
+    {
+        for (i = 0; i < 70; i++)
+        {
+            q2[i] = 0;
+        }
+        REG_IME = imeBak;
+        return FALSE;
+    }
+    for (i = 0; i < 70; i++)
+    {
+        q2[i] = q1->unk_00[q1->unk_8c1][i];
+    }
+    q1->unk_8c1++;
+    q1->unk_8c1 %= 32;
+    q1->unk_8c2--;
+    REG_IME = imeBak;
+    return TRUE;
+}
+
+bool8 sub_800D9DC(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2)
+{
+    s32 i;
+    u16 imeBak;
+
+    if (q1->unk_230 == q1->unk_231 || q1->unk_233 != 0)
+    {
+        return FALSE;
+    }
+    imeBak = REG_IME;
+    REG_IME = 0;
+    for (i = 0; i < 14; i++)
+    {
+        q2[i] = q1->unk_00[q1->unk_231][i];
+    }
+    q1->unk_231++;
+    q1->unk_231 %= 40;
+    q1->unk_232--;
+    REG_IME = imeBak;
+    return TRUE;
+}
+
+void sub_800DA68(struct UnkRfuStruct_2_Sub_c1c *q1, const u8 *q2)
+{
+    s32 i;
+
+    if (q2[1] == 0)
+    {
+        sub_800DAC8(q1, NULL);
+    }
+    else
+    {
+        for (i = 0; i < 14; i++)
+        {
+            q1->unk_00[q1->unk_1c][i] = q2[i];
+        }
+        q1->unk_1c++;
+        q1->unk_1c %= 2;
+        if (q1->unk_1e < 2)
+        {
+            q1->unk_1e++;
+        }
+        else
+        {
+            q1->unk_1d = q1->unk_1c;
+        }
+    }
+}
+
+bool8 sub_800DAC8(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2)
+{
+    s32 i;
+
+    if (q1->unk_1e == 0)
+    {
+        return FALSE;
+    }
+    if (q2 != NULL)
+    {
+        for (i = 0; i < 14; i++)
+        {
+            q2[i] = q1->unk_00[q1->unk_1d][i];
+        }
+    }
+    q1->unk_1d++;
+    q1->unk_1d %= 2;
+    q1->unk_1e--;
+    return TRUE;
+}
+
+void sub_800DB18(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
+{
+    s32 i;
+
+    if (q1->unk_202 < 2)
+    {
+        for (i = 0; i < 256; i++)
+        {
+            q1->unk_00[q1->unk_200][i] = q2[i];
+        }
+        q1->unk_200++;
+        q1->unk_200 %= 2;
+        q1->unk_202++;
+    }
+    else
+    {
+        q1->unk_203 = 1;
+    }
+}
+
+bool8 sub_800DB84(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2)
+{
+    s32 i;
+
+    if (q1->unk_200 == q1->unk_201 || q1->unk_203)
+    {
+        return FALSE;
+    }
+    for (i = 0; i < 256; i++)
+    {
+        q2[i] = q1->unk_00[q1->unk_201][i];
+    }
+    q1->unk_201++;
+    q1->unk_201 %= 2;
+    q1->unk_202--;
+    return TRUE;
+}
+
+void sub_800DBF8(u8 *q1, u8 mode)
+{
+    s32 i;
+    u8 rval;
+    u16 r5 = 0;
+    switch (mode)
+    {
+    case 0:
+        for (i = 0; i < 200; i++)
+        {
+            q1[i] = i + 1;
+            r5 += i + 1;
+        }
+        *((u16 *)(q1 + i)) = r5;
+        break;
+    case 1:
+        for (i = 0; i < 100; i++)
+        {
+            q1[i] = i + 1;
+            r5 += i + 1;
+        }
+        *((u16 *)(q1 + 200)) = r5;
+        break;
+    case 2:
+        for (i = 0; i < 200; i++)
+        {
+            rval = Random();
+            q1[i] = rval;
+            r5 += rval;
+        }
+        *((u16 *)(q1 + i)) = r5;
+        break;
+    case 3:
+        for (i = 0; i < 200; i++)
+        {
+            q1[i] = i + 1 + gUnknown_03000D74;
+            r5 += (i + 1 + gUnknown_03000D74) & 0xFF;
+        }
+        *((u16 *)(q1 + i)) = r5;
+        gUnknown_03000D74++;
+        break;
+    }
+}
+
+// File boundary here maybe?
+
+void PkmnStrToASCII(u8 *q1, const u8 *q2)
+{
+    s32 i;
+
+    for (i = 0; q2[i] != EOS; i++)
+    {
+        q1[i] = sWireless_RSEtoASCIITable[q2[i]];
+    }
+    q1[i] = 0;
+}
+
+void ASCIIToPkmnStr(u8 *q1, const u8 *q2)
+{
+    s32 i;
+
+    for (i = 0; q2[i] != 0; i++)
+    {
+        q1[i] = sWireless_ASCIItoRSETable[q2[i]];
+    }
+    q1[i] = EOS;
+}
+
+#ifdef NONMATCHING
+u8 sub_800DD1C(u8 maxFlags)
+{
+    u8 flagCount = 0;
+    u32 flags = gRfuLinkStatus->connSlotFlag;
+    u8 i;
+
+    if (gRfuLinkStatus->parentChild == 1)
+    {
+        for (i = 0; i < 4; flags >>= 1, i++)
+        {
+            if (flags & 1)
+            {
+                if (maxFlags == flagCount + 1)
+                    return gRfuLinkStatus->strength[i];
+                flagCount++;
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < 4; flags >>= 1, i++)
+        {
+            if (flags & 1)
+                return gRfuLinkStatus->strength[i];
+        }
+    }
+    return 0;
+}
+#else
+NAKED u8 sub_800DD1C(u8 maxFlags)
+{
+    asm_unified("\tpush {r4-r7,lr}\n"
+                "\tlsls r0, 24\n"
+                "\tlsrs r5, r0, 24\n"
+                "\tmovs r6, 0\n"
+                "\tldr r0, =gRfuLinkStatus\n"
+                "\tldr r4, [r0]\n"
+                "\tldrb r2, [r4, 0x2]\n"
+                "\tldrb r1, [r4]\n"
+                "\tadds r7, r0, 0\n"
+                "\tcmp r1, 0x1\n"
+                "\tbne _0800DD72\n"
+                "\tmovs r3, 0\n"
+                "\tands r1, r2\n"
+                "\tcmp r1, 0\n"
+                "\tbeq _0800DD4E\n"
+                "\tcmp r5, 0x1\n"
+                "\tbne _0800DD48\n"
+                "\tldrb r0, [r4, 0xA]\n"
+                "\tb _0800DD8C\n"
+                "\t.pool\n"
+                "_0800DD48:\n"
+                "\tadds r0, r6, 0x1\n"
+                "\tlsls r0, 24\n"
+                "\tlsrs r6, r0, 24\n"
+                "_0800DD4E:\n"
+                "\tlsrs r2, 1\n"
+                "\tadds r0, r3, 0x1\n"
+                "\tlsls r0, 24\n"
+                "\tlsrs r3, r0, 24\n"
+                "\tcmp r3, 0x3\n"
+                "\tbhi _0800DD8A\n"
+                "\tmovs r0, 0x1\n"
+                "\tands r0, r2\n"
+                "\tcmp r0, 0\n"
+                "\tbeq _0800DD4E\n"
+                "\tadds r0, r6, 0x1\n"
+                "\tcmp r5, r0\n"
+                "\tbne _0800DD48\n"
+                "_0800DD68:\n"
+                "\tldr r0, [r7]\n"
+                "\tadds r0, 0xA\n"
+                "\tadds r0, r3\n"
+                "\tldrb r0, [r0]\n"
+                "\tb _0800DD8C\n"
+                "_0800DD72:\n"
+                "\tmovs r3, 0\n"
+                "\tmovs r1, 0x1\n"
+                "_0800DD76:\n"
+                "\tadds r0, r2, 0\n"
+                "\tands r0, r1\n"
+                "\tcmp r0, 0\n"
+                "\tbne _0800DD68\n"
+                "\tlsrs r2, 1\n"
+                "\tadds r0, r3, 0x1\n"
+                "\tlsls r0, 24\n"
+                "\tlsrs r3, r0, 24\n"
+                "\tcmp r3, 0x3\n"
+                "\tbls _0800DD76\n"
+                "_0800DD8A:\n"
+                "\tmovs r0, 0\n"
+                "_0800DD8C:\n"
+                "\tpop {r4-r7}\n"
+                "\tpop {r1}\n"
+                "\tbx r1");
+}
+#endif
+
+void sub_800DD94(struct GFtgtGname *data, u8 r9, bool32 r2, s32 r3)
+{
+    s32 i;
+
+    for (i = 0; i < 2; i++)
+    {
+        data->unk_00.playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i];
+    }
+    for (i = 0; i < 4; i++)
+    {
+        data->child_sprite_gender[i] = r3;
+        r3 >>= 8;
+    }
+    data->playerGender = gSaveBlock2Ptr->playerGender;
+    data->activity = r9;
+    data->started = r2;
+    data->unk_00.language = GAME_LANGUAGE;
+    data->unk_00.version = GAME_VERSION;
+    data->unk_00.hasNews = 0;
+    data->unk_00.hasCard = 0;
+    data->unk_00.unk_00_6 = 0;
+    data->unk_00.isChampion = FlagGet(FLAG_IS_CHAMPION);
+    data->unk_00.hasNationalDex = IsNationalPokedexEnabled();
+    data->unk_00.gameClear = FlagGet(FLAG_SYS_GAME_CLEAR);
+}
+
+bool8 sub_800DE7C(struct GFtgtGname *buff1, u8 *buff2, u8 idx)
+{
+    bool8 retVal;
+
+    if (lman.parent_child == 1)
+    {
+        retVal = TRUE;
+        if (sub_8010454(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1))
+        {
+            memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
+            memcpy(buff2, gRfuLinkStatus->partner[idx].uname, PLAYER_NAME_LENGTH + 1);
+        }
+        else
+        {
+            memset(buff1, 0, 0xD);
+            memset(buff2, 0, PLAYER_NAME_LENGTH + 1);
+        }
+    }
+    else
+    {
+        retVal = FALSE;
+        if (sub_8010454(gRfuLinkStatus->partner[idx].serialNo))
+        {
+            memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
+            memcpy(buff2, gRfuLinkStatus->partner[idx].uname, PLAYER_NAME_LENGTH + 1);
+        }
+        else
+        {
+            memset(buff1, 0, 0xD);
+            memset(buff2, 0, PLAYER_NAME_LENGTH + 1);
+        }
+    }
+    return retVal;
+}
+
+bool8 sub_800DF34(struct GFtgtGname *buff1, u8 *buff2, u8 idx)
+{
+    bool8 retVal = FALSE;
+    if (gRfuLinkStatus->partner[idx].serialNo == 0x7F7D)
+    {
+        memcpy(buff1, gRfuLinkStatus->partner[idx].gname, 0xD);
+        memcpy(buff2, gRfuLinkStatus->partner[idx].uname, 8);
+        retVal = TRUE;
+    }
+    else
+    {
+        memset(buff1, 0, 0xD);
+        memset(buff2, 0, 8);
+    }
+    return retVal;
+}
+
+void sub_800DF90(struct GFtgtGname *buff1, u8 *buff2)
+{
+    memcpy(buff1, &gUnknown_02022B14, 0xD);
+    memcpy(buff2, gUnknown_02022B22, 8);
+}
+
+void CreateWirelessStatusIndicatorSprite(u8 x, u8 y)
+{
+    u8 sprId;
+
+    if (x == 0 && y == 0)
+    {
+        x = 0xE7;
+        y = 0x08;
+    }
+    if (gRfuLinkStatus->parentChild == 1)
+    {
+        sprId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0);
+        gSprites[sprId].data[7] = 0x1234;
+        gSprites[sprId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag);
+        gSprites[sprId].invisible = TRUE;
+        gWirelessStatusIndicatorSpriteId = sprId;
+    }
+    else
+    {
+        gWirelessStatusIndicatorSpriteId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0);
+        gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0x1234;
+        gSprites[gWirelessStatusIndicatorSpriteId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag);
+        gSprites[gWirelessStatusIndicatorSpriteId].invisible = TRUE;
+    }
+}
+
+void DestroyWirelessStatusIndicatorSprite(void)
+{
+    if (gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234)
+    {
+        gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0;
+        DestroySprite(&gSprites[gWirelessStatusIndicatorSpriteId]);
+        gMain.oamBuffer[125] = gDummyOamData;
+        CpuCopy16(&gDummyOamData, (struct OamData *)OAM + 125, sizeof(struct OamData));
+    }
+}
+
+void LoadWirelessStatusIndicatorSpriteGfx(void)
+{
+    if (GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag) == 0xFFFF)
+    {
+        LoadCompressedSpriteSheet(&sWirelessStatusIndicatorSpriteSheet);
+    }
+    LoadSpritePalette(&sWirelessStatusIndicatorSpritePalette);
+    gWirelessStatusIndicatorSpriteId = 0xFF;
+}
+
+u8 sub_800E124(void)
+{
+    u8 i;
+    u8 flags = gRfuLinkStatus->connSlotFlag;
+    for (i = 0; i < 4; i++)
+    {
+        if (flags & 1)
+        {
+            return gRfuLinkStatus->strength[i];
+        }
+        flags >>= 1;
+    }
+    return 0;
+}
+
+void sub_800E15C(struct Sprite *sprite, s32 signalStrengthAnimNum)
+{
+    if (sprite->data[2] != signalStrengthAnimNum)
+    {
+        sprite->data[2] = signalStrengthAnimNum;
+        sprite->data[3] = 0;
+        sprite->data[4] = 0;
+    }
+}
+
+void sub_800E174(void)
+{
+    if (gWirelessStatusIndicatorSpriteId != 0xFF && gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234)
+    {
+        struct Sprite *sprite = &gSprites[gWirelessStatusIndicatorSpriteId];
+        u8 signalStrength = 255;
+        u8 i = 0;
+        if (gRfuLinkStatus->parentChild == 1)
+        {
+            for (i = 0; i < GetLinkPlayerCount() - 1; i++)
+            {
+                if (signalStrength >= sub_800DD1C(i + 1))
+                {
+                    signalStrength = sub_800DD1C(i + 1);
+                }
+            }
+        }
+        else
+        {
+            signalStrength = sub_800E124();
+        }
+        if (sub_8012224() == TRUE)
+        {
+            sprite->data[0] = 4;
+        }
+        else if (signalStrength < 25)
+        {
+            sprite->data[0] = 3;
+        }
+        else if (signalStrength >= 25 && signalStrength < 127)
+        {
+            sprite->data[0] = 2;
+        }
+        else if (signalStrength >= 127 && signalStrength < 229)
+        {
+            sprite->data[0] = 1;
+        }
+        else if (signalStrength >= 229)
+        {
+            sprite->data[0] = 0;
+        }
+        if (sprite->data[0] != sprite->data[1])
+        {
+            sub_800E15C(sprite, sprite->data[0]);
+            sprite->data[1] = sprite->data[0];
+        }
+        if (sprite->anims[sprite->data[2]][sprite->data[4]].frame.duration < sprite->data[3])
+        {
+            sprite->data[4]++;
+            sprite->data[3] = 0;
+            if (sprite->anims[sprite->data[2]][sprite->data[4]].type == -2)
+            {
+                sprite->data[4] = 0;
+            }
+        }
+        else
+        {
+            sprite->data[3]++;
+        }
+        gMain.oamBuffer[125] = sWirelessStatusIndicatorOamData;
+        gMain.oamBuffer[125].x = sprite->pos1.x + sprite->centerToCornerVecX;
+        gMain.oamBuffer[125].y = sprite->pos1.y + sprite->centerToCornerVecY;
+        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_8011A74() == 1)
+        {
+            DestroyWirelessStatusIndicatorSprite();
+        }
+    }
+}
+
+void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 *name)
+{
+    dest->trainerId = trainerId;
+    StringCopy(dest->trainerName, name);
+}
+
+bool32 NameIsNotEmpty(const u8 *name)
+{
+    s32 i;
+
+    for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++)
+    {
+        if (name[i] != 0)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+// Save the currently connected players into the trainer records, shifting all previous records down.
+void RecordMixTrainerNames(void)
+{
+    if (gWirelessCommType != 0)
+    {
+        s32 i;
+        s32 j;
+        s32 nextSpace;
+        s32 connectedTrainerRecordIndices[5];
+        struct TrainerNameRecord *newRecords = calloc(20, sizeof(struct TrainerNameRecord));
+
+        // Check if we already have a record saved for connected trainers.
+        for (i = 0; i < GetLinkPlayerCount(); i++)
+        {
+            connectedTrainerRecordIndices[i] = -1;
+            for (j = 0; j < 20; j++)
+            {
+                if ((u16)gLinkPlayers[i].trainerId ==  gSaveBlock1Ptr->trainerNameRecords[j].trainerId && StringCompare(gLinkPlayers[i].name, gSaveBlock1Ptr->trainerNameRecords[j].trainerName) == 0)
+                {
+                    connectedTrainerRecordIndices[i] = j;
+                }
+            }
+        }
+
+        // Save the connected trainers first, at the top of the list.
+        nextSpace = 0;
+        for (i = 0; i < GetLinkPlayerCount(); i++)
+        {
+            if (i != GetMultiplayerId() && gLinkPlayers[i].language != LANGUAGE_JAPANESE)
+            {
+                CopyTrainerRecord(&newRecords[nextSpace], (u16)gLinkPlayers[i].trainerId, gLinkPlayers[i].name);
+
+                // If we already had a record for this trainer, wipe it so that the next step doesn't duplicate it.
+                if (connectedTrainerRecordIndices[i] >= 0)
+                {
+                    memset(gSaveBlock1Ptr->trainerNameRecords[connectedTrainerRecordIndices[i]].trainerName, 0, 8);
+                }
+                nextSpace++;
+            }
+        }
+
+        // Copy all non-empty records to the new list, in the order they appear on the old list. If the list is full,
+        // the last (oldest) records will be dropped.
+        for (i = 0; i < 20; i++)
+        {
+            if (NameIsNotEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName))
+            {
+                CopyTrainerRecord(&newRecords[nextSpace], gSaveBlock1Ptr->trainerNameRecords[i].trainerId, gSaveBlock1Ptr->trainerNameRecords[i].trainerName);
+                if (++nextSpace >= 20)
+                {
+                    break;
+                }
+            }
+        }
+
+        // Finalize the new list, and clean up.
+        memcpy(gSaveBlock1Ptr->trainerNameRecords, newRecords, 20 * sizeof(struct TrainerNameRecord));
+        free(newRecords);
+    }
+}
+
+bool32 sub_800E540(u16 id, u8 *name)
+{
+    s32 i;
+
+    for (i = 0; i < 20; i++)
+    {
+        if (StringCompare(gSaveBlock1Ptr->trainerNameRecords[i].trainerName, name) == 0 && gSaveBlock1Ptr->trainerNameRecords[i].trainerId == id)
+        {
+            return TRUE;
+        }
+        if (!NameIsNotEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName))
+        {
+            return FALSE;
+        }
+    }
+    return FALSE;
+}
+
+void WipeTrainerNameRecords(void)
+{
+    s32 i;
+
+    for (i = 0; i < 20; i++)
+    {
+        gSaveBlock1Ptr->trainerNameRecords[i].trainerId = 0;
+        CpuFill16(0, gSaveBlock1Ptr->trainerNameRecords[i].trainerName, 8);
+    }
+}
diff --git a/src/overworld.c b/src/overworld.c
index 0e5ed8165..ec43a3e80 100644
--- a/src/overworld.c
+++ b/src/overworld.c
@@ -2913,7 +2913,7 @@ bool32 sub_808766C(void)
 static u32 GetLinkSendQueueLength(void)
 {
     if (gWirelessCommType != 0)
-        return gUnknown_03005000.unk_9e8.unk_232;
+        return Rfu.unk_9e8.unk_232;
     else
         return gLink.sendQueue.count;
 }
diff --git a/src/party_menu.c b/src/party_menu.c
index 4decdeb02..8e1a735ab 100755
--- a/src/party_menu.c
+++ b/src/party_menu.c
@@ -3527,7 +3527,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 UnkLinkRfuStruct_02022B14Substruct *)sub_800F7DC(), species2, species, obedience))
+    switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)sub_800F7DC(), species2, species, obedience))
     {
     case CANT_REGISTER_MON:
         StringExpandPlaceholders(gStringVar4, gText_PkmnCantBeTradedNow);
@@ -3553,7 +3553,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 UnkLinkRfuStruct_02022B14Substruct *)sub_800F7DC(), gUnknown_02022C38, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience);
+    u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)sub_800F7DC(), gUnknown_02022C38, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience);
 
     if (stringId != UR_TRADE_MSG_NONE)
     {
diff --git a/src/pokemon_jump.c b/src/pokemon_jump.c
index c7ce6ddf7..1a1dab13c 100755
--- a/src/pokemon_jump.c
+++ b/src/pokemon_jump.c
@@ -2040,7 +2040,7 @@ static int sub_802C6B0(void)
 
 static bool32 sub_802C70C(void)
 {
-    return !gUnknown_03005000.unk_124.unk_8c2 && !gUnknown_03005000.unk_9e8.unk_232;
+    return !Rfu.unk_124.unk_8c2 && !Rfu.unk_9e8.unk_232;
 }
 
 static int sub_802C73C(u8 *arg0)
diff --git a/src/trade.c b/src/trade.c
index bd97471e3..37a63eb4b 100644
--- a/src/trade.c
+++ b/src/trade.c
@@ -236,7 +236,7 @@ static bool8 SendLinkData(const void *linkData, u32 size)
 {
     if (gUnknown_02022C2C == 29)
     {
-        rfu_NI_setSendData(gUnknown_03004140.unk_00, 84, linkData, size);
+        rfu_NI_setSendData(lman.acceptSlot_flag, 84, linkData, size);
         return TRUE;
     }
     else
@@ -254,7 +254,7 @@ static bool32 sub_80771BC(void)
 {
     if (gUnknown_02022C2C == 29)
     {
-        if (gRfuSlotStatusNI[sub_800E87C(gUnknown_03004140.unk_00)]->send.state == 0)
+        if (gRfuSlotStatusNI[sub_800E87C(lman.acceptSlot_flag)]->send.state == 0)
             return TRUE;
         else
             return FALSE;
@@ -273,7 +273,7 @@ static u32 _GetBlockReceivedStatus(void)
 static void TradeResetReceivedFlags(void)
 {
     if (IsWirelessTrade())
-        rfu_clearSlot(12, gUnknown_03004140.unk_00);
+        rfu_clearSlot(12, lman.acceptSlot_flag);
     else
         ResetBlockReceivedFlags();
 }
@@ -281,7 +281,7 @@ static void TradeResetReceivedFlags(void)
 static void TradeResetReceivedFlag(u32 who)
 {
     if (IsWirelessTrade())
-        rfu_clearSlot(12, gUnknown_03004140.unk_00);
+        rfu_clearSlot(12, lman.acceptSlot_flag);
     else
         ResetBlockReceivedFlag(who);
 }
@@ -2405,15 +2405,15 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet)
     return FALSE;
 }
 
-int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct rfuPlayer, struct UnkLinkRfuStruct_02022B14Substruct rfuPartner, u16 playerSpecies2, u16 partnerSpecies, u8 requestedType, u16 playerSpecies, u8 isObedientBitSet)
+int GetUnionRoomTradeMessageId(struct GFtgtGnameSub rfuPlayer, struct GFtgtGnameSub rfuPartner, u16 playerSpecies2, u16 partnerSpecies, u8 requestedType, u16 playerSpecies, u8 isObedientBitSet)
 {
     bool8 playerHasNationalDex = rfuPlayer.hasNationalDex;
     bool8 playerIsChampion = rfuPlayer.isChampion;
     bool8 partnerHasNationalDex = rfuPartner.hasNationalDex;
     bool8 partnerIsChampion = rfuPartner.isChampion;
-    u8 r1 = rfuPartner.unk_01_2;
+    u8 r1 = rfuPartner.version;
 
-    if (r1 != 3)
+    if (r1 != VERSION_EMERALD)
     {
         if (!playerIsChampion)
         {
@@ -2476,7 +2476,7 @@ int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct rfuPlay
     return UR_TRADE_MSG_NONE;
 }
 
-int CanRegisterMonForTradingBoard(struct UnkLinkRfuStruct_02022B14Substruct rfuPlayer, u16 species2, u16 species, u8 isObedientBitSet)
+int CanRegisterMonForTradingBoard(struct GFtgtGnameSub rfuPlayer, u16 species2, u16 species, u8 isObedientBitSet)
 {
     bool8 hasNationalDex = rfuPlayer.hasNationalDex;
 
diff --git a/src/union_room.c b/src/union_room.c
index a3ac02797..be4dc8dab 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -59,7 +59,7 @@ EWRAM_DATA u8 gUnknown_02022C2C = 0;
 EWRAM_DATA u8 gUnknown_02022C2D = 0;
 EWRAM_DATA union UnkUnion_Main gUnknown_02022C30 = {};
 EWRAM_DATA u32 gFiller_02022C34 = 0;
-EWRAM_DATA struct UnkLinkRfuStruct_02022B14Substruct gUnknown_02022C38 = {};
+EWRAM_DATA struct GFtgtGnameSub gUnknown_02022C38 = {};
 EWRAM_DATA u16 gUnionRoomOfferedSpecies = 0;
 EWRAM_DATA u8 gUnionRoomRequestedMonType = 0;
 static EWRAM_DATA struct UnionRoomTrade sUnionRoomTrade = {};
@@ -106,7 +106,7 @@ void sub_801AC54(void);
 void sub_80149D8(void);
 void MG_DrawTextBorder(u8 windowId);
 s8 mevent_message_print_and_prompt_yes_no(u8 *textState, u8 *arg1, u8 arg2, const u8 *str);
-bool32 sub_8016F1C(struct UnkLinkRfuStruct_02022B14 *arg0, s16 arg1);
+bool32 sub_8016F1C(struct GFtgtGname *arg0, s16 arg1);
 u8 sub_8016DF0(struct UnkStruct_Main4 *arg0, struct UnkStruct_Main4 *arg1, u32 arg2);
 void sub_8019F2C(void);
 static bool32 RegisterTradeMonAndGetIsEgg(u32 monId, struct UnionRoomTrade *trade);
@@ -875,9 +875,9 @@ void sub_80134E8(u8 taskId)
             {
                 // this unused variable along with the assignment is needed to match
                 u32 unusedVar;
-                unusedVar  = data->field_0->arr[id].unk.field_0.unk_0a_0;
+                unusedVar  = data->field_0->arr[id].unk.field_0.activity;
 
-                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.field_0.unk_0a_7)
+                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.field_0.started)
                 {
                     u32 var = sub_8013B8C(data, id);
                     if (var == 0)
@@ -919,7 +919,7 @@ void sub_80134E8(u8 taskId)
     case 6:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.unk_0a_0;
+            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.activity;
             sub_8011A64(0, 0);
             switch (gUnknown_02022C2C)
             {
@@ -1078,7 +1078,7 @@ u32 sub_8013B8C(struct UnkStruct_Group *arg0, s32 id)
 {
     struct UnkStruct_x20 *structPtr = &arg0->field_0->arr[id];
 
-    if (gUnknown_02022C2C == 4 && structPtr->unk.field_0.unk_00.unk_01_2 != 3)
+    if (gUnknown_02022C2C == 4 && structPtr->unk.field_0.unk_00.version != VERSION_EMERALD)
     {
         if (!(gSaveBlock2Ptr->specialSaveWarpFlags & CHAMPION_SAVEWARP))
             return 1;
@@ -1187,7 +1187,7 @@ u8 sub_8013DBC(struct UnkStruct_Group *data, u32 id)
 {
     if (data->field_0->arr[id].field_1A_0 == 1)
     {
-        if (data->field_0->arr[id].unk.field_0.unk_0a_7)
+        if (data->field_0->arr[id].unk.field_0.started)
             return 3;
         else if (data->field_0->arr[id].field_1A_1 != 0)
             return 1;
@@ -1946,9 +1946,9 @@ void sub_8014F48(u8 taskId)
             {
                 // this unused variable along with the assignment is needed to match
                 u32 unusedVar;
-                unusedVar  = data->field_0->arr[id].unk.field_0.unk_0a_0;
+                unusedVar  = data->field_0->arr[id].unk.field_0.activity;
 
-                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.field_0.unk_0a_7)
+                if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.field_0.started)
                 {
                     data->field_F = id;
                     LoadWirelessStatusIndicatorSpriteGfx();
@@ -1979,7 +1979,7 @@ void sub_8014F48(u8 taskId)
     case 5:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.unk_0a_0;
+            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.activity;
             data->state = 10;
         }
 
@@ -2108,7 +2108,7 @@ void sub_80152F4(u8 taskId)
                 id = ListMenu_ProcessInput(data->listTaskId);
             if (data->field_14 > 120)
             {
-                if (data->field_0->arr[0].field_1A_0 == 1 && !data->field_0->arr[0].unk.field_0.unk_0a_7)
+                if (data->field_0->arr[0].field_1A_0 == 1 && !data->field_0->arr[0].unk.field_0.started)
                 {
                     if (sub_8016F1C(&data->field_0->arr[0].unk.field_0, data->field_12 + 7))
                     {
@@ -2144,7 +2144,7 @@ void sub_80152F4(u8 taskId)
     case 5:
         if (gReceivedRemoteLinkPlayers != 0)
         {
-            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.unk_0a_0;
+            gUnknown_02022C2C = data->field_0->arr[data->field_F].unk.field_0.activity;
             data->state = 12;
         }
 
@@ -3250,11 +3250,11 @@ void sub_8016CA0(u8 taskId)
     for (i = 0; i < 4; i++)
     {
         r4 = sub_800DE7C(&sp0.field_0, sp0.playerName, i);
-        if (!sub_8013D88(sp0.field_0.unk_0a_0, gTasks[taskId].data[4]))
+        if (!sub_8013D88(sp0.field_0.activity, gTasks[taskId].data[4]))
         {
             sp0 = gUnknown_082F045C;
         }
-        if (sp0.field_0.unk_00.unk_00_0 == 1)
+        if (sp0.field_0.unk_00.language == 1)
         {
             sp0 = gUnknown_082F045C;
         }
@@ -3296,7 +3296,7 @@ void sub_8016E24(u8 taskId)
     for (i = 0; i < 4; i++)
     {
         sub_800DE7C(&ptr[0]->arr[i].unk0.field_0, ptr[0]->arr[i].unk0.playerName, i);
-        if (!sub_8013D88(ptr[0]->arr[i].unk0.field_0.unk_0a_0, gTasks[taskId].data[2]))
+        if (!sub_8013D88(ptr[0]->arr[i].unk0.field_0.activity, gTasks[taskId].data[2]))
         {
             ptr[0]->arr[i].unk0 = gUnknown_082F045C;
         }
@@ -3311,11 +3311,11 @@ void sub_8016E24(u8 taskId)
     }
 }
 
-bool32 sub_8016F1C(struct UnkLinkRfuStruct_02022B14 *arg0, s16 arg1)
+bool32 sub_8016F1C(struct GFtgtGname *arg0, s16 arg1)
 {
     if (arg1 == 7)
     {
-        if (!arg0->unk_00.unk_00_5)
+        if (!arg0->unk_00.hasCard)
         {
             return FALSE;
         }
@@ -3326,7 +3326,7 @@ bool32 sub_8016F1C(struct UnkLinkRfuStruct_02022B14 *arg0, s16 arg1)
     }
     else if (arg1 == 8)
     {
-        if (!arg0->unk_00.unk_00_4)
+        if (!arg0->unk_00.hasNews)
         {
             return FALSE;
         }
@@ -3703,19 +3703,19 @@ bool32 sub_8017678(struct UnkStruct_Shared *arg0, struct UnkStruct_Shared *arg1)
 {
     s32 i;
 
-    if (arg0->field_0.unk_0a_0 != arg1->field_0.unk_0a_0)
+    if (arg0->field_0.activity != arg1->field_0.activity)
     {
         return TRUE;
     }
 
-    if (arg0->field_0.unk_0a_7 != arg1->field_0.unk_0a_7)
+    if (arg0->field_0.started != arg1->field_0.started)
     {
         return TRUE;
     }
 
     for (i = 0; i < 4; i++)
     {
-        if (arg0->field_0.unk_04[i] != arg1->field_0.unk_04[i])
+        if (arg0->field_0.child_sprite_gender[i] != arg1->field_0.child_sprite_gender[i])
         {
             return TRUE;
         }
@@ -3783,7 +3783,7 @@ void sub_80177B8(u8 arg0, u8 arg1, u8 arg2, struct UnkStruct_x20 *arg3, u8 arg4,
     StringAppend(gStringVar4, sText_Colon);
     sub_80173E0(arg0, 1, gStringVar4, arg1, arg2, 0);
     arg1 += 18;
-    r2 = arg3->unk.field_0.unk_0a_0;
+    r2 = arg3->unk.field_0.activity;
     if (arg3->field_1A_0 == 1 && !(r2 & 0x40))
     {
         sub_8018404(gStringVar4, arg3);
@@ -3859,11 +3859,11 @@ s32 sub_80179D4(struct UnkStruct_Main0 *arg0, u8 arg1, u8 arg2, u32 playerGender
 
     struct UnkStruct_x20 * r5 = &arg0->arr[arg2];
 
-    if (!r5->unk.field_0.unk_0a_7 && arg1 == 0)
+    if (!r5->unk.field_0.started && arg1 == 0)
     {
         sub_8018404(gStringVar1, r5);
         r2 = sub_800E540(ReadAsU16(r5->unk.field_0.unk_00.playerTrainerId), gStringVar1);
-        if (r5->unk.field_0.unk_0a_0 == 0x45)
+        if (r5->unk.field_0.activity == 0x45)
         {
             StringExpandPlaceholders(gStringVar4, sJoinChatTexts[r2][playerGender]);
             return 2;
@@ -3881,7 +3881,7 @@ s32 sub_80179D4(struct UnkStruct_Main0 *arg0, u8 arg1, u8 arg2, u32 playerGender
         {
             playerGender = (r5->unk.field_0.unk_00.playerTrainerId[arg1 + 1] >> 3) & 1;
         }
-        switch (r5->unk.field_0.unk_0a_0 & 0x3F)
+        switch (r5->unk.field_0.activity & 0x3F)
         {
         case 1:
             StringExpandPlaceholders(gStringVar4, sBattleReactionTexts[playerGender][Random() % 4]);
@@ -3908,7 +3908,7 @@ void nullsub_14(u8 windowId, s32 itemId, u8 y)
 
 }
 
-void sub_8017B3C(u8 arg0, u8 arg1, struct UnkLinkRfuStruct_02022B14 * arg2, const u8 * str, u8 arg4)
+void sub_8017B3C(u8 arg0, u8 arg1, struct GFtgtGname * arg2, const u8 * str, u8 arg4)
 {
     u8 sp8[4];
     u16 r8 = arg2->species;
@@ -3932,7 +3932,7 @@ void sub_8017B3C(u8 arg0, u8 arg1, struct UnkLinkRfuStruct_02022B14 * arg2, cons
 void sub_8017BE8(u8 windowId, s32 itemId, u8 y)
 {
     struct UnkStruct_Leader *leader = gUnknown_02022C30.leader;
-    struct UnkLinkRfuStruct_02022B14 *rfu;
+    struct GFtgtGname *rfu;
     s32 i, j;
     u8 sp4[11];
 
@@ -4340,5 +4340,5 @@ void sub_8018220(u8 *unused, struct UnkStruct_URoom *arg1, bool8 arg2)
 void sub_8018404(u8 *dest, struct UnkStruct_x20 *arg1)
 {
     StringCopy7(dest, arg1->unk.playerName);
-    ConvertInternationalString(dest, arg1->unk.field_0.unk_00.unk_00_0);
+    ConvertInternationalString(dest, arg1->unk.field_0.unk_00.language);
 }
diff --git a/src/union_room_battle.c b/src/union_room_battle.c
index b49406eac..c80340da3 100644
--- a/src/union_room_battle.c
+++ b/src/union_room_battle.c
@@ -369,7 +369,7 @@ static void sub_801A8B0(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 m
 u32 sub_801A960(struct UnkStruct_x20 * a0, u32 * a1)
 {
     s32 i, j, r2;
-    u32 result = a0->unk.field_0.unk_0a_0;
+    u32 result = a0->unk.field_0.activity;
 
     for (i = 0; i < (unsigned)ARRAY_COUNT(gUnknown_082F0D70); i++)
     {
@@ -386,7 +386,7 @@ u32 sub_801A960(struct UnkStruct_x20 * a0, u32 * a1)
             r2 = 0;
             for (j = 0; j < 4; j++)
             {
-                if (a0->unk.field_0.unk_04[j] != 0)
+                if (a0->unk.field_0.child_sprite_gender[j] != 0)
                 {
                     r2++;
                 }
diff --git a/src/union_room_player_avatar.c b/src/union_room_player_avatar.c
index 7f8d6066f..8a09306c0 100644
--- a/src/union_room_player_avatar.c
+++ b/src/union_room_player_avatar.c
@@ -418,13 +418,13 @@ void sub_8019F2C(void)
     }
 }
 
-static u8 sub_8019F64(u32 r1, u32 unused, struct UnkLinkRfuStruct_02022B14 * r2)
+static u8 sub_8019F64(u32 r1, u32 unused, struct GFtgtGname * r2)
 {
     if (r1 != 0)
     {
         return gUnknown_082F076F[r1];
     }
-    else if (r2->unk_0a_0 == 0x45)
+    else if (r2->activity == 0x45)
     {
         return 1;
     }
@@ -439,7 +439,7 @@ static u32 sub_8019F8C(u32 a0, u32 a1)
     return sub_8097C8C(5 * a0 + a1 - 0x38);
 }
 
-static void sub_8019FA4(u32 r5, u32 r6, u8 r8, struct UnkLinkRfuStruct_02022B14 * r9)
+static void sub_8019FA4(u32 r5, u32 r6, u8 r8, struct GFtgtGname * r9)
 {
     s32 x, y;
     s32 r7 = 5 * r5 + r6;
@@ -462,7 +462,7 @@ static void sub_801A02C(u32 a0, u32 a1)
     sub_8088B94(x, y, 0);
 }
 
-static void sub_801A064(u32 r7, struct UnkLinkRfuStruct_02022B14 * r8)
+static void sub_801A064(u32 r7, struct GFtgtGname * r8)
 {
     s16 x, y, x2, y2;
     s32 i;
@@ -479,21 +479,21 @@ static void sub_801A064(u32 r7, struct UnkLinkRfuStruct_02022B14 * r8)
     }
     for (i = 1; i < 5; i++)
     {
-        if (r8->unk_04[i - 1] == 0)
+        if (r8->child_sprite_gender[i - 1] == 0)
         {
             sub_801A02C(r7, i);
         }
         else if (sub_80199E0(r7, i, x, y) == 0 && sub_80199E0(r7, i, x2, y2) == 0)
         {
-            sub_8019FA4(r7, i, sub_8019978((r8->unk_04[i - 1] >> 3) & 1, r8->unk_04[i - 1] & 7), r8);
+            sub_8019FA4(r7, i, sub_8019978((r8->child_sprite_gender[i - 1] >> 3) & 1, r8->child_sprite_gender[i - 1] & 7), r8);
         }
     }
 }
 
-static void sub_801A16C(u32 r5, struct UnkLinkRfuStruct_02022B14 * r4)
+static void sub_801A16C(u32 r5, struct GFtgtGname * r4)
 {
     u32 i;
-    switch (r4->unk_0a_0)
+    switch (r4->activity)
     {
     case 0x40:
     case 0x54:
@@ -516,7 +516,7 @@ static void sub_801A16C(u32 r5, struct UnkLinkRfuStruct_02022B14 * r4)
     }
 }
 
-static void sub_801A214(u32 r5, struct UnkLinkRfuStruct_02022B14 * unused)
+static void sub_801A214(u32 r5, struct GFtgtGname * unused)
 {
     s32 i;
     sub_8019D20(r5);