diff --git a/src/md_MAIN_003/md_MAIN_003.c b/src/md_MAIN_003/md_MAIN_003.c
index a65b12058..6acf68740 100644
--- a/src/md_MAIN_003/md_MAIN_003.c
+++ b/src/md_MAIN_003/md_MAIN_003.c
@@ -699,7 +699,7 @@ void func_800D2454(s32 a0, s32 a1, s32 *a2) {
 
 INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D24D0);
 
-extern s32 func_800D27A0(s32 a0, s32 a1);
+extern s32 func_800D27A0();
 extern void func_800D3234(s32 a0, s32 a1);
 extern void StFreeRing(s32 a0);
 
@@ -726,7 +726,65 @@ s32 func_800D2704(s32 a0, s32 a1) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D27A0);
+extern s32 D_800EC9F4;
+extern s32 D_800EC9F8;
+extern s32 D_800D9484;
+extern s32 D_800D9488;
+
+struct UnkS1 { s32 pad0; s32 f4; s32 pad8; s32 fC; s32 pad10; s32 pad14; s32 f18; u32 f1C; };
+
+s32 func_800D27A0(void* arg0, struct UnkS1* arg1) {
+    s32 sp10[2];
+    u16 sp18[4];
+    s32 ret;
+    s32 i;
+
+    for (i = 0x8000; i != 0; i--) {
+        if (StGetNext(&sp10[0], &sp10[1]) == 0) {
+            goto found;
+        }
+    }
+    return 0;
+found:
+    if (*(u32*)(sp10[1] + 8) >= arg1->fC) {
+        D_800EC9F4 = 1;
+    }
+    if (*(u32*)(sp10[1] + 8) >= arg1->fC - 15) {
+        D_800EC9F8 = 1;
+    } else {
+        D_800EC9F8 = 0;
+    }
+    if (D_800D9484 != *(u16*)(sp10[1] + 0x10) || D_800D9488 != *(u16*)(sp10[1] + 0x12)) {
+        u16 cur1;
+        u16 cur2;
+        sp18[0] = 0;
+        sp18[1] = 0;
+        sp18[2] = arg1->f4 != 0 ? (arg1->f18 * 3) / 2 : *(u16*)&arg1->f18;
+        sp18[3] = arg1->f1C * 2;
+        if (arg1->f4 != 0) {
+            func_80059888(sp18, 0, 0, 0);
+        } else {
+            func_80059888(sp18, 0x40, 0x40, 0x40);
+        }
+        cur1 = *(u16*)(sp10[1] + 0x10);
+        cur2 = *(u16*)(sp10[1] + 0x12);
+        D_800D9484 = cur1;
+        D_800D9488 = cur2;
+    }
+    {
+        u16 t = arg1->f4 != 0 ? (D_800D9484 * 3) / 2 : *(u16*)&D_800D9484;
+        u16 g;
+        ret = sp10[0];
+        g = *(u16*)&D_800D9488;
+        *(u16*)(arg0 + 0x24) = t;
+        *(u16*)(arg0 + 0x1C) = t;
+        *(u16*)(arg0 + 0x26) = g;
+        *(u16*)(arg0 + 0x1E) = g;
+        *(u16*)(arg0 + 0x32) = g;
+    }
+    return ret;
+}
+
 
 typedef struct {
     s8 pad00[0x18];
diff --git a/src/md_MAIN_013/md_MAIN_013.c b/src/md_MAIN_013/md_MAIN_013.c
index 73e778faa..824896bcc 100644
--- a/src/md_MAIN_013/md_MAIN_013.c
+++ b/src/md_MAIN_013/md_MAIN_013.c
@@ -66,7 +66,16 @@ void func_800CB054(void *a0) {
 
 INCLUDE_ASM("asm/md_MAIN_013/nonmatchings/md_MAIN_013", func_800CB05C);
 
-INCLUDE_ASM("asm/md_MAIN_013/nonmatchings/md_MAIN_013", func_800CB0E8);
+void func_800CB0E8(void *a0) {
+    extern s32 func_80146994(s32 a0, s32 a1, s32 a2, s32 a3);
+    s32 v1;
+
+    v1 = func_80146994(0x15, (s32)a0, 0, 0);
+    if (v1 != 0) {
+        *(s32 *)(v1 + 0x30) = *(s16 *)((u8 *)a0 + 0x36);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_013/nonmatchings/md_MAIN_013", func_800CB138);
 
diff --git a/src/md_MAIN_025/md_MAIN_025.c b/src/md_MAIN_025/md_MAIN_025.c
index ae390f35d..b8a355305 100644
--- a/src/md_MAIN_025/md_MAIN_025.c
+++ b/src/md_MAIN_025/md_MAIN_025.c
@@ -376,7 +376,20 @@ void func_800CBA60(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_025/nonmatchings/md_MAIN_025", func_800CBAF4);
+void func_800CBAF4(void *a0)
+{
+    s32 s0;
+    extern s32 func_80146E98(s32 a0);
+    extern void func_800CBBF8();
+
+    s0 = *(s32 *)((s32)a0 + 0x10);
+    if (func_80146E98((s32)a0) != 0) {
+        func_800CBBF8();
+    } else if (s0 != 0) {
+        *(u16 *)((s32)s0 + 0x1A) = *(u16 *)((s32)s0 + 0x1A) - 0x400;
+    }
+}
+
 
 void func_800CBB50(void *a0) {
     *(u8 *)((s32)a0 + 0x27) = 0x1A;
diff --git a/src/md_MAIN_026/md_MAIN_026.c b/src/md_MAIN_026/md_MAIN_026.c
index ec5f877ad..f39acce18 100644
--- a/src/md_MAIN_026/md_MAIN_026.c
+++ b/src/md_MAIN_026/md_MAIN_026.c
@@ -50,7 +50,19 @@ void func_800CAF68(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_026/nonmatchings/md_MAIN_026", func_800CB010);
+extern s32 func_8014C088(s32 a0, s32 a1);
+extern s32 func_80165A20(s32 a0);
+extern void func_800CB108();
+
+void func_800CB010(void *arg0) {
+    if (func_8014C088((s32)arg0, 0xB) == 0) {
+        *(u8 *)((s32)arg0 + 0x197) += 1;
+        func_80165A20((s32)arg0);
+    } else if (*(u8 *)((s32)arg0 + 0xBE) != 0) {
+        func_800CB108(arg0);
+    }
+}
+
 
 extern void func_800CB108(void);
 void func_800CB078(void) {
diff --git a/src/md_MAIN_027/md_MAIN_027.c b/src/md_MAIN_027/md_MAIN_027.c
index 726b4e263..cfab0d00a 100644
--- a/src/md_MAIN_027/md_MAIN_027.c
+++ b/src/md_MAIN_027/md_MAIN_027.c
@@ -532,4 +532,53 @@ void func_800CC004(void) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CC024);
+extern void func_80015954(s32 a0, s32 a1);
+extern s32 func_80047948(s32 a0);
+extern s32 func_8004787C(s32 a0);
+
+void func_800CC024() {
+    extern u8 D_800CC290[];
+    s32 s2;
+    s32 s3;
+    s32 m;
+    s32 ang;
+    s32 r;
+    s16 d[2];
+    u16 v;
+    u16 t;
+    s32 obj;
+
+    {
+        register s32 a0p __asm__("$4");
+        obj = a0p;
+    }
+
+    s2 = *(s32 *)(obj + 0x4C);
+    s3 = *(s32 *)(obj + 0x20);
+    if (s2 == 0) {
+        return;
+    }
+
+    func_80015954((s32)D_800CC290, obj + 4);
+
+    v = *(u16 *)(obj + 0x60);
+    m = v & 0x1F;
+    ang = ((m << 8) & 0x7F00) >> 1;
+    t = *(u16 *)(obj + 0xA);
+    __asm__("" :: "r"(m), "r"(ang));
+    *(u16 *)(obj + 0xA) = t - 0x10;
+    *(u16 *)(obj + 0x60) = v + 1;
+
+    if (*(s32 *)(obj + 0x50) == 0) {
+        r = func_80047948(m << 7);
+    } else {
+        r = 0x1000 - func_80047948(m << 7);
+    }
+    d[0] = r / 1024;
+    d[1] = func_8004787C(ang) / 512;
+
+    *(u16 *)(obj + 6) += d[0];
+    *(u16 *)(obj + 0xA) += d[1];
+    *(s32 *)(s3 + 0x18) = *(s32 *)(*(s32 *)(s2 + 0x20) + 0x18);
+}
+
diff --git a/src/md_MAIN_028/md_MAIN_028.c b/src/md_MAIN_028/md_MAIN_028.c
index 530a1e122..d329afdd3 100644
--- a/src/md_MAIN_028/md_MAIN_028.c
+++ b/src/md_MAIN_028/md_MAIN_028.c
@@ -164,7 +164,19 @@ INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB59C);
     }
 
 
-INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB620);
+void func_800CB620(s32 arg0) {
+    s32 v;
+    *(u16 *)(arg0 + 0x10) = *(u16 *)(arg0 + 6);
+    *(u16 *)(arg0 + 0x12) = *(u16 *)(arg0 + 0xA);
+    *(u16 *)(arg0 + 0x14) = *(u16 *)(arg0 + 0xE);
+    v = rand() & 0x1F;
+    v <<= 7;
+    *(u16 *)(arg0 + 0x64) = v;
+    *(u16 *)(arg0 + 0x66) = v;
+    func_800CB684(arg0, 0x200);
+    func_800CB6D4(arg0);
+}
+
 
 void func_800CB684(s32 a0, s32 a1) {
     extern s32 rand(void);
diff --git a/src/md_MAIN_032/md_MAIN_032.c b/src/md_MAIN_032/md_MAIN_032.c
index e52d21085..6f84779d7 100644
--- a/src/md_MAIN_032/md_MAIN_032.c
+++ b/src/md_MAIN_032/md_MAIN_032.c
@@ -30,7 +30,24 @@ void func_800CAE78(u8 *a0) {
 
 INCLUDE_ASM("asm/md_MAIN_032/nonmatchings/md_MAIN_032", func_800CAEC0);
 
-INCLUDE_ASM("asm/md_MAIN_032/nonmatchings/md_MAIN_032", func_800CAF60);
+void func_800CAF60(void *a0) {
+    extern void func_80147A84(s32 a0);
+    extern void func_801473EC(s32 *a0);
+    extern void func_80148038(s32 a0, s32 a1);
+    extern void func_80147460(s32 a0);
+    extern s32  func_80161418(void *a0);
+    extern s32  func_80155FD4(s32 a0, s32 a1);
+
+    *(u32 *)((u8 *)a0 + 0x44) |= 2;
+    func_80147A84((s32)a0);
+    func_801473EC((s32 *)a0);
+    func_80148038((s32)a0, 0x20000);
+    func_80147460((s32)a0);
+    if (func_80161418(a0) == 0) {
+        func_80155FD4((s32)a0, *(u8 *)((u8 *)a0 + 0x1AA));
+    }
+}
+
 
 void func_800CAFD0(void *a0) {
     extern u8 D_8011F9D0[];
diff --git a/src/md_MAIN_033/md_MAIN_033.c b/src/md_MAIN_033/md_MAIN_033.c
index eb1d4f9d9..e388940d6 100644
--- a/src/md_MAIN_033/md_MAIN_033.c
+++ b/src/md_MAIN_033/md_MAIN_033.c
@@ -291,7 +291,17 @@ void func_800CB5DC(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_033/nonmatchings/md_MAIN_033", func_800CB6D4);
+void func_800CB6D4(void *a0)
+{
+    extern void func_800CB76C(void *arg0);
+
+    if (*(u16 *)*(s32 *)((u8 *)a0 + 0x34) == 0) {
+        *(u16 *)((u8 *)a0 + 2) = *(u16 *)((u8 *)a0 + 2) + 1;
+    } else {
+        func_800CB76C(a0);
+    }
+}
+
 
 extern void func_80146C3C(void);
 
diff --git a/src/md_MAIN_037/md_MAIN_037.c b/src/md_MAIN_037/md_MAIN_037.c
index cb3775bc6..191022ad7 100644
--- a/src/md_MAIN_037/md_MAIN_037.c
+++ b/src/md_MAIN_037/md_MAIN_037.c
@@ -190,7 +190,24 @@ tail:
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_037/nonmatchings/md_MAIN_037", func_800CB2A8);
+extern void func_800CB378(s32 a0);
+
+void func_800CB2A8(s32 a0) {
+    s32 v1;
+    u16 v0;
+
+    v1 = *(s32 *)(a0 + 0x20);
+    v0 = *(u16 *)(v1 + 0x1A);
+    v0 = v0 + 0x80;
+    *(u16 *)(v1 + 0x1A) = v0;
+    *(u16 *)(v1 + 0x18) = v0;
+    if (func_80146E98((s32)a0) != 0) {
+        func_80146CA0((void *)a0);
+    } else {
+        func_800CB378(a0);
+    }
+}
+
 
 extern void func_800CB358(void);
 
diff --git a/src/md_MAIN_043/md_MAIN_043.c b/src/md_MAIN_043/md_MAIN_043.c
index 40bea3796..25b1f5904 100644
--- a/src/md_MAIN_043/md_MAIN_043.c
+++ b/src/md_MAIN_043/md_MAIN_043.c
@@ -107,7 +107,22 @@ void func_800CCD04(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_043/nonmatchings/md_MAIN_043", func_800CCDC4);
+extern s32 func_80146E98(s32 arg0);
+extern void func_801599A4(void *arg0);
+extern void func_80159B3C(void *arg0);
+extern s32 func_80161208();
+
+void func_800CCDC4(s32 a0)
+{
+    *(s32 *)(a0 + 0x44) |= 2;
+    if (func_80146E98(a0) != 0) {
+        func_801599A4((void *)a0);
+        func_80159B3C((void *)a0);
+    } else {
+        func_80161208((void *)a0);
+    }
+}
+
 
 extern void func_8014B5C4(s32 *a0, s32 a1, s32 a2);
 extern void func_8013C9C4(void *a0);
@@ -135,7 +150,24 @@ s32 func_800CCEA0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_043/nonmatchings/md_MAIN_043", func_800CCEAC);
+s32 func_800CCEAC(void *a0)
+{
+    extern void func_801599A4(void *a0);
+    extern void func_80159B3C(void *a0);
+    extern s16 currentLocationId;
+
+    if (currentLocationId == 0x306F) {
+        if (*(s32 *)((s32)a0 + 0x234) != 0) {
+            (*(s32 *)((s32)a0 + 0x234))--;
+            return 0;
+        }
+        func_801599A4(a0);
+        func_80159B3C(a0);
+        return 1;
+    }
+    return 0;
+}
+
 
 
 
diff --git a/src/md_MAIN_044/md_MAIN_044.c b/src/md_MAIN_044/md_MAIN_044.c
index 0d2a76d1a..7e86d8238 100644
--- a/src/md_MAIN_044/md_MAIN_044.c
+++ b/src/md_MAIN_044/md_MAIN_044.c
@@ -297,7 +297,11 @@ void func_800CD57C(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_044/nonmatchings/md_MAIN_044", func_800CD5EC);
+void func_800CD5EC(void *a0) {
+    func_800CD758((s32)a0);
+    *(u16 *)((s32)a0 + 0x66) = (*(s32 *)((s32)a0 + 0x50) * 1365) & 0xFFF;
+}
+
 
 #include "common.h"
 
@@ -371,7 +375,14 @@ void func_800CD834(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_044/nonmatchings/md_MAIN_044", func_800CD848);
+extern s32 func_80012F74(s32, s32, s32, s32);
+
+void func_800CD848(s32 param_1) {
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x18) =
+        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x1A) =
+        func_80012F74(*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x1A), 0x1000, 4, 1);
+}
+
 
 extern void func_80015978(s32 a0, s32 *a1);
 extern s32 func_80135260(s32 a0, s32 a1, s32 a2, s32 a3);
@@ -492,7 +503,20 @@ void func_800CDA80(int param_1)
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_044/nonmatchings/md_MAIN_044", func_800CDB4C);
+extern s32 func_80146E98(s32 a0);
+extern s32 func_80146C3C(void *a0);
+void func_800CDB4C(int param_1)
+{
+    extern unsigned char D_800CEBF4[];
+    unsigned char *base;
+
+    base = (unsigned char *)D_800CEBF4 + *(s32 *)(param_1 + 0x2C) * 0x40;
+    base[2] = base[2] - 8;
+    if (func_80146E98(param_1) != 0) {
+        func_80146C3C((void *)param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_044/nonmatchings/md_MAIN_044", func_800CDBA8);
 
@@ -560,7 +584,16 @@ L_c3c:
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_044/nonmatchings/md_MAIN_044", func_800CE134);
+void func_800CE134(void) {
+    register s32 a0v __asm__("$4");
+    s32 param_1 = a0v;
+
+    *(s32 *)(param_1 + 0x30) = *(s32 *)(param_1 + 0x1C) * 8;
+    func_80169A4C(a0v, param_1 + 0x38);
+    if (--*(s32 *)(param_1 + 0x1C) == 0)
+        func_80146C3C((void *)param_1);
+}
+
 
 
 
diff --git a/src/md_MAIN_047/md_MAIN_047.c b/src/md_MAIN_047/md_MAIN_047.c
index 37c5fd8d7..8f856858d 100644
--- a/src/md_MAIN_047/md_MAIN_047.c
+++ b/src/md_MAIN_047/md_MAIN_047.c
@@ -224,7 +224,21 @@ void func_800CD4D0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_047/nonmatchings/md_MAIN_047", func_800CD58C);
+void func_800CD58C(void *arg0) {
+    extern u8 D_800CD6E0[];
+    extern void func_80016714(void *a0, s32 a1);
+    extern void func_800CCBC0(void);
+
+    if (*(s32 *)((s32)arg0 + 0x2C) != 0) {
+        func_800CCDE8(arg0, 1, 0x37);
+        func_800CCBC0();
+        *(s32 *)((s32)arg0 + 0x2C) = 0;
+    } else {
+        func_80016714(D_800CD6E0, 0xC4);
+        func_800CCDE8(arg0, 0, 0);
+    }
+}
+
 
 void func_800CD5F8(void *arg0) {
     extern void func_801465C0(void);
diff --git a/src/md_SC02_009/md_SC02_009.c b/src/md_SC02_009/md_SC02_009.c
index 9698eb39f..4753ebb60 100644
--- a/src/md_SC02_009/md_SC02_009.c
+++ b/src/md_SC02_009/md_SC02_009.c
@@ -9,7 +9,25 @@ void func_801E4C64(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E4CA0);
+void func_801E4CA0(s32 a0) {
+    extern s32 func_8012C354(s32 arg0, s32 arg1);
+    extern void func_8012A828(s32 arg0, void *arg1);
+    extern s32 func_80143994(s32 arg0, s32 arg1);
+    extern s32 D_80196BBC;
+    extern void D_801E5DB4;
+    extern void D_801E9F0C;
+    s32 *ptr;
+
+    ptr = &D_80196BBC;
+    *(s32 *)ptr = (s32)&D_801E9F0C;
+
+    if (func_8012C354(a0, (s32)ptr - 4) != 0) {
+        func_8012A828(a0, &D_801E5DB4);
+        *(s32 *)(a0 + 0xCC) = func_80143994(a0, 0x4000);
+        *(u16 *)(a0 + 0x2) += 1;
+    }
+}
+
 
 void func_801E4D14(s32 a0) {
     extern void func_8012A828(s32 a0, void *a1);
@@ -203,9 +221,39 @@ void func_801E51C0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E5240);
+void func_801E5240(s32 a0) {
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 func_801399F0(s32);
+    extern void func_80139914(s32);
+    extern void D_801E5DB4;
+
+    if (*(s32 *)(a0 + 0x94) >= 0x19) {
+        func_8012A828(a0, &D_801E5DB4);
+    }
+    if (func_801399F0(*(s32 *)(a0 + 0xB0)) != 0) {
+        func_80139914(*(s32 *)(a0 + 0xB0));
+        *(s32 *)(a0 + 0x1C) = 0x18;
+        *(u16 *)(a0 + 2) += 1;
+    }
+}
+
+
+void func_801E52BC(s32 a0) {
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 D_801270C8;
+    extern void D_801E5DB4;
+
+    if (*(s32 *)(a0 + 0x94) >= 0x19) {
+        func_8012A828(a0, &D_801E5DB4);
+    }
+    *(s32 *)(a0 + 0x1C) -= 1;
+    if (*(s32 *)(a0 + 0x1C) == -1) {
+        D_801270C8 = 0x11;
+        *(s32 *)(a0 + 0x1C) = 8;
+        *(u16 *)((s32)a0 + 2) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E52BC);
 
 INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E5338);
 
@@ -427,7 +475,16 @@ void func_801E5894(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E58C0);
+void func_801E58C0(void *a0) {
+
+    extern void func_801439C0(u8 *a0);
+    extern void func_8012C218(void *a0);
+    if (--*(s32 *)((s32)a0 + 0x1C) == 0) {
+        func_801439C0(*(u8 **)((s32)a0 + 0xCC));
+        func_8012C218(a0);
+    }
+}
+
 
 void func_801E590C(void *a0) {
 
diff --git a/src/md_SC04_024/md_SC04_024.c b/src/md_SC04_024/md_SC04_024.c
index e7a6f319a..6f4ca3a05 100644
--- a/src/md_SC04_024/md_SC04_024.c
+++ b/src/md_SC04_024/md_SC04_024.c
@@ -220,7 +220,14 @@ void func_801E7FF0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC04_024/nonmatchings/md_SC04_024", func_801E802C);
+extern void func_801E8054(s32 param_1, s16 *param_2);
+
+void func_801E802C(s32 arg0) {
+    extern s16 D_801274E8;
+
+    func_801E8054(arg0, &D_801274E8);
+}
+
 
 
 /* MATRIX 0x20: short m[3][3] @0x00 (18B) + 2B pad, long t[3] @0x14  (PsyQ layout) */
diff --git a/src/md_SC04_030/md_SC04_030.c b/src/md_SC04_030/md_SC04_030.c
index d032fdafa..1dd08ed75 100644
--- a/src/md_SC04_030/md_SC04_030.c
+++ b/src/md_SC04_030/md_SC04_030.c
@@ -220,7 +220,13 @@ void func_801E7FF8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC04_030/nonmatchings/md_SC04_030", func_801E8034);
+extern void func_801E805C(s32 a0, s16 *a1);
+
+void func_801E8034(void *a0) {
+    extern s16 D_801274E8;
+    func_801E805C((s32)a0, &D_801274E8);
+}
+
 
 
 /* MATRIX 0x20: short m[3][3] @0x00 (18B) + 2B pad, long t[3] @0x14  (PsyQ layout) */
diff --git a/src/md_SC05_026/md_SC05_026_jr_801F0748.c b/src/md_SC05_026/md_SC05_026_jr_801F0748.c
index ad17c835b..9c921ce47 100644
--- a/src/md_SC05_026/md_SC05_026_jr_801F0748.c
+++ b/src/md_SC05_026/md_SC05_026_jr_801F0748.c
@@ -483,7 +483,22 @@ void func_801F0E6C(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026_jr_801F0748", func_801F0E9C);
+extern s32 D_801F832C;
+extern s32 D_801F84AC;
+
+void func_801F0E9C(void) {
+    typedef struct { s32 next; u8 pad[0xC]; } Node_801F0E9C;
+    Node_801F0E9C *p;
+    s32 i;
+
+    p = (Node_801F0E9C *)&D_801F832C;
+    for (i = 0; i < D_801F84AC - 1; ) {
+        p->next = (s32)(p + 1);
+        i++;
+        p = p + 1;
+    }
+}
+
 
 extern s32 func_80029504(void);
 extern void func_80029124(s32 a0, s32 a1);
diff --git a/src/md_SC07_003/md_SC07_003.c b/src/md_SC07_003/md_SC07_003.c
index 45ec82aa1..ae24750ca 100644
--- a/src/md_SC07_003/md_SC07_003.c
+++ b/src/md_SC07_003/md_SC07_003.c
@@ -203,7 +203,22 @@ void func_801A026C(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A04D4);
+extern s32 func_8016F1AC(void);
+extern s32 func_80178B18(s32 a0, s32 a1);
+
+extern s16 D_801A698C;
+
+void func_801A04D4(s32 arg0) {
+    s32 s0 = arg0;
+
+    if (func_8016F1AC() == 0) {
+        func_80178B18((s32)s0, (s32)&D_801A698C);
+        *(s16 *)(s0 + 2) = 2;
+        *(s16 *)(s0 + 0x34) = 0;
+        *(s32 *)(s0 + 0x1C) = 0;
+    }
+}
+
 
 #include "common.h"
 
@@ -302,7 +317,22 @@ void func_801A06E8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A072C);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012C588(s32, s32);
+extern s32 D_801F1FD8;
+extern u16 D_801F43C0;
+extern s32 D_801F436C[];
+
+void func_801A072C(s32 arg0) {
+    *(s16 *)(arg0 + 0x2) = 8;
+    *(s32 *)(arg0 + 0x1C) = 0x80;
+    *(s32 *)(arg0 + 0xE4) = 0x50;
+    *(s32 *)(*(s32 *)(arg0 + 0x20) + 0x24) = (s32)D_801F436C;
+    func_8012A828(arg0, &D_801F1FD8);
+    D_801F43C0 = 0x11;
+    func_8012C588(0x3D0, arg0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A079C);
 
@@ -472,7 +502,25 @@ void func_801A0E28(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A10B0);
+extern void func_801A28AC(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern void func_8017F184(void);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern u8 D_801F0478[];
+
+void func_801A10B0(void *a0) {
+    func_801A28AC((s32)a0);
+    *(s16 *)((s32)a0 + 0x2) = 0xE;
+    *(u16 *)((s32)a0 + 0x34) = 0;
+    *(s32 *)((s32)a0 + 0xE4) = 0x50;
+    func_8012A828((s32)a0, D_801F0478);
+    func_8012B23C((s32)a0);
+    *(s32 *)((s32)a0 + 0x14) = 0xFFE00000;
+    func_8017F184();
+    func_8012C658(0x34C, 4, (s32)a0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A1120);
 
@@ -600,7 +648,23 @@ void func_801A143C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A16BC);
+extern void func_801A28AC(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u8 D_801F1198[];
+
+void func_801A16BC(s32 arg0) {
+    s32 s0 = arg0;
+
+    func_801A28AC(s0);
+    *(s16 *)(s0 + 2) = 0x12;
+    *(s32 *)(s0 + 0xE4) = 0x50;
+    func_8012A828(s0, D_801F1198);
+    *(s16 *)(s0 + 0x34) = 0;
+    *(s32 *)(s0 + 0xE0) &= ~0x8;
+    func_8002D4C8(0xB79, 0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A1724);
 
@@ -747,7 +811,19 @@ s32 func_801A19C8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A1ACC);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32  func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern u8   D_801A64C4[];
+
+void func_801A1ACC(s32 arg0) {
+    *(s16 *)(arg0 + 0x02) = 0x14;
+    *(u16 *)(arg0 + 0x34) = 0;
+    *(s32 *)(arg0 + 0x1C) = 0;
+    *(s32 *)(arg0 + 0xE4) = 0x20;
+    func_8012A828(arg0, D_801A64C4);
+    *(s32 *)(arg0 + 0xD8) = func_8012C658(0x34C, 1, arg0);
+}
+
 
 #include "common.h"
 
diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 186aba14a..94f6f9f17 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -721,7 +721,24 @@ void func_801A2E90(s32 a0)
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2F34);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A30C8);
+extern void func_801A46B8(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801A30C8(s32 a0)
+{
+    s32 s0;
+    u16 v0;
+
+    s0 = a0;
+    v0 = *(u16 *)(s0 + 0x5C);
+    *(u8 *)(s0 + 0xC1) = 0;
+    *(u16 *)(s0 + 0x5E) = 0;
+    *(u16 *)(s0 + 0x10A) = 0;
+    *(u16 *)(s0 + 0x5C) = v0 & 0xDFFF;
+    func_801A46B8(s0);
+    func_8012AD44((s32 *)s0, 8);
+}
+
 
 extern void func_801A36F0(void *a0);
 extern void func_8012AD44(s32 *a0, s16 a1);
@@ -832,7 +849,17 @@ void func_801A370C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3744);
+extern void func_80132288(s32 *a0, s32 *a1, s32 a2);
+extern s32 *D_801AFB8C;
+extern s32 D_801BF01C;
+extern s32 D_801F8724;
+
+void func_801A3744(s32 a0) {
+    *(s16 *)(a0 + 0xE6) = 4;
+    func_80132288(&D_801F8724, D_801AFB8C, D_801BF01C);
+    *(s16 *)(a0 + 0x100) = -0x40;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3798);
 
@@ -937,9 +964,34 @@ void func_801A3F10(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3FB0);
+extern void func_801439C0(u8 *a0);
+
+void func_801A3FB0(void *arg0) {
+    register void *s0 __asm__("$16");
+    register u8 *a0 __asm__("$4");
+    s32 *v0p;
+
+    s0 = arg0;
+    v0p = *(s32 **)((char *)s0 + 0x20);
+    *(s32 *)((char *)v0p + 4) |= 0x80000000;
+
+    a0 = *(u8 **)((char *)s0 + 0xD0);
+    if (a0 != NULL) {
+        func_801439C0(a0);
+        *(u8 **)((char *)s0 + 0xD0) = NULL;
+    }
+}
+
+
+extern s32 func_80143970(s32 a0);
+
+void func_801A4008(s32 a0) {
+    *(s32 *)(*(s32 *)(a0 + 0x20) + 4) &= 0x7FFFFFFF;
+    if (*(s32 *)(a0 + 0xD0) == 0) {
+        *(s32 *)(a0 + 0xD0) = func_80143970(a0);
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4008);
 
 extern s32 func_8004787C(s32 a0);
 
@@ -2631,7 +2683,19 @@ void func_801A6E78(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6EF4);
+extern s32 func_8012B8A4(s16 *a0);
+extern void func_801A5698(u8 *s2, s32 a1);
+extern void func_801A54AC(s32 a0);
+
+void func_801A6EF4(void *arg0) {
+    s32 s0;
+
+    s0 = (s32)arg0;
+    *(u16 *)(*(s32 *)((u8 *)s0 + 0x20) + 0x12) = func_8012B8A4((s16 *)s0);
+    func_801A5698((u8 *)s0, *(s16 *)((u8 *)s0 + 0xFE));
+    func_801A54AC(s0);
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern void func_8012B178(s32 a0, s32 a1);
diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8017E5B8.c b/src/ov_SC01_004/ov_SC01_004_jr_8017E5B8.c
index 7674972a7..ed7734350 100644
--- a/src/ov_SC01_004/ov_SC01_004_jr_8017E5B8.c
+++ b/src/ov_SC01_004/ov_SC01_004_jr_8017E5B8.c
@@ -3130,7 +3130,14 @@ void func_8017EFEC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_jr_8017E5B8", func_8017F028);
+void func_8017F028(s32 param_1) {
+    if ((u32)func_80029504() < 5) {
+        func_80029514(5);
+    }
+    *(s32 *)(param_1 + 0x1C) = 4;
+    *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+}
+
 
 void func_8017F078(void *a0) {
     if (*(s32 *)((s32)a0 + 0x1C) != 0) {
diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c b/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c
index 55323f676..71f9ea034 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c
@@ -3763,7 +3763,24 @@ void func_801827FC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_80182850);
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_801828D0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012C218(void *a0);
+extern u8 D_801ED404[];
+
+void func_801828D0(void *arg0) {
+    s32 temp_v0;
+
+    if (*(s16 *)((u8 *)arg0 + 0x98) != 0) {
+        temp_v0 = *(s32 *)((u8 *)arg0 + 0x1C) - 1;
+        *(s32 *)((u8 *)arg0 + 0x1C) = temp_v0;
+        if (temp_v0 == -1) {
+            func_8012A828((s32)arg0, &D_801ED404);
+        }
+    } else {
+        func_8012C218(arg0);
+    }
+}
+
 
 
 
diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c b/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
index 442face54..41b8e4927 100644
--- a/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
+++ b/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
@@ -3356,7 +3356,23 @@ void func_8017D184(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D1D8);
+extern void func_8014706C(void *a0);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_80146DE8(s32 *a0, s32 a1, s32 a2, s32 a3);
+extern void func_80147324(s32 a0);
+extern s32 func_80171990(u8 *a0);
+extern M2C_UNK D_80182168;
+
+void func_8017D1D8(void *a0) {
+    func_8014706C(a0);
+    func_80154274((s32 *)a0, (s32)&D_80182168);
+    func_80146DE8((s32 *)a0, 0, 0x20000, 0);
+    *(s32 *)((s32)a0 + 0x200) = 0x40;
+    *(s16 *)((s32)a0 + 0x20C) = 1;
+    func_80147324(0xBCA);
+    func_80171990((u8 *)a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D244);
 
@@ -3437,7 +3453,19 @@ void func_8017D460(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D4D0);
+void func_8017D4D0(void *param_1) {
+    s16 v;
+
+    v = *(s16 *)((s32)param_1 + 0x20E);
+    v = v - 1;
+    *(s16 *)((s32)param_1 + 0x20E) = v;
+    if (v == -1) {
+        func_8002D4C8(0xBE8, 0);
+        *(s16 *)((s32)param_1 + 0x20E) = 0;
+        func_80171990((u8 *)param_1);
+    }
+}
+
 
 extern s32 func_80171990(u8 *a0);
 extern u8 D_80182200[];
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
index 75a9a3c36..f0dd251d5 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
@@ -5646,7 +5646,25 @@ void func_80180F6C(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180FA8);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181040);
+extern s32 D_80127190;
+extern void func_801292C8(u8 *a0);
+
+void func_80181040(void *a0) {
+    u16 v0;
+    s32 v1;
+
+    *(u16 *)((s8 *)a0 + 0xA) = D_80127190 - 0x150;
+    v1 = *(s32 *)((s8 *)a0 + 0x20);
+    v0 = *(u16 *)(v1 + 0x18) + 0x80;
+    *(u16 *)(v1 + 0x18) = v0;
+    *(u16 *)(v1 + 0x1A) = v0;
+    v0 = *(u16 *)((s8 *)a0 + 0x2E) - 1;
+    *(u16 *)((s8 *)a0 + 0x2E) = v0;
+    if ((s16)v0 == -1) {
+        func_801292C8((u8 *)a0);
+    }
+}
+
 
 extern void (*D_8018A248[])(void);
 
@@ -5859,7 +5877,20 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181CA
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181D98);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181F5C);
+void func_80181F5C(void *arg0)
+{
+    extern void func_80181D98(void *a0);
+    extern void func_8017F268(void *a0);
+    void *s0;
+
+    s0 = arg0;
+    func_80181D98(arg0);
+    if (*(s16 *)((s32)s0 + 0xFC) == 1) {
+        func_8016ED8C((s32)func_8017F268, 0x1000000, *(s16 *)((s32)s0 + 0xFE));
+        *(s16 *)((s32)s0 + 0xFC) = 0;
+    }
+}
+
 
 extern u16 D_800B99DA;
 extern s32 D_801270D0;
@@ -6114,7 +6145,21 @@ void func_80182AC4(s32 *param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80182B30);
+extern void func_80182B90(void *a0, s32 a1, s16 a2);
+
+void func_80182B30(int param_1)
+{
+    unsigned short t;
+
+    func_80182B90((void *)param_1, *(short *)(param_1 + 0xFC), *(short *)(param_1 + 0xFE));
+    *(unsigned short *)(param_1 + 0xFC) = *(unsigned short *)(param_1 + 0xFC) + 1;
+    t = *(unsigned short *)(param_1 + 0xFE) + 1;
+    *(unsigned short *)(param_1 + 0xFE) = t;
+    if ((short)t >= 0x10) {
+        *(unsigned short *)(param_1 + 0xFE) = 0;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
index 2284ba4e5..c85fb7b6d 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
@@ -3545,7 +3545,17 @@ void func_8017E290(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E2CC);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E334);
+extern s32 func_8013767C(s32 a0);
+extern u16 D_80126980;
+
+void func_8017E334(void *arg0) {
+    if (D_80126980 & 0x8000) {
+        *(s16 *)((s8 *)arg0 + 0x20C) = 0;
+        *(s32 *)((s8 *)arg0 + 0x198) = func_8013767C(*(s32 *)((s8 *)arg0 + 0x198));
+        (*(u8 *)((s8 *)arg0 + 0x214))++;
+    }
+}
+
 
 extern s32 func_8016F410(s32 a0);
 extern void func_80154274(s32 *a0, s32 a1);
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c b/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
index 4562f7d76..45aa4db47 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
@@ -3544,7 +3544,29 @@ void func_801809C4(Obj_801809C4 *obj) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80180CBC);
+void func_80180CBC(s32 param_1) {
+    extern void func_8012A828(s32, void *);
+    extern s32 D_80186B78;
+    extern s16 D_8018A9D0;
+    extern s16 D_8018A9D2;
+    extern s16 D_801C774C;
+
+    s32 ptr;
+    s32 tmp;
+
+    func_8012A828(param_1, &D_80186B78);
+    *(s16 *)(param_1 + 2) = 2;
+    *(s32 *)(param_1 + 0xDC) = D_8018A9D0;
+    ptr = *(s32 *)(param_1 + 0x20);
+    *(s32 *)(param_1 + 0xE0) = D_8018A9D2;
+    *(s32 *)(param_1 + 0xE4) = 0;
+    tmp = *(volatile s32 *)(param_1 + 0xE4);
+    *(s16 *)(param_1 + 0xFC) = 0x18;
+    *(s16 *)(ptr + 0x10) = (s16)tmp;
+    *(s32 *)(param_1 + 0x1C) = 0x12C;
+    D_801C774C = 1;
+}
+
 
 #include "common.h"
 
@@ -3752,7 +3774,18 @@ void func_801818E0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80181920);
+void func_80181920(void* a0)
+{
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 D_801A1A10;
+
+    *(s16 *)(a0 + 2) = 3;
+    *(s16 *)(a0 + 0x34) = 0;
+    *(s32 *)(a0 + 0x1C) = 0x3C;
+    func_8012A828(a0, &D_801A1A10);
+    *(s16 *)(a0 + 0xDC) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12);
+}
+
 
 void func_80181978(void *arg0) {
     extern void func_80142414(void *a0, s32 a1);
@@ -4019,7 +4052,29 @@ void func_80182F90(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80182FEC);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern u8 D_801A21E0[];
+extern u8 D_801A2848[];
+
+void func_80182FEC(s32 param_1)
+{
+    s32 v1;
+
+    *(s16 *)(param_1 + 2) = 0xE;
+    *(u16 *)(param_1 + 0x34) = 0;
+    func_8012A828(param_1, D_801A21E0);
+    v1 = *(s32 *)(param_1 + 0x20);
+    *(u16 *)(param_1 + 0x5C) = 0xAA00;
+    *(u16 *)(param_1 + 0x5E) = 0;
+    *(u16 *)(v1 + 0x14) = 0;
+    *(u16 *)(v1 + 0x10) = 0;
+    func_8012B23C(param_1);
+    func_8012A828(param_1, D_801A2848);
+    *(s32 *)(param_1 + 0x1C) = 0x1E;
+    *(u16 *)(param_1 + 0x34) = 1;
+}
+
 
 #include "common.h"
 
@@ -4591,7 +4646,25 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80183D3
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80183DA4);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80184090);
+extern void func_8012B21C(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u16 D_80126B62;
+
+void func_80184090(void *a0) {
+    u16 t;
+
+    t = *(u16 *)((s32)a0 + 0x5C);
+    *(u16 *)((s32)a0 + 0x2) = 2;
+    *(u16 *)((s32)a0 + 0x34) = 0;
+    *(u16 *)((s32)a0 + 0x5C) = t & 0x7FFE;
+    func_8012B21C(a0);
+    *(s32 *)((s32)a0 + 0x1C) = 0;
+    *(u16 *)((s32)a0 + 0x24) = *(u16 *)((s32)a0 + 0x6);
+    *(u16 *)((s32)a0 + 0x28) = *(u16 *)((s32)a0 + 0xE);
+    *(u16 *)((s32)a0 + 0x26) = D_80126B62;
+    func_8002D4C8(0x4B4, 0);
+}
+
 
 
 extern void (*D_8018AC10[])(void);
@@ -5204,7 +5277,29 @@ void func_80184FC4(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_8018500C);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_80182FEC(int param_1);
+extern void D_801A1AB8;
+
+void func_8018500C(int param_1)
+{
+    int iVar1;
+
+    iVar1 = func_8012BEE8((s32)param_1);
+    if (iVar1 != 0) {
+        if (*(s16 *)(param_1 + 0x70) == 2) {
+            func_80182FEC(param_1);
+        } else {
+            *(u16 *)(param_1 + 0x5e) = 0;
+            *(u16 *)(param_1 + 0x5c) = 0xAA00;
+            func_8012A828((s32)param_1, &D_801A1AB8);
+            *(u16 *)(param_1 + 2) = 3;
+            *(u16 *)(param_1 + 0xfe) = 0;
+        }
+    }
+}
+
 
 extern s32 func_8012BEE8(s32 a0);
 extern void func_8012A828(s32 a0, void *a1);
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
index d403d321c..72fa8eaab 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
@@ -3743,7 +3743,26 @@ void func_8017EA9C(void *param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017EAD4);
+
+
+void func_8017EAD4(void *param_1)
+{
+    extern void func_8017EFB4();
+    extern void func_8017EDF8();
+    extern s32 func_8014C168(s32 *a0, s32 a1);
+    extern Blk8 D_801274E8;
+    extern s16 D_801274EC;
+    extern s32 D_80126B58;
+
+    s32 ptr;
+
+    func_8017EFB4(param_1);
+    ptr = func_8014C168(&D_80126B58, 0x3D);
+    *(s16 *)&D_801274E8 = *(u16 *)(ptr + 6);
+    D_801274EC = *(u16 *)(ptr + 0xE);
+    func_8017EDF8(param_1, &D_801274E8);
+}
+
 
 void func_8017EB30(void) {
 }
@@ -4060,7 +4079,14 @@ void func_8017F358(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F394);
+void func_8017F394(void *a0) {
+    extern void func_80171B44(s32 *a0);
+
+    (*(u8 *)((s32)a0 + 0x214))++;
+    *(u16 *)(*(u32 *)((s32)a0 + 0x20) + 0x12) = 0;
+    ((void (*)(void))func_80171B44)();
+}
+
 
 
 // @class: plumbing
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
index fa9f159e5..e20bd206a 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
@@ -3284,7 +3284,21 @@ void func_80182810(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801828D8);
+#include "common.h"
+
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80186F14(void *a0);
+
+void func_801828D8(void *arg0) {
+    s32 s0 = (s32)arg0;
+    u32 v;
+
+    v = *(u32 *)(s0 + 0xE8);
+    *(u32 *)(s0 + 0xE8) = v | 1;
+    func_8012AD44((s32 *)s0, 2);
+    func_80186F14((void *)s0);
+}
+
 
 #include "common.h"
 
@@ -3362,7 +3376,18 @@ void func_80182998(void) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80182A8C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80182D80);
+extern void func_80186178(s32 *a0);
+extern void func_8012B23C(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80186304();
+
+void func_80182D80(s32 arg0) {
+    func_80186178((s32 *)arg0);
+    func_8012B23C(arg0);
+    func_8012AD44((s32 *)arg0, 0xC);
+    func_80186304((u8 *)arg0, 0, 2);
+}
+
 
 extern void func_8018622C();
 
@@ -4109,7 +4134,21 @@ void func_8018415C(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80184184);
+void func_80184184(s32 a0) {
+    s32 a1;
+
+    a1 = *(s32 *)(a0 + 0x20);
+    *(u8 *)(a0 + 0xC1) = 0;
+    *(u16 *)(a0 + 0x5E) = 0;
+    *(s32 *)(a0 + 0x1C) = 0x18;
+    *(u32 *)(a1 + 4) |= 0x80000000;
+    *(u16 *)(a0 + 2) = 4;
+    if (*(s32 *)(a0 + 0xCC) != 0) {
+        *(u16 *)*(s32 *)(a0 + 0xCC) = 0;
+    }
+    func_8002D4C8(0x509, 0);
+}
+
 
 #include "common.h"
 
@@ -4232,7 +4271,22 @@ void func_80184404(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80184480);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8012B200(u8 *a0);
+extern s32 D_801963FC;
+
+void func_80184480(s32 arg0) {
+    s32 s0 = arg0;
+
+    *(s32 *)(s0 + 0x58) = (s32)&D_801963FC;
+    *(u16 *)(s0 + 0x5C) = 0x8C00;
+    func_8012AD44((s32 *)s0, 1);
+    func_8012B200((u8 *)s0);
+    *(s32 *)(s0 + 0xC) = 0;
+    *(s32 *)(s0 + 8) = 0;
+    *(s32 *)(s0 + 4) = 0;
+}
+
 
 void func_801844D4(s32 arg0) {
     s32 self = arg0;
@@ -4536,7 +4590,17 @@ void func_80184828(void *a0)
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801849E4);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80184A34);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80184A34(void *arg0) {
+    *(u16 *)((s32)arg0 + 0xDC) = *(u16 *)((s32)arg0 + 0x6);
+    *(u16 *)((s32)arg0 + 0xDE) = *(u16 *)((s32)arg0 + 0xA);
+    *(u16 *)((s32)arg0 + 0xE0) = *(u16 *)((s32)arg0 + 0xE);
+    func_8012AD44((s32 *)arg0, 5);
+    *(u16 *)((s32)arg0 + 0x34) = 4;
+    *(s32 *)((s32)arg0 + 0x1C) = 5;
+}
+
 
 #include "common.h"
 
@@ -6004,7 +6068,18 @@ void func_80186F60(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80186F9C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80187070);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_80187070(s32 arg0) {
+    s32 self = arg0;
+    s32 v1;
+
+    v1 = func_8012C658(0x56, 5, self);
+    if (v1 != 0) {
+        *(s32 *)(v1 + 0xCC) = *(s32 *)(self + 0xCC);
+    }
+}
+
 
 #include "common.h"
 
@@ -6406,7 +6481,22 @@ void func_801877FC(s32 s0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801878C0);
+void func_801878C0(void *arg0) {
+    s32 s0 = (s32)arg0;
+
+    func_80182810((void *)s0);
+    if (*(u32 *)(s0 + 0xE8) & 0x2000) {
+        *(u32 *)(s0 + 0x1C) = 0x18;
+    } else {
+        *(u32 *)(s0 + 0x1C) = 0x30;
+    }
+    func_801828D8((void *)s0);
+    *(u32 *)(s0 + 0xE8) = *(u32 *)(s0 + 0xE8) & 0xFFFFFF7F;
+}
+
+extern void func_80182810();
+extern void func_801828D8();
+
 
 void func_8018791C(void *a0) {
     s32 s0 = (s32)a0;
@@ -6446,7 +6536,17 @@ extern void func_80181900(void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80187A38);
+extern void func_80186F58();
+extern void func_80186304();
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80187A38(void *arg0) {
+    *(u32 *)((s32)arg0 + 0xE8) |= 1;
+    func_80186F58(arg0);
+    func_80186304((u8 *)arg0, 0xE, 2);
+    func_8012AD44((s32 *)arg0, 4);
+}
+
 
 #include "common.h"
 
@@ -6733,7 +6833,19 @@ void func_8018810C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80188150);
+extern s32 func_8012BEE8(s32 a0);
+extern u16 D_801E4398;
+
+void func_80188150(void *a0) {
+    s32 s0 = (s32)a0;
+
+    func_8012BEE8(s0);
+    if (*(s32 *)(s0 + 0x1C) == 1) {
+        *(u16 *)(s0 + 0x76) = 0x1E;
+        D_801E4398 = 0x1E;
+    }
+}
+
 
 extern s32 func_801830F4(s32, s32);
 extern void func_8002D4C8(s32 a0, s32 a1);
@@ -10351,7 +10463,20 @@ void func_8018D7F0(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018D8A8);
+extern s32 D_801270C8;
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018EA04(s32 a0);
+
+void func_8018D8A8(void *a0)
+{
+    if (D_801270C8 == 0x15) {
+        func_8018EA04(2);
+        func_8002D4C8(5, 0);
+        *(u32 *)((s32)a0 + 0x1C) = 0xE;
+        *(u16 *)((s32)a0 + 2) += 1;
+    }
+}
+
 
 void func_8018D904(void *a0) {
         *(s16 *)((s32)a0 + 0x2) += 1;
diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
index 539cd469b..03c1416ed 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -7940,7 +7940,18 @@ extern void func_8018452C(void);
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183630);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183954);
+extern void func_8012AD80(s32 a0);
+
+s32 func_80183954(s32 a0) {
+    u8 *s0;
+    s16 val;
+
+    func_8012AD80(a0);
+    s0 = (u8 *)a0;
+    val = *(s16 *)(s0 + 0xA);
+    return ((val - 0xB0) < -0xA01) ? 0 : 2;
+}
+
 
 extern s32 rand(void);
 extern u8 D_801202A0[];
@@ -8420,7 +8431,18 @@ void func_80184964(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801849D4);
+extern s32 func_80029178(s32 arg);
+extern void func_80029124(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801F45D4;
+
+void func_801849D4(s32 param_1) {
+    if ((func_80029178(0x125) & 0xFF) != 0) {
+        func_8012A828(param_1, &D_801F45D4);
+        func_80029124(0x125, 0);
+    }
+}
+
 
 s32 func_80184A28(s32 *a0) {
     return *(s16 *)((char *)a0 + 0xFE) == 0;
@@ -10066,7 +10088,19 @@ void func_8018707C(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801870D0);
+extern void func_8012AD80(s32 a0);
+extern void func_8012C218(void *a0);
+
+void func_801870D0(s32 param_1) {
+    s32 s0;
+
+    s0 = param_1;
+    func_8012AD80(s0);
+    if (*(s16 *)(s0 + 0x98) == 0) {
+        func_8012C218((void *)s0);
+    }
+}
+
 
 #include "common.h"
 
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 738112489..10d0435a2 100644
--- a/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
+++ b/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
@@ -6369,7 +6369,29 @@ void func_80184474(s32 param_1)
 void func_80184510(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184518);
+#include "common.h"
+
+extern void func_8012B23C(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801CC344;
+extern u8 D_801D0BB4;
+
+void func_80184518(void *arg0)
+{
+    s32 s0;
+    s32 v0;
+
+    s0 = (s32)arg0;
+    func_8012B23C(s0);
+    func_8012B14C(s0, (s32)&D_801CC344);
+    func_8012A828(s0, (void *)&D_801D0BB4);
+    v0 = *(s32 *)(s0 + 0x20);
+    *(s16 *)(v0 + 0x10) = -0x400;
+    *(s16 *)(s0 + 2) = 3;
+    *(s32 *)(s0 + 0x1C) = 0x28;
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern void func_8012B2CC(s32 a0);
@@ -8414,7 +8436,26 @@ void func_801878A8(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80187940);
+#include "common.h"
+
+void func_80187940(s32 arg0) {
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 D_801E0F44;
+
+    s32 p1;
+    s32 p2;
+
+    func_8012A828(arg0, (void *)&D_801E0F44);
+    *(s16 *)(arg0 + 2) = 0x10;
+    p1 = *(s32 *)(arg0 + 0x20);
+    *(s32 *)(p1 + 4) |= 0x80000000;
+    p2 = *(s32 *)(arg0 + 0x20);
+    *(s16 *)(arg0 + 0x34) = 0;
+    *(s16 *)(p2 + 0x1C) = 0x1000;
+    *(s16 *)(p2 + 0x1A) = 0x1000;
+    *(s16 *)(p2 + 0x18) = 0x1000;
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
index 22f965668..e369538f6 100644
--- a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
+++ b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
@@ -3781,9 +3781,29 @@ extern void func_80029514(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017EEF8);
+extern void func_80029124(s32 a0, s32 a1);
+extern void func_80029514(s32 a0);
+
+void func_8017EEF8(void) {
+    func_80029514(0x118);
+    func_80029124(0xF9, 1);
+    func_80029124(0xFA, 0);
+    func_80029124(0x109, 1);
+}
+
+
+extern void func_80029514(s32 a0);
+extern void func_80029124(s32 a0, s32 a1);
+extern s32 func_801788B8(s32 a0, s32 a1);
+extern s32 func_8017F1B4(s32 a0);
+
+void func_8017EF3C(s32 arg0) {
+    func_80029514(0x118);
+    func_80029124(0xF9, 0);
+    func_80029124(0xFA, 1);
+    func_801788B8(arg0, (s32)func_8017F1B4);
+}
 
-INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017EF3C);
 
 extern void func_800D0F4C(s32 arg);
     void func_8017EF90(void) {
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c b/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
index ed1dcac16..fbfb3ceef 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
@@ -5292,7 +5292,14 @@ void func_80181AD0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181B48);
+void func_80181B48(int param_1)
+{
+    void **fp = *(void ***)(*(int *)(param_1 + 0x64) + 0xDC);
+
+    if (fp != 0 && *fp != 0)
+        (*(void (*)(void))*fp)();
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181B90);
 
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
index 7ec857969..100d3b33f 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
@@ -3772,7 +3772,27 @@ void func_801865A4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_80184BD8", func_80186668);
+void func_80186668(s32 a0)
+{
+    s32 sp18;
+    s32 ret;
+
+    sp18 = *(s32 *)(a0 + 0x20);
+    ret = func_80047948((*(s32 *)(a0 + 0x1C) << 9) >> 4);
+    *(s16 *)(sp18 + 0x18) = *(s16 *)(sp18 + 0x1A) = *(s16 *)(sp18 + 0x1C) = ret * 2;
+    if (*(s16 *)(a0 + 0x100) <= *(s16 *)(sp18 + 0x18)) {
+        *(s16 *)(sp18 + 0x18) = *(s16 *)(sp18 + 0x1A) = *(s16 *)(sp18 + 0x1C) = *(s16 *)(a0 + 0x100);
+        *(u16 *)(a0 + 2) = 1;
+        *(u16 *)(a0 + 0x5C) = *(u16 *)(*(s32 *)(a0 + 0x78) + 2);
+        *(u16 *)(a0 + 0x76) = *(u16 *)*(s32 *)(a0 + 0x78);
+        *(s32 *)(a0 + 0xE0) &= ~1;
+        if (!(*(u16 *)(a0 + 0x70) & 1)) {
+            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) &= ~0x10;
+        }
+    }
+    --*(s32 *)(a0 + 0x1C);
+}
+
 
     typedef struct { u8 b[8]; } Blk8_80186740;
     typedef struct {
@@ -4478,7 +4498,38 @@ void func_801875F0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_80184BD8", func_801876C4);
+extern s32 D_801A9A78[];
+extern s32 D_801A9A7C[];
+extern s32 D_801A9A80[];
+extern s32 D_801A9A84[];
+extern s32 D_801A9A88[];
+extern s32 func_8012C51C(void *a0, s32 a1);
+
+void func_801876C4(void *a0, s32 a1) {
+    s32 sp10[5];
+    s32 obj;
+    register s32 w __asm__("$7");
+    s32 x, y, z;
+    register s32 t __asm__("$3");
+
+    obj = (s32)a0;
+    x = D_801A9A78[a1 * 5];
+    y = D_801A9A7C[a1 * 5];
+    z = D_801A9A80[a1 * 5];
+    w = D_801A9A84[a1 * 5];
+    sp10[0] = x;
+    sp10[1] = y;
+    sp10[2] = z;
+    sp10[3] = w;
+    t = D_801A9A88[a1 * 5];
+    sp10[4] = t;
+    __asm__ __volatile__("" ::: "memory");
+    ((u16 *)sp10)[0] = ((u16 *)sp10)[0] + *(u16 *)(obj + 6);
+    ((u16 *)sp10)[1] = ((u16 *)sp10)[1] + *(u16 *)(obj + 0xA);
+    ((u16 *)sp10)[2] = ((u16 *)sp10)[2] + *(u16 *)(obj + 0xE);
+    func_8012C51C(sp10, obj);
+}
+
 
 typedef struct {
     s32 a;      /* 0x00 -> D_801D0120 */
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c b/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
index af1151f40..fcfe86b7f 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
@@ -3419,7 +3419,13 @@ DEFINE_func_80172760()  /* dedup: shared engine-core @0x80172760 (src/shared) */
 DEFINE_func_80172780()  /* dedup: shared engine-core @0x80172780 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_801727D0);
+extern int (*D_8018718C[])(void);
+
+s32 func_801727D0(void *a0)
+{
+    D_8018718C[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_8017280C()  /* dedup: shared engine-core @0x8017280c (src/shared) */
 
@@ -3433,7 +3439,13 @@ void func_8017288C(void) {
 DEFINE_func_80172894()  /* dedup: shared engine-core @0x80172894 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_801728E4);
+extern void (*D_80187198[])(void);
+
+s32 func_801728E4(void *a0)
+{
+    D_80187198[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172920()  /* dedup: shared engine-core @0x80172920 (src/shared) */
 
@@ -3447,7 +3459,13 @@ void func_801729A8(void) {
 DEFINE_func_801729B0()  /* dedup: shared engine-core @0x801729b0 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_801729F0);
+extern void (*D_801871A4[])(void);
+
+s32 func_801729F0(void *a0)
+{
+    D_801871A4[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172A2C()  /* dedup: shared engine-core @0x80172a2c (src/shared) */
 
@@ -3464,7 +3482,13 @@ void func_80172B0C(void) {
 DEFINE_func_80172B14()  /* dedup: shared engine-core @0x80172b14 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_80172B44);
+s32 func_80172B44(void *a0)
+{
+
+    extern void (*D_801871B4[])(void);
+    D_801871B4[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172B80()  /* dedup: shared engine-core @0x80172b80 (src/shared) */
 
@@ -3499,7 +3523,12 @@ void func_80172D60(void) {
 DEFINE_func_80172D68()  /* dedup: shared engine-core @0x80172d68 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_80172DAC);
+s32 func_80172DAC(void *a0)
+{
+    extern void (*D_801871CC[])(void);
+    D_801871CC[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172DE8()  /* dedup: shared engine-core @0x80172de8 (src/shared) */
 
@@ -3534,7 +3563,12 @@ DEFINE_func_80172FEC()  /* dedup: shared engine-core @0x80172fec (src/shared) */
 DEFINE_func_8017303C()  /* dedup: shared engine-core @0x8017303c (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_80173078);
+s32 func_80173078(void *a0)
+{
+    extern void (*D_801871D8[])(void);
+    D_801871D8[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801730B4()  /* dedup: shared engine-core @0x801730b4 (src/shared) */
 
@@ -3548,7 +3582,13 @@ void func_8017316C(void) {
 DEFINE_func_80173174()  /* dedup: shared engine-core @0x80173174 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_8017319C);
+extern void (*D_801871E4[])(void);
+
+s32 func_8017319C(void *a0)
+{
+    D_801871E4[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801731D8()  /* dedup: shared engine-core @0x801731d8 (src/shared) */
 
@@ -3665,7 +3705,12 @@ void func_801736A8(void) {
 DEFINE_func_801736B0()  /* dedup: shared engine-core @0x801736b0 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_801736FC);
+s32 func_801736FC(void *a0) {
+
+    extern void (*D_80187204[])(void);
+    D_80187204[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80173738()  /* dedup: shared engine-core @0x80173738 (src/shared) */
 
@@ -3693,7 +3738,13 @@ void func_801738D4(void) {
 DEFINE_func_801738DC()  /* dedup: shared engine-core @0x801738dc (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_8017390C);
+s32 func_8017390C(void *a0)
+{
+
+    extern void (*D_8018721C[])(void);
+    D_8018721C[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80173948()  /* dedup: shared engine-core @0x80173948 (src/shared) */
 
@@ -3759,7 +3810,13 @@ void func_80174274(void) {
 DEFINE_func_8017427C()  /* dedup: shared engine-core @0x8017427c (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_801742A4);
+extern void (*D_8018724C[])(void);
+
+s32 func_801742A4(void *a0)
+{
+    D_8018724C[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801742E0()  /* dedup: shared engine-core @0x801742e0 (src/shared) */
 
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c b/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
index a5bf68224..d1e63041b 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
@@ -5981,7 +5981,13 @@ void func_8017EB88(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_8017AE2C", func_8017EBC4);
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_8017AE2C", func_8017ED68);
+extern s32 func_8017EEC4(s32 arg0, void *arg1);
+extern s32 D_80187850;
+
+void func_8017ED68(s32 arg0) {
+    func_8017EEC4(arg0, &D_80187850);
+}
+
 
 
 extern s16 D_80126940;
diff --git a/src/ov_SC02_041/ov_SC02_041_jr_8017BEBC.c b/src/ov_SC02_041/ov_SC02_041_jr_8017BEBC.c
index 13c7b5e0b..e8825348f 100644
--- a/src/ov_SC02_041/ov_SC02_041_jr_8017BEBC.c
+++ b/src/ov_SC02_041/ov_SC02_041_jr_8017BEBC.c
@@ -7792,7 +7792,59 @@ s32 a0;
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_041/nonmatchings/ov_SC02_041_jr_8017BEBC", func_80183014);
+extern s32  func_8012BC60(void *a0, void *a1);
+extern s32  func_8012B6D4(s16 *a0, s16 *a1);
+extern void func_8012B0B4(unsigned int *p, int a1, int a2);
+extern s32  func_8012CEB0(void *a0, void *a1, s32 a2);
+extern void func_8012ADE4(u8 *a0);
+
+void func_80183014(s32 a0) {
+    extern u8 D_801202A0[];
+    u8 *p;
+    s16 *self4;
+    unsigned int *sc;
+    s32 i;
+    s32 ang;
+    s16 v10[4];  /* sp+0x10 */
+    s16 v18[4];  /* sp+0x18 */
+    s32 sp20[2]; /* sp+0x20 — func_8012B0B4 output */
+
+    i = 0;
+    p = D_801202A0;
+    self4 = (s16 *)(a0 + 4);
+    sc = (unsigned int *)sp20;
+    do {
+        switch (*(u16 *)p) {
+        case 0x1DC:
+            if ((u8 *)a0 != p) {
+                if (func_8012BC60((void *)self4, (void *)(p + 4)) < 0x900) {
+                    ang = func_8012B6D4(self4, (s16 *)(p + 4));
+                    func_8012B0B4(sc, ang, 0x31);
+                    v18[0] = *(u16 *)(p + 6);
+                    v18[1] = *(u16 *)(p + 0xA);
+                    v18[2] = *(u16 *)(p + 0xE);
+                    v18[0] += sp20[0];
+                    v18[2] += sp20[0] >> 16;
+                    v10[0] = *(u16 *)(a0 + 0x3A);
+                    v10[1] = *(u16 *)(a0 + 0x3E);
+                    v10[2] = *(u16 *)(a0 + 0x42);
+                    if ((func_8012CEB0(v10, v18, 0) & 0x2000) != 0) {
+                        *(u16 *)(a0 + 6) = v18[0];
+                        *(u16 *)(a0 + 0xA) = v18[1];
+                        *(u16 *)(a0 + 0xE) = v18[2];
+                        return;
+                    }
+                    func_8012ADE4((u8 *)a0);
+                    return;
+                }
+            }
+            break;
+        }
+        i++;
+        p += 0x10C;
+    } while (i < 0x60);
+}
+
 
 extern s32 func_80132EF4(s32 a0, s32 a1);
 typedef struct { short a, b, c; } SV3_80181D44_8018317C;   /* == the TU's own `SV3` (engine_types.h:612); renamed only because
diff --git a/src/ov_SC03_001/ov_SC03_001_jr_80184DDC.c b/src/ov_SC03_001/ov_SC03_001_jr_80184DDC.c
index 25c1c9db7..edaa94a94 100644
--- a/src/ov_SC03_001/ov_SC03_001_jr_80184DDC.c
+++ b/src/ov_SC03_001/ov_SC03_001_jr_80184DDC.c
@@ -3056,5 +3056,18 @@ void func_80184DDC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_jr_80184DDC", func_80184F18);
+void func_80184F18(s32 *arg0)
+{
+    extern void func_8012E88C(s32 a0);
+    extern void func_8012A828(s32 a0, s32 a1);
+    extern void func_80187750(s32 a0);
+    extern short D_801C36E8;
+
+    *(s16 *)((s32)arg0 + 2) = 9;
+    *(s16 *)((s32)arg0 + 0x34) = 0;
+    func_8012E88C((s32)arg0);
+    func_8012A828((s32)arg0, (s32)&D_801C36E8);
+    func_80187750((s32)arg0);
+}
+
 
diff --git a/src/ov_SC03_002/ov_SC03_002_jr_8017D604.c b/src/ov_SC03_002/ov_SC03_002_jr_8017D604.c
index 363dcf8e3..415612fc0 100644
--- a/src/ov_SC03_002/ov_SC03_002_jr_8017D604.c
+++ b/src/ov_SC03_002/ov_SC03_002_jr_8017D604.c
@@ -5088,6 +5088,21 @@ void func_80181B14(void) {
 void func_80181B1C(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_jr_8017D604", func_80181B24);
+void func_80181B24(s32 a0)
+{
+    extern s32 D_801A4304;
+    extern s32 func_80183550(s32 a0);
+    extern void func_80183480(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern s32 func_8012BD14(s32 a0);
+    extern void func_8014CB68(void);
+
+    if (func_80183550(a0) != 0) {
+        func_80183480(a0, (s32)&D_801A4304, 1, 0x70);
+    }
+    if (func_8012BD14(*(s32 *)(a0 + 0x64)) < 0x4001) {
+        func_8014CB68();
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_jr_8017D604", func_80181B88);
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
index b4aa022eb..fdb5ba0d1 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
@@ -6517,7 +6517,13 @@ void func_8017F510(s32 arg0, s32 arg1, s32 arg2)
 
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80180CAC);
+void func_80180CAC(void) {
+    func_80029124(0x142, 0);
+    if ((func_800291B4(0xCC) & 0xFF) == 1) {
+        func_800291A0(0xCC, 2);
+    }
+}
+
 
 extern void func_80029124(s32 arg0, s32 arg1);
     void func_80180CF0(void) {
@@ -13005,7 +13011,20 @@ void func_8018A2F8(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A384);
+void func_8018A384(s16 *param_1)
+{
+    s32 s0 = (s32)param_1;
+    u16 v;
+
+    v = *(u16 *)(s0 + 0xFE);
+    v = v - 1;
+    *(u16 *)(s0 + 0xFE) = v;
+    if ((s32)(v << 16) <= 0) {
+        func_80143B6C(param_1, 0);
+        *(u16 *)(s0 + 0xFE) = 8;
+    }
+}
+
 
 #include "common.h"
 
@@ -13075,11 +13094,47 @@ void func_8018A4B4(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A538);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u8 D_801E0084;
+extern s32 D_801D7E84;
+extern s32 D_801F7740;
+
+void func_8018A538(s32 param_1) {
+    s32 v1;
+
+    *(u16 *)(param_1 + 2) = 4;
+    *(u16 *)(param_1 + 0x34) = 0;
+    func_8012A828(param_1, &D_801E0084);
+    v1 = D_801D7E84;
+    *(s32 *)(param_1 + 0x1C) = 0x28;
+    D_801F7740 = v1;
+    func_8002D4C8(0x660, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A598);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A5C4);
+extern void func_8012CBA4(s32 a0);
+extern void func_80131E00();
+extern void func_8012ADE4(u8 *a0);
+
+s32 func_8018A5C4_impl(s32 a0) __asm__("func_8018A5C4");
+s32 func_8018A5C4_impl(s32 a0)
+{
+    s32 flags;
+
+    flags = ((s32 (*)(s32))func_8012CBA4)(a0);
+    if ((flags & 0x1000) != 0) {
+        ((void (*)(s32, s32))func_80131E00)(a0, 0x12);
+        return 0;
+    }
+    if (flags != 0x2000) {
+        func_8012ADE4((u8 *)a0);
+    }
+    return 1;
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
index 2461e0c28..02ad28d69 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
@@ -5645,7 +5645,20 @@ void func_8017FA84(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017FB40);
+void func_8017FB40(s32 param_1)
+{
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_801BEC20[];
+
+    *(u16 *)(param_1 + 0x5C) = 0;
+    *(s32 *)(param_1 + 0x1C) = 0x10;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10;
+    *(s16 *)(param_1 + 0x34) = 0;
+    *(s16 *)(param_1 + 0xA) = *(s16 *)(param_1 + 0xA) - 0x3C;
+    func_8012A828(param_1, (void *)D_801BEC20);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017FBA0);
 
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_80181F94.c b/src/ov_SC03_007/ov_SC03_007_jr_80181F94.c
index b57f4839a..bbb7c558b 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_80181F94.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_80181F94.c
@@ -3450,7 +3450,16 @@ void func_80182A18(int param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_80181F94", func_80182A80);
+extern s32 func_8012BCCC(s32 a0);
+
+void func_80182A80(s32 param_1) {
+    s32 ret;
+    ret = func_8012BCCC(param_1);
+    if (ret < 0x24001) {
+        func_80182468(param_1);
+    }
+}
+
 
 extern s32 func_8012BEE8(s32 arg);
     extern s32 func_801824A8();
diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c b/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
index 86e3bf0ce..97e0dd073 100644
--- a/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
+++ b/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
@@ -3421,7 +3421,20 @@ void func_8017DCA0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DCC8);
+void func_8017DCC8(s32 *a0)
+{
+    s32 v0;
+
+    v0 = func_800291B4(0xCE) & 0xFF;
+    if (v0 == 9) {
+        func_80171A04(a0);
+        func_800291A0(0xCE, 0);
+    } else {
+        func_80171A10(a0);
+        func_800291A0(0xCE, 1);
+    }
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017DD30(void) {
@@ -4348,11 +4361,47 @@ void func_8017F584(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F64C);
+extern void func_8017EB88();
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_8012AD50(void *a0);
+extern void func_80019064(void *a0);
+extern s32 D_80062BE8;
+
+void func_8017F64C(s32 a0)
+{
+    func_8017EB88(a0);
+    if (func_8012BEE8(a0) != 0) {
+        *(u16 *)(a0 + 0x104) = 0;
+        *(s32 *)(a0 + 0x1C) = 0x18;
+        func_8012AD50((void *)a0);
+    }
+    if ((*(u32 *)(a0 + 0x1C) & 7) == 0) {
+        func_80019064(&D_80062BE8);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F6B8);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F718);
+extern void func_8017EB88(s32 arg0);
+extern void func_801437D8(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s8 D_801852D0[];
+extern u8 D_80185300[];
+extern void func_80016450(s32 a0, s32 a1);
+
+void func_8017F718(s32 arg0) {
+    s32 temp;
+
+    func_8017EB88(arg0);
+    func_801437D8(arg0 + 0x102, (s32)D_801852D0, (s32)D_80185300, 0);
+    temp = *(u16 *)(arg0 + 0xFE) + 3;
+    *(u16 *)(arg0 + 0xFE) = temp;
+    if ((s16)temp >= 0x100) {
+        *(u16 *)(arg0 + 0xFE) = 0xFF;
+    }
+    func_80016450(*(u8 *)(arg0 + 0xFE), 0);
+}
+
 
 extern void func_8012C1B8(void);
 extern void func_8012CAE4(void *a0);
diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c b/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
index ef7078474..28fbf20ee 100644
--- a/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
+++ b/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
@@ -4234,7 +4234,27 @@ void func_8017DBE4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8017AE2C", func_8017DCB4);
 
-INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8017AE2C", func_8017DE18);
+extern u16 D_800B99DC;
+extern u8 D_8017E8A4[];
+extern void func_8013C9C4(void *a0);
+extern void func_8017DCB4(s32 a0);
+extern void func_800D1724(s32 a0);
+extern u8 D_80181B58[];
+
+void func_8017DE18(void *a0) {
+    u16 val;
+
+    val = *(u16 *)((char *)a0 + 0xE6);
+    val--;
+    *(u16 *)((char *)a0 + 0xE6) = val;
+    if ((val << 0x10) == 0) {
+        *(u16 *)((char *)a0 + 0xE6) = (D_800B99DC & 7) + 1;
+        func_8013C9C4(&D_8017E8A4);
+    }
+    func_8017DCB4((s32)a0);
+    func_800D1724((s32)&D_80181B58);
+}
+
 
 void func_8017DE90(s32 *a0) {
     *(u16 *)((s32)a0 + 6) = *(u16 *)(*(s32 *)((s32)a0 + 100) + 0xDE);
diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c b/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
index 6610ec54a..fd21e663b 100644
--- a/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
+++ b/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
@@ -3857,7 +3857,17 @@ void func_8017EBA0(s32 a0, s32 a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_jr_8017C730", func_8017ECD0);
+extern void func_80139A68(s32 a0, u16 a1);
+extern s16 D_80184E7C[];
+extern s32 D_80184E84[];
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_8017ECD0(s32 a0) {
+    func_80139A68(D_80184E7C[*(s16 *)(a0 + 0x70)], 0);
+    func_80178B18(a0, D_80184E84[*(s16 *)(a0 + 0x70)]);
+    func_8012AD44((s32 *)a0, 2);
+}
+
 
 extern void func_8012AD44(s32 *a0, s16 a1);
     void func_8017ED40(s32 arg0) {
diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c b/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c
index 02b9fd192..850f9c403 100644
--- a/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c
+++ b/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c
@@ -4681,7 +4681,24 @@ void func_8017E834(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E8E4);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801933C0[];
+
+void func_8017E8E4(s32 a0) {
+    s32 s0;
+    s32 v1;
+
+    s0 = a0;
+    *(u16 *)(s0 + 6) = *(u16 *)(s0 + 6) - 3;
+    v1 = *(s32 *)(s0 + 0x1C) - 1;
+    *(s32 *)(s0 + 0x1C) = v1;
+    *(u16 *)(s0 + 0xE) = *(u16 *)(s0 + 0xE) + 1;
+    if (v1 == 0) {
+        func_8012A828(a0, D_801933C0);
+        *(s16 *)(s0 + 2) = 5;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E948);
 
@@ -4784,7 +4801,16 @@ void func_8017EB2C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017EC30);
+extern s32 func_8012BD14(s32 a0);
+
+void func_8017EC30(s32 a0)
+{
+    if ((func_8016F1AC() == 0) && (func_8012BD14(a0) < 0x401)) {
+        func_8017D884();
+        *(s16 *)(a0 + 2) = 2;
+    }
+}
+
 
 extern s32 func_800291B4(s32 a0);
 extern void func_8012C218(void *a0);
@@ -4816,7 +4842,22 @@ extern void func_8012CAE4(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017ED30);
+extern s32 func_8012CBCC(s32 a0);
+extern void func_8012C218(void *a0);
+
+void func_8017ED30(s32 a0)
+{
+    s32 s0;
+
+    s0 = a0;
+    func_8012CBCC(a0);
+    if (((u16)(*(u16 *)(s0 + 6) + 0x300) >= 0x601U) ||
+        (*(s16 *)(s0 + 0xA) < -0x400) ||
+        ((u16)(*(u16 *)(s0 + 0xE) + 0x100) >= 0x701U)) {
+        func_8012C218((void *)s0);
+    }
+}
+
 
 extern void func_8012C1B8(void);
 extern void func_8012CAE4(void *a0);
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
index 72c575347..d9ef6c572 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -6603,7 +6603,26 @@ void func_80186C98(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80186D0C);
+#include "common.h"
+
+extern void func_8012CBCC(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+extern u8 D_801AE46C[];
+
+void func_80186D0C(void *a0)
+{
+    if (((s32 (*)(s32))func_8012CBCC)(a0) & 0x8000) {
+        *(s16 *)((s32)a0 + 0x2) = 0x11;
+        func_8012A828(a0, D_801AE46C);
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)((s32)a0 + 0xFC);
+        func_8002D4C8(0x640, 0);
+    }
+
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) += 0x48;
+}
+
 
 #include "common.h"
 
@@ -7359,7 +7378,17 @@ void func_80187C28(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80187CF4);
+extern void func_80183264(s32 a0);
+
+void func_80187CF4(void *a0) {
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1C) += 0xA00;
+    if (*(s16 *)((s32)a0 + 0xFC) == 4) {
+        *(u16 *)((s32)a0 + 0x2) = 2;
+        *(s32 *)((s32)a0 + 0x1C) = 0x79;
+    }
+    func_80183264((s32)a0);
+}
+
 
 extern s32 func_8012C354(s32 a0, s32 a1);
 extern void func_8012A828(s32 a0, void *a1);
@@ -8037,7 +8066,19 @@ void func_80188F4C(void *a0)
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80188FF0);
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189094);
+extern void func_8012C218(void *a0);
+
+void func_80189094(s32 param_1) {
+    s32 v0;
+
+    *(u32 *)(*(s32 *)(param_1 + 0x20) + 4) ^= 0x80000000;
+    v0 = *(s32 *)(param_1 + 0x1C) - 1;
+    *(s32 *)(param_1 + 0x1C) = v0;
+    if (v0 == 0) {
+        func_8012C218((void *)param_1);
+    }
+}
+
 
 extern void func_8012CBCC(s32 a0);
     extern void func_8012C218(void *a0);
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c b/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
index db1cefca1..1a143e228 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
@@ -3734,7 +3734,29 @@ void func_8017FC50(void *param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FCE0);
+#include "common.h"
+
+extern s32 func_8012E504(s32 a0, s32 a1);
+extern s32 func_80029178(s32 arg);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern s32 func_80143970(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012CAE4(void *a0);
+
+extern u8 D_8018B720[];
+extern u8 D_80187B3C[];
+
+void func_8017FCE0(void *a0) {
+    if ((func_8012E504((s32)a0, 0x95) != 0) || ((func_80029178(0x9D) & 0xFF) != 0)) {
+        func_8012CAE4(a0);
+    } else if (func_8012C354((s32)a0, (s32)D_8018B720) != 0) {
+        func_80143970((s32)a0);
+        func_8012A828((s32)a0, D_80187B3C);
+        *(s16 *)((s32)a0 + 2) = 1;
+        *(s16 *)((s32)a0 + 0x34) = 0;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FD74);
 
diff --git a/src/ov_SC03_030/ov_SC03_030_jr_8017AE2C.c b/src/ov_SC03_030/ov_SC03_030_jr_8017AE2C.c
index 7daa5efcf..6908beec9 100644
--- a/src/ov_SC03_030/ov_SC03_030_jr_8017AE2C.c
+++ b/src/ov_SC03_030/ov_SC03_030_jr_8017AE2C.c
@@ -4664,7 +4664,21 @@ void func_8017EBF8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8017AE2C", func_8017EC34);
+extern void func_8014BF18(s32 a0);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern s32 func_8012AD50(void *a0);
+
+void func_8017EC34(s32 a0) {
+    s32 s0 = a0;
+
+    func_8014BF18(4);
+    func_8012C658(0xCA, 0, s0);
+    func_8012C658(0xCA, 1, s0);
+    func_8012C658(0xCA, 2, s0);
+    func_8012C658(0xCA, 3, s0);
+    func_8012AD50((void *)s0);
+}
+
 
 extern u8 func_8014BF6C(void);
 
@@ -5608,7 +5622,31 @@ void func_8018101C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8017AE2C", func_8018107C);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012A828(s32, void *);
+extern void func_8012C588();
+extern s32 rand(void);
+extern u8 D_801DCCE8[];
+extern s32 D_801DD860;
+
+void func_8018107C(s32 a0) {
+    register s32 v0 __asm__("$2");
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+        return;
+    }
+    func_8001C214(v0, (s32)D_801DCCE8);
+    ((void (*)(s32, s32))func_8012A828)((s32)a0, (s32)&D_801DD860);
+    ((void (*)(s32, s32))func_8012C588)(0x10F, (s32)a0);
+    *(s32 *)((s32)a0 + 0x1C) = rand() % 31 + 0x3C;
+    *(u16 *)((s32)a0 + 2) = 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8017AE2C", func_8018112C);
 
@@ -5651,7 +5689,28 @@ void func_80181300(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8017AE2C", func_8018133C);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012C588();
+
+void func_8018133C(void *a0) {
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+    func_8001C214(v0, 0);
+    *(u16 *)((s32)a0 + 0xFC) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x36);
+    *(u16 *)((s32)a0 + 0xFE) = 200;
+    *(u16 *)((s32)a0 + 0x70) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x70);
+    func_8012C588(0x10B, a0);
+    *(u16 *)((s32)a0 + 2) = 2;
+}
+
 
 extern s32 func_80181C08(void *a0);
 extern void func_80181708(void *a0);
diff --git a/src/ov_SC03_095/ov_SC03_095_jr_8017BEBC.c b/src/ov_SC03_095/ov_SC03_095_jr_8017BEBC.c
index 5820c5868..e26bb73d0 100644
--- a/src/ov_SC03_095/ov_SC03_095_jr_8017BEBC.c
+++ b/src/ov_SC03_095/ov_SC03_095_jr_8017BEBC.c
@@ -3570,7 +3570,20 @@ s32 a0;
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_095/nonmatchings/ov_SC03_095_jr_8017BEBC", func_8017D758);
+void func_8017D758(s32 a0) {
+    extern s16 D_80184A4A[];
+    s32 t;
+
+    t = *(s32 *)(a0 + 0x1C) - 1;
+    *(s32 *)(a0 + 0x1C) = t;
+    if (t == 0) {
+        s32 val = D_80184A4A[*(s16 *)(a0 + 0xFC) * 4];
+        *(s16 *)(a0 + 0x2) = 3;
+        *(s32 *)(a0 + 0x1C) = val;
+    }
+    func_8012DFD4((u8 *)a0);
+}
+
 
 extern void func_8012CBA4(s32 a0);
 extern void func_8012DFD4(u8 *a0);
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
index a75346f43..f11ba3579 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
@@ -4418,7 +4418,19 @@ INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_801818E
 
 INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_80181C84);
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_80182220);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_80183EE8(void);
+extern void func_80184604();
+
+void func_80182220(s32 a0) {
+    *(s16 *)((s32)a0 + 0x2) = 0xB;
+    *(s32 *)((s32)a0 + 0x1C) = 0x3C;
+    *(s16 *)((s32)a0 + 0x34) = 0;
+    func_8002D4C8(0x72C, 0);
+    func_80183EE8();
+    func_80184604(-1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_8018226C);
 
@@ -6634,7 +6646,35 @@ void func_8018784C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_80187890);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80187890(void *arg0) {
+    s32 t;
+    s32 v0;
+
+    *(s32 *)((u8 *)arg0 + 0x20) = ((s32 (*)(void))func_8012C1B8)();
+    if (*(s32 *)((u8 *)arg0 + 0x20) == 0) {
+        func_8012CAE4((void *)arg0);
+        return;
+    }
+    func_8001C214(*(s32 *)((u8 *)arg0 + 0x20), 0);
+    *(s16 *)((u8 *)arg0 + 0x102) = -0x1AC;
+    *(s16 *)((u8 *)arg0 + 0xFE) = -0x1AC;
+    *(s16 *)((u8 *)arg0 + 0x104) = -0x1AC;
+    *(s16 *)((u8 *)arg0 + 0x100) = -0x1AC;
+    *(s32 *)((u8 *)arg0 + 0x1C) = 0x1F;
+    t = *(u16 *)(*(s32 *)((u8 *)arg0 + 0x64) + 2);
+    v0 = 0x775;
+    if (t != 9) {
+        v0 = 0x733;
+    }
+    func_8002D4C8(v0, 0);
+    *(u16 *)((u8 *)arg0 + 2) = *(u16 *)((u8 *)arg0 + 2) + 1;
+}
+
 
 #include "common.h"
 
@@ -6720,7 +6760,30 @@ void func_80188040(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_8018807C);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012B2CC(s32 a0);
+extern s32 rand(void);
+
+void func_8018807C(s32 a0) {
+    s32 obj;
+
+    obj = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(a0 + 0x20) = obj;
+    if (obj == 0) {
+        func_8012CAE4((void *)a0);
+        return;
+    }
+
+    func_8001C214(obj, 0);
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = *(u16 *)(a0 + 0xFC);
+    func_8012B2CC(a0);
+
+    *(u16 *)(a0 + 0xFE) = rand() % 32 + 0x20;
+    *(u16 *)(a0 + 0x2) = *(u16 *)(a0 + 0x2) + 1;
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c b/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
index 76c2e22e0..821f590df 100644
--- a/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
+++ b/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
@@ -3497,7 +3497,16 @@ s32 func_8017D608(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017D628);
+void func_8017D628(s32 param_1) {
+    s32 ret;
+
+    ret = func_800D0EC4();
+    func_800D0F0C(ret, *(s16 *)(param_1 + 0x70) + 0x62);
+    func_800291A0(0xDE, *(u8 *)(param_1 + 0x70));
+    *(s16 *)(param_1 + 0x70) = 0;
+    *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x80000000;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017D684);
 
diff --git a/src/ov_SC03_117/ov_SC03_117_jr_8017BEBC.c b/src/ov_SC03_117/ov_SC03_117_jr_8017BEBC.c
index 0a82b8509..92bad2117 100644
--- a/src/ov_SC03_117/ov_SC03_117_jr_8017BEBC.c
+++ b/src/ov_SC03_117/ov_SC03_117_jr_8017BEBC.c
@@ -5256,9 +5256,38 @@ void func_80180B88(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_jr_8017BEBC", func_80180BC4);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012AD50(s32);
+
+void func_80180BC4(void *a0)
+{
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+    func_8001C214(v0, 0);
+    func_8012AD50((s32)a0);
+}
+
+
+extern s32 func_80029178(s32 arg);
+extern void func_8012AD50(s32);
+extern u8 D_80188B4C[];
+
+void func_80180C18(void *a0) {
+    if ((func_80029178(0xBB) & 0xFF) != 0) {
+        *(s32 *)((s32)a0 + 0x58) = (s32)D_80188B4C;
+        *(s16 *)((s32)a0 + 0x5C) = 0x80;
+        func_8012AD50((s32)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_jr_8017BEBC", func_80180C18);
 
 void func_80180C68(void) {
 }
diff --git a/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c b/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c
index 48739dcd5..803022175 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c
@@ -4749,7 +4749,21 @@ void func_8017E380(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8017AE2C", func_8017E3BC);
+extern int func_800D0F8C(int a0);
+extern s32 func_800D0EC4(void);
+extern void func_800D0F0C(s32, s32);
+
+void func_8017E3BC(s32 a0)
+{
+    if (func_800D0F8C(a0 & 0xFF) == 0) {
+        s32 ret;
+        ret = func_800D0EC4();
+        if (ret != 0) {
+            func_800D0F0C(ret, a0);
+        }
+    }
+}
+
 
 extern void func_8012E8E0(s32 a0, s32 a1);
 extern void func_8012E88C(s32 a0);
@@ -5778,7 +5792,31 @@ void func_80180334(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8017AE2C", func_801803CC);
+extern u16 D_800B99DA;
+extern s32 func_801842F8(u8 a0, u8 a1, u8 a2, u8 a3);
+extern void func_8012E88C(s32 a0);
+extern void func_8012A828(s32, s32);
+extern void func_801843B8(s32 a0);
+extern void func_801845FC(s32, s32, s32, s32);
+extern short D_801BEA50;
+extern s16 D_801B9560;
+extern void func_8018004C(s32 a0);
+
+void func_801803CC(void *arg0)
+{
+    if (*(s16 *)((char *)arg0 + 0xFC) != 0) {
+        func_8018004C((s32)arg0);
+    }
+    if ((D_800B99DA & 3) == 0 && func_801842F8(9, 4, 0x12, 0) == 0) {
+        *(s16 *)((char *)arg0 + 2) = 6;
+        func_8012E88C((s32)arg0);
+        func_8012A828((s32)arg0, (s32)&D_801BEA50);
+        func_801843B8((s32)arg0);
+        *(s16 *)((char *)arg0 + 0x34) = 0;
+        func_801845FC((s32)arg0, (s32)&D_801B9560, 0, 0x60);
+    }
+}
+
 
 extern int func_80178970(void);
 extern void func_80178D18(void);
diff --git a/src/ov_SC04_000/ov_SC04_000_jr_8017BEBC.c b/src/ov_SC04_000/ov_SC04_000_jr_8017BEBC.c
index dbc704acf..6d095f275 100644
--- a/src/ov_SC04_000/ov_SC04_000_jr_8017BEBC.c
+++ b/src/ov_SC04_000/ov_SC04_000_jr_8017BEBC.c
@@ -5380,7 +5380,25 @@ INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_jr_8017BEBC", func_801806B
 void func_80180730(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_jr_8017BEBC", func_80180738);
+extern s32 func_80029504(void);
+extern void func_80178CBC(s32 *a0, s32 a1);
+extern s32 D_80199868;
+extern s32 D_80199830;
+
+void func_80180738(void *a0)
+{
+    s32 v0;
+
+    if ((u32)func_80029504() >= 0x302) {
+        func_80178CBC((s32 *)a0, &D_80199868);
+        v0 = 4;
+    } else {
+        func_80178CBC((s32 *)a0, &D_80199830);
+        v0 = 3;
+    }
+    *(s16 *)(a0 + 2) = v0;
+}
+
 
 
 extern int func_80178970(void);
diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c b/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
index 04255664c..82c133ceb 100644
--- a/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
+++ b/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
@@ -10140,7 +10140,59 @@ s32 func_80186544(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80186638);
+extern s32  func_8012BC60(void *a0, void *a1);
+extern s32  func_8012B6D4(s16 *a0, s16 *a1);
+extern void func_8012B0B4(unsigned int *param_1, int param_2, int param_3);
+extern s32  func_8012CEB0(void *a0, void *a1, s32 a2);
+extern void func_8012ADE4(u8 *a0);
+
+void func_80186638(s32 a0) {
+    extern u8 D_801202A0[];
+    u8 *p;
+    s16 *self4;
+    unsigned int *sc;
+    s32 i;
+    s32 ang;
+    s16 v10[4];
+    s16 v18[4];
+    s32 sp20[2];
+
+    i = 0;
+    p = D_801202A0;
+    self4 = (s16 *)(a0 + 4);
+    sc = (unsigned int *)sp20;
+    do {
+        switch (*(u16 *)p) {
+        case 0x1DC:
+            if ((u8 *)a0 != p) {
+                if (func_8012BC60((void *)self4, (void *)(p + 4)) < 0x900) {
+                    ang = func_8012B6D4(self4, (s16 *)(p + 4));
+                    func_8012B0B4(sc, ang, 0x31);
+                    v18[0] = *(u16 *)(p + 6);
+                    v18[1] = *(u16 *)(p + 0xA);
+                    v18[2] = *(u16 *)(p + 0xE);
+                    v18[0] += sp20[0];
+                    v18[2] += sp20[0] >> 16;
+                    v10[0] = *(u16 *)(a0 + 0x3A);
+                    v10[1] = *(u16 *)(a0 + 0x3E);
+                    v10[2] = *(u16 *)(a0 + 0x42);
+                    if (func_8012CEB0(v10, v18, 0) & 0x2000) {
+                        *(u16 *)(a0 + 6) = v18[0];
+                        *(u16 *)(a0 + 0xA) = v18[1];
+                        *(u16 *)(a0 + 0xE) = v18[2];
+                        return;
+                    }
+                    func_8012ADE4((u8 *)a0);
+                    return;
+                }
+            }
+            break;
+        }
+        i++;
+        p += 0x10C;
+    } while (i < 0x60);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
index 656fdf9a2..fd9cf69ec 100644
--- a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
+++ b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
@@ -9475,7 +9475,58 @@ s32 func_80185914(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80185A08);
+#include "common.h"
+
+extern u8   D_801202A0[];
+
+extern s32  func_8012BC60(struct Vec *a0, struct Vec *a1);
+extern s32  func_8012B6D4(s16 *a0, s16 *a1);
+extern void func_8012B0B4(unsigned int *param_1, int param_2, int param_3);
+extern s32  func_8012CEB0(s32 a0, s32 a1, s32 a2);
+extern void func_8012ADE4(u8 *a0);
+
+s32 func_80185A08(s32 a0) {
+    u8 *p;
+    s16 *self4;
+    unsigned int *sc;
+    s32 i;
+    s32 ang;
+    s16 v10[4];  /* sp+0x10 */
+    s16 v18[4];  /* sp+0x18 */
+    s32 sp20[2]; /* sp+0x20 — func_8012B0B4 output */
+
+    i = 0;
+    p = D_801202A0;
+    self4 = (s16 *)(a0 + 4);
+    sc = (unsigned int *)sp20;
+    do {
+        if (*(u16 *)p == 0x1DC && (u8 *)a0 != p) {
+            if (func_8012BC60((struct Vec *)self4, (struct Vec *)(p + 4)) < 0x900) {
+                ang = func_8012B6D4(self4, (s16 *)(p + 4));
+                func_8012B0B4(sc, ang, 0x31);
+                v18[0] = *(u16 *)(p + 6);
+                v18[1] = *(u16 *)(p + 0xA);
+                v18[2] = *(u16 *)(p + 0xE);
+                v18[0] += sp20[0];
+                v18[2] += sp20[0] >> 16;
+                v10[0] = *(u16 *)(a0 + 0x3A);
+                v10[1] = *(u16 *)(a0 + 0x3E);
+                v10[2] = *(u16 *)(a0 + 0x42);
+                if (func_8012CEB0((s32)v10, (s32)v18, 0) & 0x2000) {
+                    *(u16 *)(a0 + 6) = v18[0];
+                    *(u16 *)(a0 + 0xA) = v18[1];
+                    *(u16 *)(a0 + 0xE) = v18[2];
+                    return;
+                }
+                func_8012ADE4((u8 *)a0);
+                return;
+            }
+        }
+        i++;
+        p += 0x10C;
+    } while (i < 0x60);
+}
+
 
 extern s32 func_80132EF4(s32 a0, s32 a1);
 typedef struct { short a, b, c; } SV3_80181D44_80185B70;   /* == the TU's own `SV3` (engine_types.h:612); renamed only because
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
index e0abf6dff..ab71e3e16 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
@@ -4595,7 +4595,18 @@ s32 func_801809D4(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801809E0);
+extern void func_8018FC58(void *a0);
+
+void func_801809E0(s32 arg0) {
+    s32 s0;
+
+    s0 = arg0;
+    func_8017FF80();
+    func_8018FC58((void *)3);
+    *(s32 *)(s0 + 0x1C) = 0xC0;
+    *(s16 *)(s0 + 0x84) = 0x28;
+}
+
 
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern void func_8012BEE8(u8*);
@@ -5444,7 +5455,22 @@ L80182380:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801823C0);
+#include "common.h"
+
+void func_801823C0(void *a0)
+{
+    extern void func_8018637C(s32 arg0, s32 arg1);
+    extern void func_80186BF8(void);
+    extern void func_8012AD44(s32 *a0, s16 a1);
+    extern struct { s32 f0; s32 f1; s32 f2; } D_801944EC[];
+
+    register s32 s0 __asm__("$16") = (s32)a0;
+
+    func_8018637C((s32)a0, D_801944EC[*(s16 *)(s0 + 0xE2)].f0);
+    func_80186BF8();
+    func_8012AD44((s32 *)s0, 0xB);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80182420);
 
@@ -5492,7 +5518,20 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801827D
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80182AF8);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80182B5C);
+void func_80182B5C(void *arg0) {
+    extern u8 D_80194538[];
+    extern void func_8018332C(s32 a0, s32 a1);
+    extern void func_80186908();
+    extern u16 D_801EFD40;
+    extern void func_8012AD44(s32 *a0, s16 a1);
+
+    *(s16 *)((s32)arg0 + 0xF4) = 0;
+    func_8018332C((s32)arg0, (s32)&D_80194538);
+    func_80186908();
+    D_801EFD40 |= 0x20;
+    func_8012AD44((s32 *)arg0, 0xE);
+}
+
 
 #include "common.h"
 
@@ -10452,7 +10491,24 @@ void func_80189FDC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018A018);
+#include "common.h"
+
+extern void func_8018A074(s32 arg0);
+extern void func_8001C924(void *a0, void *a1);
+extern void func_8018A42C(void *a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801E30C4;
+extern u8 D_801E5870[];
+
+void func_8018A018(s32 arg0)
+{
+    func_8018A074((s32)arg0);
+    func_8001C924(*(void **)((s32)arg0 + 0x20), (void *)&D_801E30C4);
+    func_8018A42C((void *)arg0, (void *)D_801E5870);
+    *(s32 *)((s32)arg0 + 0x58) = 0;
+    func_8002D4C8(0x84C, 0);
+}
+
 
 extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
 extern void func_8018A0E0(s32 arg0);
diff --git a/src/ov_SC04_020/ov_SC04_020_jr_8017D604.c b/src/ov_SC04_020/ov_SC04_020_jr_8017D604.c
index 599384c5e..5e537d30f 100644
--- a/src/ov_SC04_020/ov_SC04_020_jr_8017D604.c
+++ b/src/ov_SC04_020/ov_SC04_020_jr_8017D604.c
@@ -3496,7 +3496,17 @@ void func_8017F030(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_020/nonmatchings/ov_SC04_020_jr_8017D604", func_8017F068);
+extern s32 func_801813AC(u8 a0, u8 a1, u8 a2, u8 a3);
+
+void func_8017F068(s32 obj) {
+    *(s32 *)(*(s32 *)(obj + 0xCC) + 0xB0) = 2;
+    if (func_801813AC(5, 0, 5, 0x1E) != 0) {
+        func_8017EDF4((void *)obj);
+    } else if (func_80181388(7, 0x15) != 0) {
+        func_8017EDB0(obj);
+    }
+}
+
 
 extern void func_80178CBC(s32 arg0, s32 arg1);
 extern int func_80178970(void);
diff --git a/src/ov_SC05_000/ov_SC05_000_jr_8017BEBC.c b/src/ov_SC05_000/ov_SC05_000_jr_8017BEBC.c
index 95f2316c7..52fb8e9d7 100644
--- a/src/ov_SC05_000/ov_SC05_000_jr_8017BEBC.c
+++ b/src/ov_SC05_000/ov_SC05_000_jr_8017BEBC.c
@@ -3615,7 +3615,21 @@ void func_8017D828(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_000/nonmatchings/ov_SC05_000_jr_8017BEBC", func_8017D864);
+void func_8017D864(s32 param_1) {
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+    extern void (*D_80181E28[])(void);
+    extern s32 D_80198064;
+    s32 v0;
+
+    v0 = func_8012C354(param_1, (s32)D_80181E28);
+    if (v0 != 0) {
+        func_8001D0E8(*(s32 *)(param_1 + 0x20), 0x7FFF, 0x7FFF);
+        *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = D_80198064;
+        *(u16 *)(param_1 + 0x2) = *(u16 *)(param_1 + 0x2) + 1;
+    }
+}
+
 
 void func_8017D8CC(void) {
 }
diff --git a/src/ov_SC05_001/ov_SC05_001_jr_8017BEBC.c b/src/ov_SC05_001/ov_SC05_001_jr_8017BEBC.c
index 3e009b335..c92beac57 100644
--- a/src/ov_SC05_001/ov_SC05_001_jr_8017BEBC.c
+++ b/src/ov_SC05_001/ov_SC05_001_jr_8017BEBC.c
@@ -5333,7 +5333,32 @@ void func_80180260(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_jr_8017BEBC", func_8018029C);
+#include "common.h"
+
+/* Callee spellings copied VERBATIM from this TU (law 2):
+ *   func_80178B18 @2535/@4800, func_8016F2A8 @1946, func_8016F2EC @1948,
+ *   func_8002D4C8 @59/@4802, func_8012AD44 @5060/@5182.
+ * D_80189B10 is only address-taken (2nd arg of func_80178B18); spelled as a
+ * dispatcher table to match the adjacent D_80189AF8 (@5329) / D_80189B18 (@5359)
+ * declarations in this same TU. */
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void func_8016F2A8(void);
+extern void func_8016F2EC(void);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+extern void (*D_80189B10[])(void);
+
+void func_8018029C(s32 param_1) {
+    func_80178B18(param_1, (s32)D_80189B10);
+    func_8016F2A8();
+    func_8016F2EC();
+    *(u16 *)(param_1 + 0xFE) = 0x14;
+    *(s32 *)(param_1 + 0x1C) = 4;
+    func_8002D4C8(0x8FE, 0);
+    func_8012AD44((s32 *)param_1, 2);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_jr_8017BEBC", func_80180304);
 
diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c b/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c
index 6753ebaa5..211e452db 100644
--- a/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c
+++ b/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c
@@ -3457,7 +3457,19 @@ void func_8017D490(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D52C);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+
+void func_8017D52C(s32 a0)
+{
+    extern s16 D_80126B62;
+
+    if (func_80178970() != 0 || D_80126B62 >= -447) {
+        ((void (*)(s32))func_80178D18)(a0);
+        *(u16 *)(a0 + 2) -= 1;
+    }
+}
+
 
 void func_8017D58C(void) {
 }
diff --git a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
index a93c0d506..9719dd30f 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
@@ -3826,7 +3826,19 @@ void func_80185288(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_801852C4);
+void func_801852C4(s32 arg0)
+{
+    extern void func_80187B80(s32 a0);
+    extern void func_8017E910(void);
+    void *s0;
+
+    func_80187B80(4);
+    s0 = (void *)(arg0 + 0x76);
+    func_8017BF08(s0, s0, 5, 0xD2);
+    func_8017E910();
+    func_8002D4C8(0x89E, 0);
+}
+
 
 extern void func_80187BAC(void);
 extern void func_8017E9B4(void);
@@ -4105,7 +4117,22 @@ INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80185B2
 
 INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80185BD8);
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80185C80);
+void func_80185C80(s32 a0) {
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_8019273C[];
+    extern void (*D_80188CCC)(void);
+
+    if (func_8012C354(a0, (s32)D_8019273C) != 0) {
+        *(u32 *)(*(s32 *)(a0 + 0x20) + 4) = *(u32 *)(*(s32 *)(a0 + 0x20) + 4) | 0x80000000;
+        *(s16 *)(a0 + 2) = 1;
+        func_8012A828(a0, &D_80188CCC);
+        *(u8 *)(a0 + 0x75) = 3;
+        *(u8 *)(a0 + 0xC0) = 1;
+        *(s16 *)(a0 + 0xAE) = -1;
+    }
+}
+
 
 void func_80185CF8(void) {
 }
@@ -4768,7 +4795,22 @@ void func_801872BC(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_8018738C);
+void func_8018738C(s32 a0) {
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern void (*D_80188CCC)(void);
+    extern void (*D_80192E00)(void);
+
+    if (func_8012C354(a0, (s32)&D_80192E00) != 0) {
+        *(s32 *)(*(s32 *)(a0 + 0x20) + 4) = *(s32 *)(*(s32 *)(a0 + 0x20) + 4) | 0x40000040;
+        *(u8 *)(a0 + 0xC0) = 1;
+        *(u16 *)(a0 + 0x5C) = 0;
+        func_8012A828(a0, &D_80188CCC);
+        *(u16 *)(a0 + 2) = 1;
+        *(s32 *)(a0 + 0x1C) = 6;
+    }
+}
+
 
 
 extern void func_8012C218(void*);
@@ -4782,7 +4824,24 @@ extern void func_8012C218(void*);
 
 INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80187438);
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_801874DC);
+extern void func_8012C218(void*);
+extern void func_8017ECE4(void);
+extern s32 D_801C7E64;
+
+void func_801874DC(void *param_1) {
+    s32 v;
+
+    v = *(s32 *)((u8 *)param_1 + 0x1C) - 1;
+    *(s32 *)((u8 *)param_1 + 0x1C) = v;
+    if (v == 0) {
+        ((void (*)(void))func_8012C218)();
+        D_801C7E64 = 0;
+    }
+    *(u16 *)((u8 *)param_1 + 0xA) = 0;
+    ((void (*)(s32))func_8017ECE4)((s32)param_1);
+    *(u16 *)((u8 *)param_1 + 0xA) -= 0x20;
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c b/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c
index 338c9c9d0..3af9caf31 100644
--- a/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c
+++ b/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c
@@ -5127,7 +5127,13 @@ void func_8017ED1C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_jr_8017AE2C", func_8017ED58);
+void func_8017ED58(void *a0) {
+    extern s32 D_801911C0;
+    *(short *)((char *)a0 + 0x2) = 5;
+    func_80178CBC((s32)a0, (s32)&D_801911C0);
+    *(short *)((char *)a0 + 0x34) = 0;
+}
+
 
 
 extern s16 func_80184B44(void);
@@ -5172,7 +5178,19 @@ void func_8017EEC8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_jr_8017AE2C", func_8017EF20);
+extern s32 func_801858E0(s32 a0);
+extern s32 func_80184CA4(s32 a0);
+extern void func_80185C54(void*, s32, s32);
+
+void func_8017EF20(void *a0) {
+    func_80185C54(a0, 0xC, 1);
+    if (func_801858E0(0xC) != 0) {
+        if (func_80184CA4((s32)a0) != 0) {
+            func_8017E85C(a0);
+        }
+    }
+}
+
 
 extern void func_80184BD4(s32, s32, s32, s32);
 extern s32 func_801848AC(s32 arg0, s32 arg1);
@@ -6095,7 +6113,32 @@ extern void func_801849B8(s32*, s32);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_jr_8017AE2C", func_801801B4);
+extern s16 func_80184B44(void);
+extern void func_801849B8(s32 *a0, s32 a1);
+extern void func_8012E88C(s32);
+extern void func_8012A828(s32, s32);
+extern void func_80184990(s32);
+
+void func_801801B4(void *arg0) {
+
+    extern short D_8019142C;
+    extern short D_801B9964;
+    extern s32 D_801CE1C0;
+    extern s32 D_801ECE70;
+
+    if (((s32 (*)(void))func_80184B44)() == 1) {
+        *(short *)((char *)arg0 + 0x2) = 1;
+        func_801849B8((s32 *)arg0, (s32)&D_8019142C);
+    } else {
+        *(short *)((char *)arg0 + 0x2) = 8;
+        func_8012E88C((s32)arg0);
+        func_8012A828((s32)arg0, (s32)&D_801B9964);
+        func_80184990((s32)arg0);
+        D_801CE1C0 = D_801ECE70;
+        *(short *)((char *)arg0 + 0x34) = 0;
+    }
+}
+
 
 
 extern void func_801849B8(s32*, s32);
diff --git a/src/ov_SC05_017/ov_SC05_017_jr_80186270.c b/src/ov_SC05_017/ov_SC05_017_jr_80186270.c
index e3ba33f3a..42d9409cb 100644
--- a/src/ov_SC05_017/ov_SC05_017_jr_80186270.c
+++ b/src/ov_SC05_017/ov_SC05_017_jr_80186270.c
@@ -3590,6 +3590,69 @@ void func_80186B24(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_jr_80186270", func_801874B0);
+void func_801874B0(void) {
+
+    extern s32 D_801151D0;
+    extern s32 D_801151C8[];
+    extern u16 xf02 __asm__("D_800B9A02");
+    extern s16 xa __asm__("D_8011511A");
+    extern u16 xb __asm__("D_8011511A");
+    extern s32 xf168c(s32 a0) __asm__("func_8014168C");
+    extern u8  D_80115138[];
+    extern s32 D_801ED560;
+    extern s32 D_80115130;
+    extern s32 D_801B93CC[];
+    extern s32 D_801ED564;
+    extern u8  D_800B9A15;
+    extern u16 D_80115112;
+    extern s16 D_801ECE90;
+
+    extern s32 func_80188128(void);
+    extern void func_80188478(void);
+    extern s32 func_80188B1C(s32 a0, s32 a1);
+    extern void func_80139954(void);
+    extern s32 func_801376E8(s32 a0, s32 a1);
+    extern void func_80137B80(void);
+
+    s32 pad[2];
+    s32 v;
+    s32 r2;
+    s32 ret;
+    s16 rn;
+    s32 b;
+    s32 *p30;
+    u16 *p12;
+
+    D_801151D0 = ((s32 *)D_801151C8)[xf02];
+    ret = func_80188128();
+    func_80188478();
+    r2 = xf168c(xa);
+    b = D_80115138[xb];
+    if (D_801ED560 == 0) {
+        v = func_80188B1C(b, (s16)r2);
+    } else {
+        v = D_801ED560;
+    }
+    if (v != 0) {
+        p30 = &D_80115130;
+        if (v != *p30) {
+            *p30 = v;
+            func_80139954();
+            D_801ED564 = func_801376E8(v, (s32)D_801B93CC);
+        }
+    }
+    func_80137B80();
+    rn = ret;
+    if (rn < 0) {
+        func_80139954();
+        D_800B9A15 = 0;
+        if (D_801ECE90 == 0) {
+            func_8002D4C8(0x474, 0);
+        }
+        p12 = &D_80115112;
+        *p12 += 2;
+    }
+}
+
 
 
diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
index 809fcc854..c4dc7c059 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
@@ -3434,7 +3434,29 @@ void func_8017EBFC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EC80);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8017FE44(void);
+extern s32 func_80171990(u8 *a0);
+extern s32 D_801151D4;
+
+void func_8017EC80(s32 a0) {
+    register s32 v0 __asm__("$2");
+    s32 v1;
+
+    v1 = D_801151D4;
+    v0 = *(u16 *)(v1 + 0x22) + 4;
+    *(u16 *)(v1 + 0x22) = v0;
+    *(s16 *)(v1 + 0x1A) = v0;
+
+    v0 = *(s32 *)((u8 *)a0 + 0x204) - 1;
+    *(s32 *)((u8 *)a0 + 0x204) = v0;
+    if (v0 == -1) {
+        func_8002D4C8(0xC4C, 0);
+        func_8017FE44();
+        func_80171990((u8 *)a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017ECEC);
 
@@ -3745,7 +3767,19 @@ void func_8017F598(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F608);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017F608(void *arg0) {
+    s16 var;
+
+    var = *(s16 *)((u8 *)arg0 + 0x20E) - 1;
+    *(s16 *)((u8 *)arg0 + 0x20E) = var;
+    if (var == -1) {
+        *(s16 *)((u8 *)arg0 + 0x20E) = 0;
+        func_80171990((u8 *)arg0);
+    }
+}
+
 
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern s32 func_80171990(u8 *a0);
@@ -3791,7 +3825,22 @@ void func_8017F6C8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F754);
+extern s32 func_80171990(u8*);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F990();
+
+void func_8017F754(void *a0) {
+    s32 v0;
+
+    v0 = *(s32 *)((u8 *)a0 + 0x200) - 0xA;
+    *(s32 *)((u8 *)a0 + 0x200) = v0;
+    if (v0 < 0x6F) {
+        ((void (*)(void *))func_80171990)(a0);
+    }
+    func_8017F818(a0, *(s16 *)((u8 *)a0 + 0x20C), *(s32 *)((u8 *)a0 + 0x200), 0);
+    func_8017F990(a0, 0x800);
+}
+
 
 extern u8 D_800AE6BD;
 extern void func_80171928(void *);
diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8017DB90.c b/src/ov_SC06_006/ov_SC06_006_jr_8017DB90.c
index 997a774ac..286b39565 100644
--- a/src/ov_SC06_006/ov_SC06_006_jr_8017DB90.c
+++ b/src/ov_SC06_006/ov_SC06_006_jr_8017DB90.c
@@ -4362,7 +4362,22 @@ extern s32 func_8018034C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017DB90", func_801807EC);
+extern s32 func_8018034C(void);
+extern void func_8017F2A0(void);
+extern s32 D_801F8084;
+extern void func_8017F308(void);
+extern void func_8017FECC(s32 a0);
+
+void func_801807EC(void) {
+    if (func_8018034C() != 0) {
+        func_8017F2A0();
+    }
+    if (D_801F8084 == 0xC8) {
+        func_8017F308();
+    }
+    func_8017FECC(4);
+}
+
 
 extern s32 func_8018034C(void);
 extern s32 D_801F8084;
diff --git a/src/ov_SC06_008/ov_SC06_008_jr_8017C294.c b/src/ov_SC06_008/ov_SC06_008_jr_8017C294.c
index 0a70c3a4a..13fe47451 100644
--- a/src/ov_SC06_008/ov_SC06_008_jr_8017C294.c
+++ b/src/ov_SC06_008/ov_SC06_008_jr_8017C294.c
@@ -3958,7 +3958,16 @@ void func_8017E62C(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_008/nonmatchings/ov_SC06_008_jr_8017C294", func_8017E694);
+void func_8017E694(s32 a0) {
+    extern void func_801292C8();
+    if (*(s32 *)(a0 + 0x1c) == 0) {
+        func_801292C8(a0);
+    } else {
+        func_8017E6F0(a0);
+        *(s32 *)(a0 + 0x1c) -= 1;
+    }
+}
+
 
 
 
diff --git a/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.c b/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.c
index 4b5a22527..ddf362704 100644
--- a/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.c
+++ b/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.c
@@ -3957,7 +3957,20 @@ void func_8017E0FC(s32 a0) {
 void func_8017E174(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC06_011/nonmatchings/ov_SC06_011_jr_8017BEBC", func_8017E17C);
+void func_8017E17C(s32 param_1)
+{
+    extern void func_8002D4C8(s32 a0, s32 a1);
+    s32 v;
+
+    v = *(u16 *)(param_1 + 0xA) + 0x10;
+    *(u16 *)(param_1 + 0xA) = v;
+    if ((s16)v >= -0x1C0) {
+        *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) - 1;
+        func_8002D4C8(4, 0xA66);
+        func_8002D4C8(0xA67, 0);
+    }
+}
+
 
 void func_8017E1DC(s32 a0) {
     extern s32 func_8012C354(s32 a0, s32 a1);
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
index 04247063c..ec2e95245 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
@@ -3622,7 +3622,23 @@ void func_8017E4AC(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E4FC);
+#include "common.h"
+
+extern void func_8017EEFC(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u8 D_80195E24;
+extern s16 D_8019F708;
+extern s16 D_8019F710;
+extern u16 D_80188A1A;
+
+void func_8017E4FC(s32 arg0)
+{
+    func_8017EEFC(arg0, 7, 0, &D_80195E24);
+    D_8019F708 = 0;
+    D_8019F710 = D_80188A1A;
+    func_8002D4C8(0xA97, 0);
+}
+
 
 #include "common.h"
 
@@ -5574,7 +5590,16 @@ void func_80181D7C(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181DBC);
+extern s16 D_8019F710;
+extern void func_8017E7D0(void);
+
+void func_80181DBC(void) {
+    D_8019F710 = D_8019F710 - 1;
+    if (D_8019F710 <= 0) {
+        func_8017E7D0();
+    }
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern s32 func_8012BEE8(s32 a0);
diff --git a/src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c b/src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c
index 7589fdc7f..4b964b317 100644
--- a/src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c
+++ b/src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c
@@ -8808,7 +8808,17 @@ void func_801857CC(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_jr_8017C24C", func_80185944);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801CC6E8[];
+
+void func_80185944(s32 p) {
+    *(u16 *)(p + 2) = 0x20;
+    func_8012A828(p, D_801CC6E8);
+    *(s32 *)(p + 0x1C) = 0;
+    *(s32 *)(p + 0xE4) = 0;
+    *(s32 *)(p + 0x48) = 0x4650;
+}
+
 
 // @class: regalloc-order
 // @stuck: none — MATCH (168/168). $s4/$s5 pins for base+&local28; s32 sVar1 for single lh;
diff --git a/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c b/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
index 8e13f987b..55baf69e0 100644
--- a/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
+++ b/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
@@ -8309,4 +8309,64 @@ void func_8018F694(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_jr_80187AEC", func_8018FE0C);
+typedef struct { s32 a; s32 b[4]; } OtBlk_8018FE0C;
+
+/* ==== simulated TU file-scope surface (verbatim from ov_SC06_018_jr_80187AEC.c) ==== */
+extern short D_800B9A02;
+extern s16 D_800B9A02;
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void func_8004914C(void *);
+extern void func_800491AC(void *);
+extern void func_8004914C();
+extern void func_800491AC();
+extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3);
+extern u8 D_800A651C[];
+
+void func_8018FE0C(s32 arg0, s32 arg1, s32 arg2)
+{
+    extern void *func_80010A08(s32);
+    extern void func_8004914C(void *);
+    extern void func_800491AC(void *);
+    extern s32 RotTransPers(s32, s32, s32 *, s32 *);
+    extern u8 D_800AF648;
+    extern OtBlk_8018FE0C aD800A651C[] __asm__("D_800A651C");
+    extern u8 D_800A6518[];
+    extern short D_800B9A02;
+    extern void func_80016638(void *a0, s32 a1, s32 a2);
+
+    s32 sp10;
+    s32 sp14;
+    s32 temp_v0_2;
+    void *temp_v0;
+    s32 ot;
+    s32 depth4;
+    register u16 *bidx __asm__("$8");
+    register u32 mask1 __asm__("$7");
+    register s32 rgb __asm__("$16");
+    register u32 tag0 __asm__("$4");
+
+    rgb = arg2;
+    __asm__("" : "=r"(rgb) : "0"(rgb));
+    temp_v0 = func_80010A08(0x10);
+    *(u8 *)((u8 *)temp_v0 + 3) = 3;
+    *(s32 *)((u8 *)temp_v0 + 4) = rgb;
+    *(u8 *)((u8 *)temp_v0 + 7) = 0x42;
+    func_8004914C(&D_800AF648);
+    func_800491AC(&D_800AF648);
+    temp_v0_2 = RotTransPers(arg0, temp_v0 + 8, &sp10, &sp14);
+    if ((temp_v0_2 > 0) && (sp14 >= 0) &&
+        (RotTransPers(arg1, temp_v0 + 0xC, &sp10, &sp14) > 0) && (sp14 >= 0)) {
+        mask1 = 0xFFFFFF;
+        bidx = (u16 *)&D_800B9A02;
+        depth4 = temp_v0_2 * 4;
+        tag0 = *(u32 *)temp_v0;
+        *(u32 *)temp_v0 = (tag0 & 0xFF000000) |
+            (*(u32 *)(depth4 + aD800A651C[*bidx].a) & mask1);
+        ot = aD800A651C[*bidx].a;
+        *(u32 *)(depth4 + ot) =
+            (*(u32 *)(depth4 + ot) & 0xFF000000) | ((u32)temp_v0 & mask1);
+        func_80016638(&D_800A6518[*bidx * 20], temp_v0_2, 1);
+    }
+}
+
diff --git a/src/ov_SC06_020/ov_SC06_020_jr_8017C24C.c b/src/ov_SC06_020/ov_SC06_020_jr_8017C24C.c
index 16adad559..05bbdc386 100644
--- a/src/ov_SC06_020/ov_SC06_020_jr_8017C24C.c
+++ b/src/ov_SC06_020/ov_SC06_020_jr_8017C24C.c
@@ -4680,7 +4680,15 @@ void func_8017F490(s32 p) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_020/nonmatchings/ov_SC06_020_jr_8017C24C", func_8017F570);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801B5B88[];
+
+void func_8017F570(s32 param_1) {
+    *(s16 *)(param_1 + 2) = 27;
+    func_8012A828(param_1, D_801B5B88);
+    *(s32 *)(param_1 + 0x1C) = 0x20;
+}
+
 
 extern s32  func_801833F4(void *a0, s32 a1, s32 a2);
 extern s32 func_8012BCCC(s32 a0);
diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
index 4478754b9..5a1036209 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
@@ -4775,7 +4775,26 @@ void func_80183138(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_80183228);
+extern void func_8012BE54(s32 a0);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801892CC;
+
+void func_80183228(void *a0) {
+    u16 *v0;
+
+    v0 = *(u16 **)((s32)a0 + 0x20);
+    *(u16 *)((s32)v0 + 0x1C) = 0xC00;
+    *(u16 *)((s32)v0 + 0x1A) = 0xC00;
+    *(u16 *)((s32)v0 + 0x18) = 0xC00;
+    if (((s32 (*)(s32))func_8012BE54)(a0) < 0x6401) {
+        func_80178B18((s32)a0, (s32)&D_801892CC);
+        *(u16 *)((s32)a0 + 0x2) = 2;
+        *(u16 *)((s32)a0 + 0x34) = 0;
+        func_8002D4C8(0xB01, 0);
+    }
+}
+
 
 void func_80183298(void *a0)
 {
diff --git a/src/ov_SC06_027/ov_SC06_027_jr_8017BEBC.c b/src/ov_SC06_027/ov_SC06_027_jr_8017BEBC.c
index 4391af5b9..53c6b64b5 100644
--- a/src/ov_SC06_027/ov_SC06_027_jr_8017BEBC.c
+++ b/src/ov_SC06_027/ov_SC06_027_jr_8017BEBC.c
@@ -3604,7 +3604,18 @@ void func_8017D8B8(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_027_jr_8017BEBC", func_8017D92C);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_8019D2B8;
+extern s32 D_80199B1C;
+
+void func_8017D92C(s32 param_1)
+{
+    if (D_8019D2B8 == 1) {
+        D_8019D2B8 = 0;
+        func_8012A828(param_1, &D_80199B1C);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_027_jr_8017BEBC", func_8017D96C);
 
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_801836FC.c b/src/ov_SC06_033/ov_SC06_033_jr_801836FC.c
index e9d853730..81f7bc00b 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_801836FC.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_801836FC.c
@@ -3183,7 +3183,15 @@ void func_80183DA8(s32 p) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_801836FC", func_80183E88);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801C6B7C[];
+
+void func_80183E88(s32 param_1) {
+    *(s16 *)(param_1 + 2) = 0x1B;
+    func_8012A828(param_1, D_801C6B7C);
+    *(s32 *)(param_1 + 0x1C) = 0x20;
+}
+
 
 extern void func_8012F214(s32, s32, s32);
 extern s32  func_8012BCCC(s32 a0);
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
index 92b47c01a..c46f0a005 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -5867,7 +5867,22 @@ void func_80182E48(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80182F2C);
+void func_80182F2C(void *a0)
+{
+    extern u16 D_8019FF8A;
+    s32 q;
+    u16 g;
+
+    func_80182818(a0);
+    q = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)(q + 0x12) = *(u16 *)(q + 0x12) + 0x80;
+    g = D_8019FF8A;
+    *(u16 *)((s32)a0 + 0xE4) = *(u16 *)((s32)a0 + 0xE4) + *(u16 *)((s32)a0 + 0xE8);
+    if (g & 0x4000) {
+        func_8018260C((s32)a0);
+    }
+}
+
 
 void func_80182F94(s32 arg0) {
     register s32 s0 __asm__("$16") = arg0;
diff --git a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c
index d022260f5..862f3af08 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c
@@ -4801,7 +4801,48 @@ void func_801828A4(s32 t)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182B8C);
+extern s32 D_801BFCEC;
+extern u8 D_8018E510[];
+extern u8 D_8018DF10;
+extern void func_8017D8A4(s32 a0, void *a1, void *a2, s32 a3, s32 a4);
+extern void func_80143C74(s32 a0, s32 a1);
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern s32 rand(void);
+
+void func_80182B8C(s32 param_1, s32 param_2) {
+    s32 *q;
+    s32 work;
+    s32 rnd;
+    s32 t;
+    s32 u;
+
+    q = &D_801BFCEC;
+    func_8017D8A4(*q + 0x48, D_8018E510, D_8018E510 + 0x24, param_2, 1);
+    func_8017D8A4(*q + 0x54, D_8018E510 + 0xC, D_8018E510 + 0x30, param_2, 1);
+    func_8017D8A4(*q + 0x60, D_8018E510 + 0x18, D_8018E510 + 0x3C, param_2, 1);
+    work = ((s32 (*)())func_80143C74)(param_1, 0);
+    if (work != 0) {
+        *(u16 *)(work + 0xE) = *(u16 *)(work + 0xE) - *(u16 *)(D_801BFCEC + 0x48);
+        rnd = rand();
+        t = *(u16 *)(D_801BFCEC + 0x4A) - 0x20;
+        *(u16 *)(work + 0xA) = *(u16 *)(work + 0xA) + (t + (rnd & 0x3F));
+        rnd = rand();
+        u = *(u16 *)(D_801BFCEC + 0x4C) - 0x20;
+        *(u16 *)(work + 6) = *(u16 *)(work + 6) + (u + (rnd & 0x3F));
+        rnd = rand() & 0xFF;
+        *(u32 *)(work + 0x10) = (rnd - 0x80) << 10;
+        rnd = rand() & 3;
+        *(u16 *)(work + 0x16) = -(rnd + 4);
+        *(u32 *)(work + 0x18) = (rand() & 0xFF) << 11;
+        func_80128EA8(*(u32 *)(work + 0x20), (void *)(work + 0xD0), &D_8018DF10);
+        func_8012C658(0x3AC, 6, work);
+        func_8012C658(0x3AC, 6, work);
+        func_8012C658(0x3AC, 6, work);
+        func_8012C658(0x3AC, 6, work);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182D4C);
 
diff --git a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
index b09f4b472..693fd4985 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
@@ -4462,7 +4462,23 @@ s32 func_8017E4B0(void * arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E4C4);
+extern s32 D_801151D4;
+
+void func_8017E4C4(s32 a0) {
+    s32 p;
+    s32 t;
+
+    p = D_801151D4;
+    t = *(s32 *)(p + 0x10) - 2;
+    *(s32 *)(p + 0x10) = t;
+    *(s32 *)(p + 0x14) = t;
+    if (*(s32 *)(p + 0x10) < 300) {
+        *(s32 *)(p + 0x10) = 300;
+        *(s32 *)(p + 0x14) = 300;
+        func_80016714((void *)a0, 0x18);
+    }
+}
+
 
 extern s32 D_801151D4;
 
@@ -7062,7 +7078,19 @@ void func_801817D0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181828);
+void func_80181828(s32 a0) {
+    extern s32 func_8012BEE8(s32 a0);
+    extern s32 func_8012AD50(void *a0);
+    extern void func_80181960();
+    register s32 s0 __asm__("$16");
+
+    if (func_8012BEE8(a0) != 0) {
+        *(u16 *)(a0 + 0xFC) = 0;
+        func_8012AD50((void *)a0);
+    }
+    func_80181960((void *)0xFFFFFF, 2, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181878);
 
diff --git a/src/ov_SC07_009/ov_SC07_009_jr_8017AE2C.c b/src/ov_SC07_009/ov_SC07_009_jr_8017AE2C.c
index e4885da54..bd3f499c1 100644
--- a/src/ov_SC07_009/ov_SC07_009_jr_8017AE2C.c
+++ b/src/ov_SC07_009/ov_SC07_009_jr_8017AE2C.c
@@ -3901,7 +3901,24 @@ INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_jr_8017AE2C", func_8017D06
 void func_8017D0CC(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_jr_8017AE2C", func_8017D0D4);
+extern s16 D_800B9ABA[];
+extern s16 D_801274EA;
+extern s16 D_801274F2;
+
+void func_8017D0D4(s32 a0)
+{
+    s16 *p;
+
+    if (func_80171A88(a0) != 0) {
+        func_80171928((void *)a0);
+        return;
+    }
+    p = &D_801274EA;
+    (*p) += 4;
+    D_801274F2 += 8;
+    D_800B9ABA[0] += 2;
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017D150(void) {
@@ -4300,7 +4317,17 @@ s32 func_8017D994(s32 *arg0) {
 
 INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_jr_8017AE2C", func_8017DA0C);
 
-INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_jr_8017AE2C", func_8017DA7C);
+void func_8017DA7C(s32 *arg0) {
+    extern void func_800178C8(void *a0);
+
+    *(s16 *)((u8 *)arg0 + 4) = 4;
+    *(s32 *)((u8 *)arg0 + 0x40) = 0x60000000;
+    func_800178C8(arg0);
+    *(s16 *)((u8 *)arg0 + 4) = 3;
+    *(s32 *)((u8 *)arg0 + 0x40) = 0x50000000;
+    func_800178C8(arg0);
+}
+
 
 
 extern void (*D_801819E4[])(void);