From 170f33fb8b8f7fd8effc82c29ac6cdbd86c429c4 Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Wed, 26 Aug 2026 08:01:45 -0600
Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20g0f=20overlays=20?=
 =?UTF-8?q?=E2=80=94=2010=20banked?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Committed before the main batch: gate_main reverts on failure and would take these with it.
---
 src/md_MAIN_003/md_MAIN_003.c             | 33 ++++++++-
 src/md_MAIN_029/md_MAIN_029.c             | 75 ++++++++++++++++++++-
 src/md_MAIN_038/md_MAIN_038.c             | 50 +++++++++++++-
 src/md_MAIN_040/md_MAIN_040.c             | 82 ++++++++++++++++++++++-
 src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c | 43 +++++++++++-
 src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c | 34 +++++++++-
 src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c | 63 ++++++++++++++++-
 src/ov_SC06_033/ov_SC06_033_jr_8018D98C.c | 49 +++++++++++++-
 src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c | 29 +++++++-
 src/resident/resident.c                   | 64 +++++++++++++++++-
 10 files changed, 512 insertions(+), 10 deletions(-)

diff --git a/src/md_MAIN_003/md_MAIN_003.c b/src/md_MAIN_003/md_MAIN_003.c
index 7a565080b..92a53f8d5 100644
--- a/src/md_MAIN_003/md_MAIN_003.c
+++ b/src/md_MAIN_003/md_MAIN_003.c
@@ -486,7 +486,38 @@ __asm__(".text\n.align 2\n.globl func_800D0174\n.ent\tfunc_800D0174\n"
 ".set\treorder\n.end\tfunc_800D0174\n");
 
 
-INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D0204);
+__asm__(".text\n.align 2\n.globl func_800D0204\n.ent\tfunc_800D0204\n"
+"func_800D0204:\n.frame $sp,24,$31\n.mask 0xC0000000,-8\n.fmask 0,0\n"
+".set\tnoreorder\n"
+"addiu $sp, $sp, -24\n"
+"sw $ra, 20($sp)\n"
+"sw $fp, 16($sp)\n"
+"addu $fp, $sp, $zero\n"
+"lui $v0, %hi(D_800EC8B0)\n"
+"lw $v0, %lo(D_800EC8B0)($v0)\n"
+"nop\n"
+"beqz $v0, .L800D0248\n"
+"nop\n"
+"jal func_800D1E58\n"
+"nop\n"
+"jal func_800D0D6C\n"
+"nop\n"
+"jal func_800118AC\n"
+"nop\n"
+"j .L800D0250\n"
+"nop\n"
+".L800D0248:\n"
+"jal func_800118AC\n"
+"nop\n"
+".L800D0250:\n"
+"addu $sp, $fp, $zero\n"
+"lw $ra, 20($sp)\n"
+"lw $fp, 16($sp)\n"
+"addiu $sp, $sp, 24\n"
+"jr $ra\n"
+"nop\n"
+".set\treorder\n.end\tfunc_800D0204\n");
+
 
 INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D0268);
 
diff --git a/src/md_MAIN_029/md_MAIN_029.c b/src/md_MAIN_029/md_MAIN_029.c
index 305980032..ba18a8413 100644
--- a/src/md_MAIN_029/md_MAIN_029.c
+++ b/src/md_MAIN_029/md_MAIN_029.c
@@ -76,7 +76,80 @@ void func_800CAF90(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_029/nonmatchings/md_MAIN_029", func_800CB0D0);
+typedef struct {
+    s8 pad00[0x12];
+    s16 f12;
+    s8 pad14[6];
+    s16 f1A;
+    s32 f1C;
+    s8 pad20[8];
+    u16 f28;
+    u16 f2A;
+    s8 pad2C[4];
+    u32 f30;
+} St;
+
+extern u8 D_80078EC1;
+extern s16 D_80126BCC;
+extern u16 D_80126BCA;
+extern s16 D_80126BC8;
+extern u16 D_800B99DA;
+
+s32 func_80146AB4(s32, void *, s32, s32, s32, s32, s32);
+void func_80146C3C(void *);
+void func_8002D4C8(s32, s32);
+
+void func_800CB0D0(St *arg0) {
+    s16 *p;
+    s32 r;
+    if (D_80078EC1 == 0x14) {
+        switch (arg0->f30) {
+        case 0:
+            r = rand();
+            arg0->f1A = r & 0xFFF;
+            arg0->f2A = (r & 1) + 2;
+            arg0->f30 = arg0->f30 + 1;
+            break;
+        case 1:
+            if ((arg0->f1C++ & 1) == 0) {
+                if (func_80146AB4(0x38, arg0, 0, 0, 0, arg0->f12,
+                                  arg0->f1A | ((s16)arg0->f28 << 16)) == 0) {
+                    arg0->f2A = 0;
+                }
+                arg0->f28++;
+                if ((s16)arg0->f28 >= 3) {
+                    arg0->f28 = 0;
+                }
+                arg0->f2A--;
+                if ((s16)arg0->f2A <= 0) {
+                    arg0->f1C = 0xE;
+                    arg0->f30 = arg0->f30 + 1;
+                }
+            }
+            break;
+        case 2:
+            if (--arg0->f1C == 0) {
+                arg0->f30 = 0;
+            }
+            break;
+        }
+        p = &D_80126BCC;
+        if (*p < 0x1000) {
+            D_80126BCA -= 0x38;
+            *p += 0xE0;
+            D_80126BC8 = *p;
+        }
+        if ((D_800B99DA & 0xF) == 0) {
+            func_8002D4C8(0x5FB, 0);
+        }
+    } else {
+        D_80126BCC = 0x1000;
+        D_80126BCA = 0x1000;
+        D_80126BC8 = 0x1000;
+        func_80146C3C(arg0);
+    }
+}
+
 
 typedef struct { s32 w[8]; } Blk20;
 
diff --git a/src/md_MAIN_038/md_MAIN_038.c b/src/md_MAIN_038/md_MAIN_038.c
index ab67ca098..31adb270a 100644
--- a/src/md_MAIN_038/md_MAIN_038.c
+++ b/src/md_MAIN_038/md_MAIN_038.c
@@ -45,7 +45,55 @@ void func_800CAF1C(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_038/nonmatchings/md_MAIN_038", func_800CAFAC);
+extern s16 func_80148E54(void *a0);
+extern s16 func_80012ABC(s16 a0, s16 a1, s32 a2);
+extern void func_80148AFC(void *a0);
+extern void func_801466F0(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6, s32 a7);
+extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
+extern void func_80147324(s32 a0);
+extern void func_801655E4(void *a0);
+extern s32 func_80165624(void *a0);
+extern u8 D_800CBB84[];
+extern u8 D_800CBB64[];
+
+void func_800CAFAC(void *a0) {
+    s32 temp = *(s32 *)((u8 *)a0 + 0x20);
+    *(u32 *)((u8 *)a0 + 0x44) |= 2;
+    if (func_80161208() == 0) {
+        switch (*(u8 *)((u8 *)a0 + 0xA9)) {
+        case 0x41: {
+            s16 r = func_80148E54(a0);
+            if (r > 0) {
+                *(s16 *)(temp + 0x12) = func_80012ABC(*(s16 *)(temp + 0x12), r, 4);
+            }
+            break;
+        }
+        case 0x53:
+        case 0x73:
+            func_80148AFC(a0);
+            break;
+        }
+        if (*(u16 *)((u8 *)a0 + 0xB8) & 0x4000) {
+            s32 mf = -0xF;
+            s32 one = 1;
+            func_801466F0(0x1F, a0, 0, -0x18, mf, 0, 0, one);
+            func_801466F0(0x1F, a0, 0, -0x18, mf, one, 0, one);
+            func_801466F0(0x1F, a0, 0, -0x18, mf, 2, 0, one);
+            func_80146A6C(0x43, a0, 0, -0x18, mf, 0, 0);
+            func_80147324(0xA64);
+            func_801655E4(a0);
+        }
+        if (*(u16 *)((u8 *)a0 + 0xB8) & 0x8000) {
+            if (func_80165624(a0) == 0 && (func_801487F4((s32 *)a0) & 0x20)) {
+                func_80154274((s32 *)a0, (s32)D_800CBB84);
+            } else {
+                func_80154274((s32 *)a0, (s32)D_800CBB64);
+                *(u8 *)((u8 *)a0 + 0x197) += 1;
+            }
+        }
+    }
+}
+
 
 extern s32 func_80161208();
 extern void func_801599A4(void *a0);
diff --git a/src/md_MAIN_040/md_MAIN_040.c b/src/md_MAIN_040/md_MAIN_040.c
index 7d02c68d7..6cd5f10cf 100644
--- a/src/md_MAIN_040/md_MAIN_040.c
+++ b/src/md_MAIN_040/md_MAIN_040.c
@@ -110,7 +110,87 @@ void func_800CB038(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_040/nonmatchings/md_MAIN_040", func_800CB114);
+void func_800CB114(void *a0) {
+    extern void func_80162FF4(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80162FC0(s32 a0);
+    extern s32 func_80146E98(s32 a0);
+    extern void func_800CB3BC(void);
+    extern s32 func_80163950(s32 a0);
+    extern s32 func_801638A0(s32 a0, s32 *a1);
+    extern void func_80146E90(s32 *a0, s32 a1);
+    extern void func_80147324(s32 a0);
+    extern void func_80146CA0(void *a0);
+    extern void func_80163408(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80163328(s32 a0);
+    extern s32 func_801632F0(s32 a0);
+    extern void func_80162D28(s32 a0);
+
+    s32 vec[2];
+    s32 save[2];
+    void *obj;
+    s32 f;
+    s32 w;
+
+    obj = *(void **)((s32)a0 + 0x20);
+    memcpy(save, (void *)(obj + 0x10), 8);
+    memcpy((void *)(obj + 0x10), (void *)((s32)a0 + 0x58), 8);
+    func_80162FF4((s32)a0, 0, 0x20000, 0);
+    func_80162FC0((s32)a0);
+    *(u16 *)save = *(u16 *)save + 0x71;
+    *(u16 *)((s32)save + 4) = *(u16 *)((s32)save + 4) + 0x71;
+    memcpy((void *)(obj + 0x10), save, 8);
+    if (func_80146E98((s32)a0) != 0) {
+        ((void (*)(s32))func_800CB3BC)(a0);
+        return;
+    }
+    f = (func_80163950((s32)a0) != 0) << 13;
+    f |= func_801638A0((s32)a0, vec);
+    if (f == 0) {
+        goto L274;
+    }
+    if ((f & 0x6000) == 0) {
+        goto L250;
+    }
+    w = *(u16 *)((s32)a0 + 0x60);
+    w = w - 1;
+    *(u16 *)((s32)a0 + 0x60) = w;
+    if ((s16)w == -1) {
+        goto L250;
+    }
+    {
+        s32 v = *(s32 *)((s32)a0 + 0x28);
+        *(s32 *)((s32)a0 + 0x28) = -(v / 2);
+    }
+    goto L274;
+L250:
+    func_80146E90((s32 *)a0, 8);
+    func_80147324(0x8E7);
+    func_80146CA0(a0);
+    return;
+L274:
+    func_80163408((s32)a0, 0x2A, 0, 0x20);
+    func_80163328((s32)a0);
+    f = func_801632F0((s32)a0);
+    if (f == 2) {
+        goto L2E4;
+    }
+    if ((u32)f < 3) {
+        if (f == 1) {
+            goto L2CC;
+        }
+        goto L2E4;
+    }
+    if (f != 4) {
+        goto L2E4;
+    }
+L2CC:
+    func_80146E90((s32 *)a0, 8);
+    func_80147324(0x8E7);
+    func_80146CA0(a0);
+L2E4:
+    func_80162D28((s32)a0);
+}
+
 
 void func_800CB304(void *a0) {
     extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c b/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
index 1e1321d90..1779bfb12 100644
--- a/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
+++ b/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
@@ -9159,7 +9159,48 @@ s32 param_1;
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80188620);
+#include "common.h"
+
+extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_8012F214(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012C51C(void *a0, s32 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_801883A0(a0);
+extern u16 D_80126B96;
+extern u8 D_801E2118[];
+extern u8 D_801E2128[];
+
+void func_80188620(s32 arg0) {
+    u16 sp10[3];
+    u16 sp18[12];
+
+    if (*(s32 *)(arg0 + 0x1C) == 9) {
+        if (func_8012D5E4(arg0, (s32)D_801E2118, (s32)(D_801E2118 + 8), 10) != 0) {
+            D_80126B96 |= 0x800;
+        }
+        if (*(s16 *)(arg0 + 0x70) & 0x8000) {
+            func_8012F214(arg0, (s32)D_801E2128, (s32)sp10);
+            sp18[3] = 0x126;
+            sp18[5] = 0;
+            sp18[6] = 0x7FFF;
+            sp18[0] = sp10[0];
+            sp18[1] = sp10[1];
+            sp18[2] = sp10[2];
+            sp18[7] = *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12);
+            func_8012C51C(sp18, arg0);
+            sp18[7] = *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) + 0x100;
+            func_8012C51C(sp18, arg0);
+            sp18[7] = *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) - 0x100;
+            func_8012C51C(sp18, arg0);
+        }
+        func_8002D4C8(0x43E, 0);
+    }
+    if (func_8012BEE8(arg0) != 0) {
+        ((void (*)(void *))func_801883A0)(arg0);
+    }
+}
+
 
 void func_8018875C(s32 a0) {
     register s32 result __asm__("$2");
diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c b/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c
index adb7e6e35..5c59e72b4 100644
--- a/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c
+++ b/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c
@@ -9213,7 +9213,39 @@ void func_80184310(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_jr_8017AE2C", func_80184350);
+extern void func_80172710(void);
+extern s32 func_8018739C(void);
+extern s32 func_80188D1C(void *);
+extern s32 func_80178BF8(void);
+
+/* §124 asm-label alias: TU decl layer carries `extern void func_80184350(void*)`
+ * (L9106, used address-only by banked func_801840E4), so a plain-name s32
+ * definition is "conflicting types". Alias per ov_SC03_001_jr_801870B0.c L3309. */
+s32 aF80184350(void *arg0) __asm__("func_80184350");
+
+s32 aF80184350(void *arg0)
+{
+    void *s0 = arg0;
+
+    if ((*(u16 *)(*(s32 *)((char *)s0 + 0x64) + 2) != 2) &&
+        (*(u16 *)(*(s32 *)((char *)s0 + 0x64) + 2) != 8)) {
+        return 0;
+    }
+
+    if (((s32 (*)(void *))func_8018739C)(s0) == 0) {
+        return 0;
+    }
+
+    if (func_80188D1C(*(void **)((char *)s0 + 0x64)) != 0) {
+        return 0;
+    }
+
+    *(u16 *)(*(s32 *)((char *)s0 + 0x64) + 2) += 1;
+    func_80178BF8();
+
+    return (s32)func_80172710;
+}
+
 
 extern s32 func_8012BD14(s32 a0);
 extern s32 func_80178BF8();
diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c b/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
index 98e71eaad..32f4ecf37 100644
--- a/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
+++ b/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
@@ -3652,7 +3652,68 @@ void func_801809D4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8017EC58", func_80180A10);
 
-INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8017EC58", func_80180B80);
+typedef struct {
+    u8 pad0[8];
+    s32 unk8;
+    s32 unkC;
+    s32 unk10;
+    s32 unk14;
+    u16 unk18;
+    u16 unk1A;
+    u16 unk1C;
+    u8 pad1E[2];
+    u16 unk20;
+    u16 unk22;
+    u16 unk24;
+    u8 pad26[2];
+    s16 unk28;
+    s16 unk2A;
+    s16 unk2C;
+    s16 unk2E;
+    s16 unk30;
+    s16 unk32;
+    u8 pad34[8];
+    s32 unk3C;
+    s32 unk40;
+    s32 unk44;
+    s32 unk48;
+    s32 unk4C;
+    s32 unk50;
+} S;
+
+void func_80180B80(S* arg0, s16* arg1, u16 arg2) {
+    s16 sp0x10[16];
+    s16 sp0x30[4];
+    u16 sp0x38[4];
+    u16 sp0x40[3];
+    s16 temp;
+
+    temp = func_80012C6C(*(s16*)&arg0->unk8, *(s16*)&arg0->unkC, 4);
+    *(s32*)&arg0->unk8 = temp;
+    temp = func_80012C6C(*(s16*)&arg0->unk10, *(s16*)&arg0->unk14, 4);
+    *(s32*)&arg0->unk10 = temp;
+    arg0->unk18 = func_80012ABC((s16)arg0->unk18, (s16)arg0->unk20, 4);
+    arg0->unk1A = func_80012ABC((s16)arg0->unk1A, (s16)arg0->unk22, 4);
+    arg0->unk1C = func_80012ABC((s16)arg0->unk1C, (s16)arg0->unk24, 4);
+    arg0->unk28 = func_80012C6C(arg0->unk28, arg0->unk2E, 0x10);
+    arg0->unk2A = func_80012C6C(arg0->unk2A, arg0->unk30, 0x10);
+    arg0->unk2C = func_80012C6C(arg0->unk2C, arg0->unk32, 0x10);
+    arg0->unk48 = arg0->unk28 + *arg1;
+    arg0->unk4C = arg0->unk2A + arg1[1];
+    arg0->unk50 = arg0->unk2C + arg1[2];
+    sp0x40[0] = arg0->unk18;
+    sp0x40[1] = arg0->unk1A + arg2;
+    sp0x40[2] = arg0->unk1C;
+    func_80181998(sp0x40, sp0x10);
+    sp0x30[0] = 0;
+    sp0x30[1] = 0;
+    sp0x30[2] = arg0->unk10;
+    ApplyMatrixSV(sp0x10, sp0x30, sp0x38);
+    arg0->unk3C = (((s16)sp0x38[0] >> 3) + arg0->unk28) + *arg1;
+    arg0->unk40 = (((s16)sp0x38[1] >> 3) + arg0->unk2A) + arg1[1];
+    arg0->unk44 = (((s16)sp0x38[2] >> 3) + arg0->unk2C) + arg1[2];
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8017EC58", func_80180D4C);
 
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8018D98C.c b/src/ov_SC06_033/ov_SC06_033_jr_8018D98C.c
index e38921826..4ef43d9a2 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8018D98C.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8018D98C.c
@@ -4995,7 +4995,54 @@ void func_80190CE0(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8018D98C", func_80190E64);
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8018D98C", func_8019131C);
+extern void func_8012BE54(s32);
+extern s32 func_8012B8A4(s32);
+extern s32 func_8004787C(s32);
+extern s32 func_80047948(s32);
+extern void func_8012C218(void *);
+extern u8 D_801202A0[];
+extern u8 D_80126B5C;
+extern u8 D_80126B64;
+
+void func_8019131C(s32 arg0) {
+    s32 s0;
+    s16 t;
+    s32 i;
+    u16 *p;
+
+    switch (*(u16 *)(arg0 + 0x34)) {
+    case 0:
+        if (((s32 (*)(s32))func_8012BE54)(arg0) > 0x9000) {
+            *(u16 *)(arg0 + 0x34) = 1;
+        }
+        break;
+    case 1:
+        if (((s32 (*)(s32))func_8012BE54)(arg0) <= 0x9000) {
+            s0 = ((s32 (*)(s32))func_8012B8A4)(arg0);
+            *(s32 *)&D_80126B5C = *(s32 *)(arg0 + 4) - ((s32 (*)(s32))func_8004787C)(s0) * 0xC00;
+            *(s32 *)&D_80126B64 = *(s32 *)(arg0 + 0xC) - ((s32 (*)(s32))func_80047948)(s0) * 0xC00;
+        }
+        *(u16 *)(arg0 + 0xA) = t = *(u16 *)(arg0 + 0xA) + 4;
+        if ((s16)t - *(s16 *)(arg0 + 0x8A) < 0xC0) {
+            break;
+        }
+        p = (u16 *)D_801202A0;
+        i = 0;
+        *(u32 *)(*(s32 *)(arg0 + 0x20) + 4) |= 0x80000000;
+        do {
+            if (*p == 0x350) {
+                *(s32 *)(p + 4) = *(s32 *)(arg0 + 8);
+                *(u32 *)(*(s32 *)(p + 0x10) + 4) &= 0x7FFFFFFF;
+                *(p + 1) += 1;
+            }
+            p += 0x86;
+            i++;
+        } while (i < 0x60);
+        func_8012C218((void *)arg0);
+        break;
+    }
+}
+
 
 extern void (*D_801CB590[])(void);
 
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
index 1001201af..47ea3581c 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -3693,7 +3693,34 @@ void func_8017DB64(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017DBA0);
+extern void func_8017DC68(s32 param_1, s16 *param_2);
+
+void func_8017DBA0(s32 param_1) {
+    typedef struct {
+        s16 v[4];
+    } Blk8_80126940_8017D20C;
+    extern Blk8_80126940_8017D20C D_80126940;
+    Blk8_80126940_8017D20C sp10;
+
+    sp10 = D_80126940;
+
+    if (sp10.v[1] >= -0x3FF) {
+        sp10.v[1] = -0x400;
+    } else if (sp10.v[1] < -0x800) {
+        sp10.v[1] = -0x800;
+    }
+
+    if (sp10.v[2] >= 0x2601) {
+        if (sp10.v[1] >= -0x4FF) {
+            sp10.v[1] = -0x500;
+        }
+    } else if ((sp10.v[2] >= 0x1A01) && (sp10.v[1] >= -0x3FF)) {
+        sp10.v[1] = -0x400;
+    }
+
+    func_8017DC68(param_1, sp10.v);
+}
+
 
 
 // @class: schedule
diff --git a/src/resident/resident.c b/src/resident/resident.c
index d920c0499..0afb17978 100644
--- a/src/resident/resident.c
+++ b/src/resident/resident.c
@@ -2678,7 +2678,69 @@ void func_800D2468(void) {
     D_8011DB20 = 0;
 }
 
-INCLUDE_ASM("asm/resident/nonmatchings/resident", func_800D24A0);
+
+
+
+
+
+
+
+typedef struct { s32 f0; } E4;
+
+void func_800D24A0(s16 arg0) {
+    extern void func_80018FC8(void);
+    extern void func_800596F4(s32);
+    extern void func_8002D4C8(s32, s32);
+    extern u16 D_800B9A02;
+    extern u8 D_800B9A13;
+    extern u8 D_800A6518[];
+    extern u8 D_8007BA70[];
+    extern u8 D_800856B0[];
+    extern u16 D_80115112;
+    extern u16 D_8011512A;
+    extern u16 D_80115124;
+    extern u8 D_80115110[];
+    extern u16 D_80115114;
+    extern u8 *D_801151C8;
+    extern u8 *D_801151CC;
+    extern E4 D_80115168[];
+
+    u16 i;
+    u32 *src;
+    u32 *dst;
+    u16 *v;
+    char *p;
+
+    func_80018FC8();
+    func_800596F4(0);
+
+    src = (u32 *)&D_800A6518[(D_800B9A02 ^ 1) * 20];
+    dst = (u32 *)&D_800A6518[D_800B9A02 * 20];
+    for (i = 0; i < 5; i++) {
+        *dst++ = *src++;
+    }
+
+    v = &D_80115112;
+    *v = 0;
+    D_8011512A = 0;
+    D_80115124 = 0;
+    (*(u16 *)D_80115110) = arg0;
+    D_800B9A13 = arg0 + 1;
+    D_80115114 = D_800B9A02;
+    D_801151C8 = &D_8007BA70[D_800B9A02 * 80000];
+    D_801151CC = &D_800856B0[D_800B9A02 * 80000];
+
+    i = 0;
+    p = (char *)v - 2;
+    do {
+        *(s32 *)(p + (s16)i * 4 + 0x78) = 0;
+        D_80115168[(s16)i].f0 = 0;
+        i++;
+    } while ((s16)i < 8);
+
+    func_8002D4C8(0x14, 0);
+}
+
 
 extern void (*D_8011DB24)(void);