diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c b/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c
index 70a6bb39a..5561ff65f 100644
--- a/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c
+++ b/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c
@@ -3906,7 +3906,20 @@ void func_8017EBA4(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_8017EBCC);
+extern s32 D_801EDA20;
+extern s32 func_801399F0(s32);
+extern void func_80139914(s32);
+
+void func_8017EBCC(void)
+{
+    if (D_801EDA20 != 0) {
+        if (func_801399F0(D_801EDA20) != 0) {
+            func_80139914(D_801EDA20);
+            D_801EDA20 = 0;
+        }
+    }
+}
+
 
 extern s32 D_801EDA20;
     s32 func_8017EC18(void) {
@@ -4203,7 +4216,159 @@ void func_8017F8B4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_8017F950);
+#include "common.h"
+
+extern void func_8012A828(s32 a0, s32 a1);
+extern void func_80182B60(s32 *a0, s32 a1);
+extern s32 D_801EDA14;
+extern s32 D_80187F90;
+extern s32 D_80187FE8;
+extern s32 D_80188148;
+extern s32 D_801881D0;
+extern s32 D_80188298;
+extern s32 D_801DBEAC;
+extern s32 D_801DD170;
+extern s32 D_801DD624;
+extern s32 D_801DD64C;
+extern s32 D_801DD6C8;
+extern s32 D_801DDCB4;
+extern s32 D_801DDCC8;
+extern s32 D_801DDCDC;
+extern s32 D_801DDCF0;
+extern s32 D_801DE224;
+extern s32 D_801DEA28;
+extern s32 D_801DF1F4;
+extern s32 D_801DFBF8;
+extern s32 D_801DFF1C;
+extern s32 D_801E00B8;
+extern s32 D_801E00CC;
+extern s32 D_801E00E0;
+extern s32 D_801E00F4;
+extern s32 D_801E03C8;
+extern s32 D_801E03DC;
+extern s32 D_801E0868;
+
+void func_8017F950(s32 arg0)
+{
+    s32 s0 = arg0;
+
+    switch (D_801EDA14) {
+    case 0:
+        break;
+    case 1:
+        func_8012A828(s0, (s32)&D_80187FE8);
+        func_80182B60((s32 *)s0, (s32)&D_801DBEAC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 2:
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 3:
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 4:
+        func_8012A828(s0, (s32)&D_80187FE8);
+        func_80182B60((s32 *)s0, (s32)&D_801DD170);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 5:
+        func_8012A828(s0, (s32)&D_80187F90);
+        func_80182B60((s32 *)s0, (s32)&D_801DD64C);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x2424:
+        func_8012A828(s0, (s32)&D_80188298);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 0x3737:
+        func_80182B60((s32 *)s0, (s32)&D_801DD6C8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x38A:
+        func_80182B60((s32 *)s0, (s32)&D_801DDCB4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x38B:
+        func_80182B60((s32 *)s0, (s32)&D_801DDCC8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x3939:
+        func_80182B60((s32 *)s0, (s32)&D_801DDCDC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x4040:
+        func_80182B60((s32 *)s0, (s32)&D_801DDCF0);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x4141:
+        func_80182B60((s32 *)s0, (s32)&D_801DE224);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5050:
+        func_80182B60((s32 *)s0, (s32)&D_801DEA28);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5151:
+        func_80182B60((s32 *)s0, (s32)&D_801DF1F4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5151B:
+        func_8012A828(s0, (s32)&D_80188148);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 0x5151C:
+        func_8012A828(s0, (s32)&D_801881D0);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 0x5252:
+        func_8012A828(s0, (s32)&D_801881D0);
+        func_80182B60((s32 *)s0, (s32)&D_801DFBF8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x53A:
+        func_80182B60((s32 *)s0, (s32)&D_801DFF1C);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x53B:
+        func_80182B60((s32 *)s0, (s32)&D_801E00B8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5454:
+        func_80182B60((s32 *)s0, (s32)&D_801E00CC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5555:
+        func_80182B60((s32 *)s0, (s32)&D_801E00E0);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5656:
+        func_80182B60((s32 *)s0, (s32)&D_801E00F4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x57A:
+        func_80182B60((s32 *)s0, (s32)&D_801E03C8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x57B:
+        func_80182B60((s32 *)s0, (s32)&D_801E03DC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5858:
+        func_80182B60((s32 *)s0, (s32)&D_801E0868);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 8:
+        func_8012A828(s0, (s32)&D_80187FE8);
+        func_80182B60((s32 *)s0, (s32)&D_801DD624);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    }
+
+    if (D_801EDA14 != 0) {
+        D_801EDA14 = 0;
+    }
+}
+
 
 extern s32 D_801EDA14;
 
@@ -4540,7 +4705,158 @@ void func_80180914(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_801809B0);
+#include "common.h"
+
+extern void func_8012A828(s32 a0, s32 a1);
+extern void func_80182B60(s32 *a0, s32 a1);
+extern s32 D_801EDA18;
+extern s32 D_801887E8;
+extern s32 D_801888F8;
+extern s32 D_801889C8;
+extern s32 D_801E087C;
+extern s32 D_801E0890;
+extern s32 D_801E08A4;
+extern s32 D_801E08CC;
+extern s32 D_801E0948;
+extern s32 D_801E12AC;
+extern s32 D_801E1898;
+extern s32 D_801E18AC;
+extern s32 D_801E18C0;
+extern s32 D_801E18D4;
+extern s32 D_801E18E8;
+extern s32 D_801E18FC;
+extern s32 D_801E3048;
+extern s32 D_801E3814;
+extern s32 D_801E4218;
+extern s32 D_801E453C;
+extern s32 D_801E4550;
+extern s32 D_801E4564;
+extern s32 D_801E4578;
+extern s32 D_801E458C;
+extern s32 D_801E45A0;
+extern s32 D_801E45B4;
+extern s32 D_801E4A40;
+
+void func_801809B0(s32 arg0) {
+    s32 s0 = arg0;
+
+    switch (D_801EDA18) {
+    case 0:
+        break;
+    case 1:
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 2:
+        func_8012A828(s0, (s32)&D_801888F8);
+        func_80182B60((s32 *)s0, (s32)&D_801E087C);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 3:
+        func_8012A828(s0, (s32)&D_801887E8);
+        func_80182B60((s32 *)s0, (s32)&D_801E08CC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x3031:
+        func_80182B60((s32 *)s0, (s32)&D_801E0948);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x30B:
+        func_8012A828(s0, (s32)&D_801889C8);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    case 0x3737:
+        func_80182B60((s32 *)s0, (s32)&D_801E12AC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x38A:
+        func_80182B60((s32 *)s0, (s32)&D_801E1898);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x38B:
+        func_80182B60((s32 *)s0, (s32)&D_801E18AC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x3939:
+        func_80182B60((s32 *)s0, (s32)&D_801E18C0);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x4040:
+        func_80182B60((s32 *)s0, (s32)&D_801E18D4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x4141:
+        func_80182B60((s32 *)s0, (s32)&D_801E18E8);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x4747:
+        func_80182B60((s32 *)s0, (s32)&D_801E18FC);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5050:
+        func_80182B60((s32 *)s0, (s32)&D_801E3048);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5151:
+        func_80182B60((s32 *)s0, (s32)&D_801E3814);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5252:
+        func_80182B60((s32 *)s0, (s32)&D_801E4218);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x53A:
+        func_80182B60((s32 *)s0, (s32)&D_801E453C);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x53B:
+        func_80182B60((s32 *)s0, (s32)&D_801E4550);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5454:
+        func_80182B60((s32 *)s0, (s32)&D_801E4564);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5555:
+        func_80182B60((s32 *)s0, (s32)&D_801E4578);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5656:
+        func_80182B60((s32 *)s0, (s32)&D_801E458C);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x57A:
+        func_80182B60((s32 *)s0, (s32)&D_801E45A0);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x57B:
+        func_80182B60((s32 *)s0, (s32)&D_801E45B4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x5858:
+        func_80182B60((s32 *)s0, (s32)&D_801E4A40);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 6:
+        func_8012A828(s0, (s32)&D_801887E8);
+        func_80182B60((s32 *)s0, (s32)&D_801E0890);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 7:
+        func_8012A828(s0, (s32)&D_801887E8);
+        func_80182B60((s32 *)s0, (s32)&D_801E08A4);
+        *(u16 *)(s0 + 2) = 3;
+        break;
+    case 0x100:
+        func_8012A828(s0, (s32)&D_801888F8);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+        break;
+    }
+
+    if (D_801EDA18 != 0) {
+        D_801EDA18 = 0;
+    }
+}
+
 
 extern s32 D_801EDA18;
 
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 57eb3378c..ed5262742 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8018057C.c
@@ -3454,9 +3454,52 @@ extern void func_8012B200(u8 *param_1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_801819B0);
+extern s32 func_8012C51C(void *a0, void *a1);
+
+void func_801819B0(void *arg0) {
+    typedef struct {
+        s16 a, b, c, d, e, f, g, h;
+        s32 w;
+    } Blk801819B0;
+    Blk801819B0 blk;
+    s32 v0;
+
+    blk.d = 0x1AB;
+    blk.e = 0x29;
+    blk.a = -0x1C0;
+    blk.b = -0xB2;
+    blk.g = 0;
+    blk.f = 0;
+    blk.w = 0;
+    blk.h = 0;
+    blk.c = 0x188;
+    v0 = func_8012C51C(&blk, arg0);
+    *(s32 *)((s32)arg0 + 0xD4) = v0;
+}
+
+
+extern s32  func_8012C51C(void *a0, void *a1);
+extern u16  D_801F32D4;
+
+void func_80181A1C(void *arg0) {
+    typedef struct {
+        s16 a, b, c, d, e, f, g, h;
+        s32 w;
+    } Blk80181A1C;
+    Blk80181A1C blk;
+
+    blk.d = 0x1AB;
+    blk.e = 0x2A;
+    blk.g = 0;
+    blk.f = 0;
+    blk.w = 0;
+    blk.c = 0;
+    blk.b = 0;
+    blk.a = 0;
+    blk.h = D_801F32D4++;
+    func_8012C51C(&blk, arg0);
+}
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_80181A1C);
 
 extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
     void func_80181A80(void *a0) {
@@ -3464,7 +3507,12 @@ extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_80181AA8);
+void func_80181AA8(void *param_1) {
+    func_80146A6C(6, param_1, *(s16 *)((char *)param_1 + 6),
+                  (s16)(*(u16 *)((char *)param_1 + 0xA) - 0x10),
+                  (s16)(*(u16 *)((char *)param_1 + 0xE) + 0x30), 0x800FFC00, 0);
+}
+
 
 void func_80181B04(s32 arg0) {
     extern u16 D_801ED59C[];
@@ -3542,7 +3590,12 @@ void func_80181C64(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8018057C", func_80181CF8);
+void func_80181CF8(s32 a0) {
+    if (func_801789AC(a0) != 0) {
+        *(u16 *)(a0 + 2) += 1;
+    }
+}
+
 
 void func_80181D38(void *a0) {
     extern void func_801439C0(u8 *a0);
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 9a5481754..022b7cbc5 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
@@ -3784,7 +3784,19 @@ void func_8017E7C0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E834);
+extern s16 func_80171AB0(s32 a0, void *a1);
+extern s32 func_8013767C(s32 a0);
+
+extern u8 D_8018A4C0;
+extern s16 D_801A3220;
+
+void func_8017E834(void *arg0) {
+    if (func_80171AB0((s32)arg0, &D_8018A4C0) == 0) {
+        *(s32 *)((s8 *)arg0 + 0x198) = func_8013767C((s32)&D_801A3220);
+        *(u8 *)((s8 *)arg0 + 0x214) = *(u8 *)((s8 *)arg0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E890);
 
@@ -3835,7 +3847,21 @@ void func_8017EA4C(s32 param_1) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017EA98);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017ED5C);
+#include "common.h"
+
+extern void func_8012E9C0(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_8018A610;
+
+void func_8017ED5C(s32 param_1) {
+    func_8012E9C0(param_1);
+    func_8012A828(param_1, &D_8018A610);
+    *(s16 *)(param_1 + 0x2) = 3;
+    *(s32 *)(param_1 + 0x1C) = 0x14;
+    *(s16 *)(param_1 + 0x5C) = 0;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(s16 *)(param_1 + 0x62) + 0x800U & 0xFFF;
+}
+
 
 #include "common.h"
 
@@ -3947,7 +3973,28 @@ void func_8017F2D0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F308);
+void func_8017F308(void *a0)
+{
+    extern s32 func_8012BEE8(s32 a0);
+    extern void func_80130D48(s32 a0);
+    extern void func_8012C218(void *a0);
+    extern s32 func_8012C588(s32 a0, s32 a1);
+    extern s32 D_801270D0;
+
+    s16 sVar1;
+
+    if (func_8012BEE8((s32)a0)) {
+        func_80130D48((s32)a0);
+        sVar1 = *(s16 *)((s32)a0 + 0x70);
+        if (sVar1 == 0x100) {
+            D_801270D0 = 0;
+        } else if ((sVar1 & 0xFF00) == 0) {
+            func_8012C588(0x26, 0);
+        }
+        func_8012C218(a0);
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC02_037/ov_SC02_037.c b/src/ov_SC02_037/ov_SC02_037.c
index f04ea9963..fa5f5beee 100644
--- a/src/ov_SC02_037/ov_SC02_037.c
+++ b/src/ov_SC02_037/ov_SC02_037.c
@@ -313,7 +313,22 @@ int func_80128940(int arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037", func_80128998);
+extern void func_8001ABBC(s32 a0, s32 a1, void *a2, s32 a3, s32 sp10);
+
+s32 func_80128998(void)
+{
+    extern int D_800C7C60;
+    extern int *D_800C7C64;
+    extern int D_800A2E20;
+    extern int D_800AECB0;
+    extern s32 D_801C7200;
+
+    int *p = &D_800C7C60;
+    *p = 13;
+    D_800C7C64 = &D_800A2E20;
+    ((void (*)(int, int, int *, int, int *))func_8001ABBC)(0, 0, &D_800AECB0, D_801C7200, p);
+}
+
 
 
 
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_801555F4.c b/src/ov_SC02_037/ov_SC02_037_jr_801555F4.c
index 97d92b189..1aa839f88 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_801555F4.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_801555F4.c
@@ -2323,7 +2323,21 @@ void func_801577C8(s32 *param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_801555F4", func_80157808);
+extern void func_801599A4(void *a0);
+extern void func_80159B3C(void *a0);
+
+void func_80157808(s32 *a0)
+{
+    extern void (*D_80185F18[])(void);
+    extern s32 D_801C8578;
+    D_80185F18[*(unsigned short *)((char *)a0 + 2)]();
+    D_801C8578 = D_801C8578 - 1;
+    if (D_801C8578 == -1) {
+        func_801599A4(a0);
+        func_80159B3C(a0);
+    }
+}
+
 
 DEFINE_func_80157880()  /* dedup: shared engine-core @0x80157880 (src/shared) */
 
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_8015A3C8.c b/src/ov_SC02_037/ov_SC02_037_jr_8015A3C8.c
index 9dcf5d080..901fde574 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_8015A3C8.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_8015A3C8.c
@@ -4596,7 +4596,12 @@ DEFINE_func_8015EFA4()  /* dedup: shared engine-core @0x8015efa4 (src/shared) */
 DEFINE_func_8015EFD8()  /* dedup: shared engine-core @0x8015efd8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_8015A3C8", func_8015F00C);
+extern void (*D_801865A4[])(void);
+
+void func_8015F00C(s32 *a0) {
+    D_801865A4[*(u16 *)((s32)a0 + 0x2)]();
+}
+
 
 DEFINE_func_8015F048()  /* dedup: shared engine-core @0x8015f048 (src/shared) */
 
@@ -8130,7 +8135,23 @@ void func_80168430(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_8015A3C8", func_801684B4);
+void func_801684B4(s32 a0) {
+    extern void func_80146C3C();
+    extern s32 func_80166994(s32 a0, s32 a1, s32 a2, s32 a3);
+    s32 *s0 = (s32 *)a0;
+    if ((*(s32 *)(*(s32 *)(a0 + 0x34) + 0x44) & 0x2) == 0) {
+        ((void (*)(void))func_80146C3C)();
+    } else {
+        s16 v0 = *(u16 *)(a0 + 0x2A) - 1;
+        *(s16 *)(a0 + 0x2A) = v0;
+        if (v0 == 0) {
+            func_80166994(a0, 0, 2, 0);
+            *(s16 *)(a0 + 0x2) = *(u16 *)(a0 + 0x2) + 1;
+        }
+    }
+    (void)s0;
+}
+
 
 DEFINE_func_80168540()  /* dedup: shared engine-core @0x80168540 (src/shared) */
 
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 0394a7443..f610f3888 100644
--- a/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
+++ b/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
@@ -3500,7 +3500,23 @@ extern void func_8017FB78();
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DD98);
+extern s32 func_8012E544(s32 a0);
+extern void func_8012C098(void *a0);
+extern void func_8017FB78(void);
+extern void func_80171928(void *a0);
+
+void func_8017DD98(void *arg0)
+{
+    s32 v0;
+
+    v0 = func_8012E544(0x83);
+    if (v0) {
+        func_8012C098((void *)v0);
+    }
+    func_8017FB78();
+    func_80171928(arg0);
+}
+
 
 extern void func_8017FBFC(void);
 extern void func_80171928(void*);
@@ -3611,7 +3627,21 @@ void func_8017DFE4(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E08C);
+extern s32 D_80186068;
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern s32 func_8013767C(s32 a0);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017E08C(s32 param_1)
+{
+    if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(param_1 + 0x198));
+        *(s32 *)(param_1 + 0x198) = func_8013767C((s32)&D_80186068);
+        func_80171990((u8 *)param_1);
+    }
+}
+
 
 extern s32 func_801399F0(s32 a0);
 extern void func_80139914(s32 a0);
@@ -4549,7 +4579,22 @@ void func_8017F64C(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F6B8);
+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 s32 func_8012BEE8(s32 a0);
+extern s32 func_8012AD50(void *a0);
+
+void func_8017F6B8(s32 arg0) {
+    func_8017EB88(arg0);
+    func_801437D8(arg0 + 0x102, (s32)D_801852D0, (s32)D_80185300, 0);
+    if (func_8012BEE8(arg0) != 0) {
+        *(u16 *)(arg0 + 0xFE) = 0;
+        func_8012AD50((void *)arg0);
+    }
+}
+
 
 extern void func_8017EB88(s32 arg0);
 extern void func_801437D8(s32 a0, s32 a1, s32 a2, s32 a3);
@@ -4767,7 +4812,21 @@ void func_8017FB78(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FBFC);
+extern u8 D_801202A0[];
+
+void func_8017FBFC(void) {
+    u8 *p;
+    s16 i;
+
+    p = D_801202A0;
+    for (i = 0; i < 0x60; i++) {
+        if (*(u16 *)p == 0xBE) {
+            *(s16 *)(p + 2) = 3;
+        }
+        p += 0x10C;
+    }
+}
+
 
 extern s32 func_80132EF4(s32 a0, s32 a1);
 
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 caf7265f1..8b7da32fe 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -4365,7 +4365,24 @@ INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80180B4
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80181000);
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80181304);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012BA10(s32 a0, s32 a1);
+extern u8 D_801ADE54[];
+
+void func_80181304(void *a0) {
+    s32 iVar1;
+    s32 iVar2;
+
+    iVar1 = func_8012BA10((s32)a0, 4);
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += iVar1;
+    iVar2 = *(s32 *)(a0 + 0x1C) - 1;
+    *(s32 *)(a0 + 0x1C) = iVar2;
+    if (iVar2 == 0) {
+        *(u16 *)(a0 + 0x2) = 8;
+        func_8012A828((s32)a0, D_801ADE54);
+    }
+}
+
 
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern s32 func_8012C588(s32 a0, s32 a1);
@@ -5032,7 +5049,43 @@ void func_80182E2C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80182F3C);
+extern void func_8017C010(s32 a0, s32 a1, s32 a2);
+extern void func_8016AA50(s32 param_1, s32 param_2);
+extern void func_8016B3F4(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8002A520(void *a0);
+extern s16 D_8018F924;
+
+void func_80182F3C(void *param_1)
+{
+    s32 s0 = (s32)param_1;
+    u16 v0;
+
+    if (*(u8 *)(*(s32 *)(s0 + 0x64) + 0xC1) != 0) {
+        v0 = *(u16 *)(s0 + 0x5C);
+        *(u8 *)(s0 + 0xC1) = 0;
+        *(u16 *)(s0 + 0x5E) = 0;
+        *(u16 *)(s0 + 0x5C) = v0 & 0x7FFF;
+    } else {
+        *(u16 *)(s0 + 0x5C) = 0;
+        *(u8 *)(s0 + 0xC1) = 0;
+        *(u16 *)(*(s32 *)(s0 + 0x64) + 0x76) =
+            *(u16 *)(*(s32 *)(s0 + 0x64) + 0x76) - 0x28;
+        func_8017C010(*(s32 *)(s0 + 0x64) + 0x76, (s32)&D_8018F924, 0x78);
+        func_8016AA50(s0, 0x28);
+        func_8016B3F4(s0);
+        *(u16 *)(*(s32 *)(s0 + 0x64) + 0x5C) =
+            *(u16 *)(*(s32 *)(s0 + 0x64) + 0x5C) & 0xFDFF;
+        *(u16 *)(*(s32 *)(s0 + 0x64) + 2) = 0x27;
+        *(u16 *)(s0 + 2) = 2;
+        *(s32 *)(s0 + 0x1C) = 0xC;
+        func_8002D4C8(0xB08, 0);
+        if (*(u8 *)(s0 + 0xC8) != 0) {
+            func_8002A520(param_1);
+        }
+    }
+}
+
 
 
 extern void (*D_80190068[])(void);
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 7d70a96e8..28d7d1d5f 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
@@ -6497,7 +6497,38 @@ void func_801861DC(void *a0)
 
 INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_8018624C);
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_80186680);
+#include "common.h"
+
+extern s32 rand(void);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_801871C0(void *a0, s32 a1, s32 a2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void (*D_8018E8E4[])(void);
+extern void (*D_8018E9CC[])(void);
+
+void func_80186680(s32 a0)
+{
+    s32 v0;
+
+    if ((rand() & 0xFF) == 0) {
+        func_801871C0((void *)a0, rand() % 5 + 1, 2);
+    }
+
+    if (func_8012BEE8(a0) != 0) {
+        if ((rand() & 1) == 0) {
+            func_8012A828(a0, D_8018E8E4);
+            v0 = *(s32 *)(a0 + 0x6C);
+            func_8012A828(v0, D_8018E9CC);
+            *(s32 *)(a0 + 0x1C) = 0x72;
+            func_801871C0((void *)a0, 7, 3);
+            func_8002D4C8(0x728, 0);
+        } else {
+            *(s32 *)(a0 + 0x1C) = 0x5A;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_8018676C);
 
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_80186DDC.c b/src/ov_SC03_105/ov_SC03_105_jr_80186DDC.c
index 4156d2f5f..80f930b68 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_80186DDC.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_80186DDC.c
@@ -3854,7 +3854,61 @@ void func_801886C8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_80186DDC", func_80188828);
+extern void func_8012AD80(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s16 func_80174774(void);
+extern s32 func_8012BE54(s32 a0);
+
+void func_80188828(s32 arg0)
+{
+    u16 v1;
+    s32 v0;
+    s32 cnt;
+
+    func_8012AD80(arg0);
+    v1 = *(u16 *)(arg0 + 0x34);
+    switch (v1) {
+    case 0:
+        if (0xFEEEFFFFU < *(u32 *)(arg0 + 8)) {
+            *(u32 *)(arg0 + 8) = 0xFEEF0000;
+            *(s32 *)(arg0 + 0x14) = -(*(s32 *)(arg0 + 0x14) * 3 >> 2);
+            cnt = *(s32 *)(arg0 + 0x1C) + 1;
+            *(s32 *)(arg0 + 0x1C) = cnt;
+            if (6 < cnt) {
+                *(s32 *)(arg0 + 0x14) = 0;
+                *(s32 *)(arg0 + 0x48) = 0;
+                *(u16 *)(arg0 + 0x34) += 1;
+            }
+            if (*(s16 *)(arg0 + 0xE) < -0x1E9) {
+                *(s16 *)(arg0 + 0xE) = -0x1EA;
+            }
+            func_8002D4C8(0x773, 0);
+        }
+        break;
+    case 1:
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x10) += 0x20;
+        if (*(s16 *)(arg0 + 0xE) < -0x1E9) {
+            *(s32 *)(arg0 + 0x18) = 0;
+            *(s16 *)(arg0 + 0xE) = -0x1EA;
+            *(u16 *)(arg0 + 0x34) += 1;
+        }
+        break;
+    case 2:
+        if (((s32 (*)(void))func_80174774)() != 0) {
+            func_80188B64(arg0);
+            return;
+        }
+        break;
+    }
+
+    if (*(s16 *)(arg0 + 0xFE) == 0 && (v0 = func_8012BE54(arg0), v0 < 0x7901) &&
+        *(s16 *)(*(s32 *)(arg0 + 0x64) + 0xFE) == 2) {
+        func_8002D4C8(0x14C, 0);
+        *(u16 *)(arg0 + 0xFE) += 1;
+    }
+    func_80188A94(arg0);
+}
+
 
 extern s16 D_8018EE00;
 extern s32 D_8018F254;
diff --git a/src/ov_SC05_010/ov_SC05_010_jr_8017C8D0.c b/src/ov_SC05_010/ov_SC05_010_jr_8017C8D0.c
index 9ca414be1..95dfa1f41 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_8017C8D0.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_8017C8D0.c
@@ -4649,7 +4649,52 @@ void func_80180DEC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_8017C8D0", func_80180E28);
+extern s32 func_8004787C(s32 a0);
+extern s32 func_8017ECE4(s32 arg0);
+extern void func_8012D624(s32 a0, s32 a1, s32 a2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012B370(int a0);
+extern s16 D_801C7E28;
+extern s16 D_801C7E2C;
+extern u16 D_8019244C[][2];
+
+void func_80180E28(s32 param_1)
+{
+    s32 iVar1;
+
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) -= 0x80;
+    *(u16 *)(param_1 + 0x100) += 0x40;
+    *(s32 *)(param_1 + 4) -= *(s32 *)(param_1 + 0x10);
+    iVar1 = func_8004787C(*(s16 *)(param_1 + 0x100));
+    *(s32 *)(param_1 + 8) = iVar1 * *(s16 *)(param_1 + 0xFE) * -0x10 - 0x700000;
+    iVar1 = func_8017ECE4(param_1);
+    if (iVar1 >= 1) {
+        s32 child = *(s32 *)(param_1 + 0x20);
+        s32 e28 = D_801C7E28;
+        s16 val1E = 0x1E;
+
+        *(u16 *)(child + 0x14) = 0;
+        *(s16 *)(param_1 + 2) = 2;
+        *(s16 *)(param_1 + 0xFE) = val1E;
+        *(s16 *)(param_1 + 0xFC) = 0x400;
+        if (e28 != 0) {
+            D_801C7E2C = D_801C7E2C + 1;
+            if (D_801C7E2C >= 9) {
+                D_801C7E2C = 8;
+            }
+            D_801C7E28 = val1E;
+            func_8002D4C8(D_8019244C[D_801C7E2C][0], 0);
+        } else {
+            D_801C7E28 = val1E;
+            D_801C7E2C = 0;
+            func_8002D4C8(0x896, 0);
+        }
+    } else {
+        func_8012D624(param_1, 0x20, 0xC);
+    }
+    func_8012B370(param_1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_8017C8D0", func_80180F84);
 
@@ -4881,4 +4926,57 @@ void func_80181670(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_8017C8D0", func_80181B4C);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_80181670(void *a0);
+extern u8 D_801928B8[];
+extern u8 D_801928C8[];
+extern u8 D_801A3E2C[];
+
+void func_80181B4C(void *a0)
+{
+    s32 v0;
+    s32 ptr64;
+    s32 rec;
+
+    if (*(u16 *)((s32)a0 + 0x2) == 0) {
+        v0 = func_8012C1B8();
+        *(s32 *)((s32)a0 + 0x20) = v0;
+        if (v0 == 0) {
+            func_8012CAE4(a0);
+            return;
+        }
+        func_8001C2C4(v0);
+        *(u16 *)((s32)a0 + 0x5C) = 0x8000;
+        *(s32 *)((s32)a0 + 0x58) = (s32)D_801928B8 | 0x40000000 | 0x20000000;
+        *(u16 *)((s32)a0 + 0x76) = 10000;
+        *(u8  *)((s32)a0 + 0xC0) = 1;
+        *(s16 *)((s32)a0 + 0xAE) = -1;
+        *(s32 *)((s32)a0 + 0xBC) = (s32)D_801928C8;
+        *(s32 *)((s32)a0 + 0x4)  = 0x25B0000;
+        *(s32 *)((s32)a0 + 0x8)  = 0xFF900000;
+        *(s32 *)((s32)a0 + 0xB4) = 0;
+        *(u16 *)((s32)a0 + 0x2) += 1;
+        *(s32 *)((s32)a0 + 0xC4) |= 3;
+    } else {
+        ptr64 = *(s32 *)((s32)a0 + 0x64);
+        if (*(u16 *)ptr64 != 0) {
+            rec = *(s32 *)(*(s32 *)(ptr64 + 0x20) + 0x20);
+            *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) = *(u16 *)(rec + 0x6);
+            *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)(rec + 0x8);
+            *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) = *(u16 *)(rec + 0xA) - 0x100;
+            *(s16 *)((s32)a0 + 0x6) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x6) + *(u16 *)(rec + 0x0);
+            *(s16 *)((s32)a0 + 0xA) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0xA) + *(u16 *)(rec + 0x2);
+            *(s16 *)((s32)a0 + 0xE) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0xE) + *(u16 *)(rec + 0x4);
+            func_8012B2CC((s32)a0);
+            if (*(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x90) == (s32)D_801A3E2C) {
+                func_80181670(a0);
+            }
+        }
+    }
+}
+
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 793cbcc94..75c7ee153 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
@@ -3064,7 +3064,38 @@ void func_801828E0(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_801829F0);
+#include "common.h"
+
+extern void (*D_80192990[])(void);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern u8 D_80192924[];
+extern void func_8012B370(int a0);
+
+void func_801829F0(s32 param_1) {
+    struct { s16 vx, vy, vz, pad; } pos;
+
+    D_80192990[*(u16 *)(param_1 + 2)]();
+
+    if (*(u16 *)(*(s32 *)(param_1 + 0x64)) != 0) {
+        u16 t = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xFC) + 0x400;
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12) - t;
+
+        ((void (*)(s32, void *, void *))func_8012F14C)(
+            *(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x34,
+            D_80192924,
+            &pos);
+
+        *(s16 *)(param_1 + 6)  = pos.vx;
+        *(s16 *)(param_1 + 0xA) = pos.vy;
+        *(s16 *)(param_1 + 0xE) = pos.vz;
+
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) =
+            *(u16 *)(*(s32 *)(param_1 + 0x64) + 0x100);
+        func_8012B370(param_1);
+    }
+}
+
 
 #include "common.h"
 
@@ -3105,7 +3136,38 @@ void func_80182AC0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80182BD0);
+#include "common.h"
+#include "/home/musashi/bfm-decomp/src/shared/engine_types.h"
+
+extern void (*D_80192A28[])(void);
+extern u8 D_80192924[];
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern void func_8012B370(int a0);
+
+void func_80182BD0(Obj1CDC *obj) {
+    u16 out[3];
+
+    D_80192A28[M2C_FIELD(obj, u16 *, 0x2)]();
+
+    if (M2C_FIELD(obj->unk64, u16 *, 0x0) != 0) {
+        u16 fc = M2C_FIELD(obj->unk64, u16 *, 0xFC);
+        fc -= 0x400;
+
+        M2C_FIELD(obj->unk20, u16 *, 0x12) =
+            *(u16 *)(M2C_FIELD(obj->unk64, s32 *, 0x20) + 0x12) - fc;
+
+        func_8012F14C(M2C_FIELD(obj->unk64, s32 *, 0x20) + 0x34,
+                      (s32)D_80192924, (s32)out);
+
+        obj->x = out[0];
+        obj->y = out[1];
+        obj->z = out[2];
+
+        obj->unk20->unk14 = obj->unk64->unk100;
+        func_8012B370((int)obj);
+    }
+}
+
 
 extern void func_8012A828(s32 a0, void *a1);
 extern void func_8002D4C8(s32 a0, s32 a1);
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 c4dc7c059..22fc3de56 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
@@ -3212,7 +3212,23 @@ s32 func_8017E6EC(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017E770);
+extern s32 func_80029504(void);
+extern void func_8017F038(void);
+extern void func_8017F528(void);
+extern void func_800167B8(s32 a0);
+
+s32 func_8017E770(s32 param_1)
+{
+    if (func_80029504() == 0x488) {
+        func_8017F038();
+    } else {
+        func_8017F528();
+    }
+    func_800167B8(0);
+    *(u8 *)(param_1 + 0x15) = *(u8 *)(param_1 + 0x15) + 1;
+    return 0;
+}
+
 
 
 
@@ -3458,9 +3474,44 @@ void func_8017EC80(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017ECEC);
+extern void func_8017FD94(void);
+extern s32 func_80171990(u8 *a0);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F990();
+
+void func_8017ECEC(void *a0)
+{
+    s32 v0;
+
+    v0 = *(s32 *)((u8 *)a0 + 0x200) + 0xA;
+    *(s32 *)((u8 *)a0 + 0x200) = v0;
+    if (v0 >= 0x258) {
+        *(s32 *)((u8 *)a0 + 0x200) = 0x64;
+        func_8017FD94();
+        func_80171990((u8 *)a0);
+    }
+    func_8017F818(a0, *(s16 *)((u8 *)a0 + 0x20C), *(s32 *)((u8 *)a0 + 0x200), 0);
+    func_8017F990(a0, 0);
+}
+
+
+extern void func_8017F060(void);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F990(s32 a0, s32 a1);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017ED60(s32 arg0)
+{
+    func_8017F060();
+    func_8017F818((void *)arg0, *(s16 *)(arg0 + 0x20C), *(s32 *)(arg0 + 0x200), 0);
+    func_8017F990(arg0, 0);
+    *(s32 *)(arg0 + 0x200) += 0xA;
+    if (*(s32 *)(arg0 + 0x200) >= 0x258) {
+        *(s32 *)(arg0 + 0x204) = 0xA0000;
+        func_80171990((u8 *)arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017ED60);
 
 extern void func_80129FF4(void);
 extern void func_801805E0(void);
@@ -3527,7 +3578,19 @@ void func_8017EF54(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EF88);
+extern s8 D_8018A8A0[];
+
+void func_8017EF88(s32 a0) {
+    extern void func_8017EFE0(void);
+    s32 s0 = a0;
+    func_8017EFE0();
+    func_80147060((u8 *)s0);
+    func_80147084((s32 *)s0);
+    func_801472B4((void *)s0);
+    func_80172310((u8 *)D_8018A8A0);
+    func_80171928((void *)s0);
+}
+
 
 extern s32 func_8012E544(s32 arg);
 
diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c b/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
index d15fab72f..42bc74853 100644
--- a/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
+++ b/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
@@ -3321,7 +3321,13 @@ DEFINE_func_8017BEAC()  /* dedup: shared engine-core @0x8017BEAC (src/shared) */
 
 DEFINE_func_8017BEB4()  /* dedup: shared engine-core @0x8017BEB4 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_8017BEBC);
+extern void func_80174684(void *);
+extern void func_8017BEE4(void *);
+
+void func_8017BEBC(void) {
+    func_80174684((void *)func_8017BEE4);
+}
+
 
 
 extern void (*D_8018BC74[])(void);
@@ -6784,7 +6790,17 @@ void func_80180D5C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_80180D98);
+extern s32 D_801AE6E8;
+extern void func_801815E8(void);
+extern s32 func_80171990(u8 *a0);
+
+void func_80180D98(u8 *a0) {
+    D_801AE6E8 = 0;
+    func_801815E8();
+    *(s32 *)(a0 + 0x204) = 0;
+    func_80171990(a0);
+}
+
 
 extern s32 func_80171990(u8 *a0);
 extern s16 D_801274EA;
@@ -7055,7 +7071,17 @@ void func_80181388(u8 *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_801813FC);
+extern s32 D_801AE6E8;
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_80171990(u8 *a0);
+
+void func_801813FC(u8 *a0) {
+    if (D_801AE6E8 != 0) {
+        func_8002D4C8(0x92A, 0);
+        func_80171990(a0);
+    }
+}
+
 
 extern s32 func_8017EE98(s32 arg);
     extern s32 func_80171990(u8 *a0);
@@ -7224,7 +7250,37 @@ extern void func_8012A568(void (*a0)(void));
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_80181864);
+
+
+s32 func_80181864(s32 _arg0)
+{
+    extern Blk8_80181774 D_8018C0F0;
+    extern Blk8_80181774 D_801274E8;
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    extern u8 D_80126948[];
+    extern void func_8012A018(s32, s32);
+    extern void func_80181A78(void *);
+
+    D_801274E8 = D_8018C0F0;
+    D_80126954 = 0x190;
+    D_8012695C = 0x480;
+    D_80126968 = 0x180;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0;
+    func_8012A018((s32)func_80181A78, 2);
+    func_80181A78((void *)D_80126948);
+}
+
 
 extern s32 func_80181940;
 extern void func_8012A568(void (*)(void));
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 d70145e21..faa4d50c2 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
@@ -3164,7 +3164,113 @@ void func_8017FB50(s32 arg0, s32 arg1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_8017FD28);
+#include "common.h"
+
+/* func_8017FD28 (ov_SC06_025, 137 ins) -- MATCH, relocation-masked (tools/match_one.py).
+ *
+ * BANKING NOTE (read before gating -- this draft CANNOT compile in the TU as-is):
+ *   The definition MUST return s32.  Every `return 1/2/0` is a real target instruction
+ *   (`addiu $v0,1` @8017FD7C, `addiu $v0,2` @8017FD84/8017FF1C, the shared `addu $v0,$zero,$zero`
+ *   @8017FF30).  Compiled `void` it drops to 128 ins -- byte-tested, -9.
+ *   But ov_SC06_025_jr_8017EEC4.c already carries TWO declarations of this symbol that a
+ *   `s32` definition conflicts with (cc1 exit 33, `conflicting types for func_8017FD28`):
+ *       :3107  extern void func_8017FD28();      (file scope)
+ *       :3225  extern void func_8017FD28();      (block scope, in func_801805BC)
+ *   Both call sites ALREADY cast (`((s32 (*)(...))func_8017FD28)(...)`), so the fix is the
+ *   §17a-1 same-function direction: tools/normalize_self_decls.py, or simply flip those two
+ *   `void` -> `s32`.  DO NOT let sig_unify rewrite this def to the fleet-canonical
+ *   `void func_8017FD28(s32)` -- that canon is the §238 homonym from ov_SC03_010/011 +
+ *   engine_core.h, a DIFFERENT function at the same address; it costs the match.
+ *
+ * Structure notes:
+ *   - `row` (the 8-byte D_80188CA4 pair) MUST be a local pointer: spelling the two accesses as
+ *     D_80188CA4[arg1][0/1] re-folds the global address into each MEM (lui $at/addu $at) and
+ *     costs 2 ins; the target computes the row into $a1 once.
+ *   - q[arg2] is read TWICE on purpose (lhu for the 0xDE store, lh for the *8 index): the
+ *     intervening store to (s0+0xDE) kills the cse of the halfword, but not of the ADDRESS.
+ *   - v is read straight out of an s16 array: the lhu + sll16/sra16 (rather than one `lh`) is
+ *     combine keeping the shifted temp alive because `v / 2` reuses it as the sign bit
+ *     (`srl $v0,$a3,31` @8017FDA0).  Do not "simplify" the read.
+ *   - ONE trailing `return 0;` with an else-if chain: that is what builds the shared
+ *     .L8017FF30 (`addu $v0,$zero,$zero`) the >=6 and >0 arms `j` to, and what lets the
+ *     delay-slot filler retarget the other two arms to .L8017FF34 with $v0=0 in the slot.
+ *     Per-arm `return 0;` statements cost an extra `move $v0,$zero`.
+ *   - Call-arg globals are written as the argument expression, NOT hoisted to a temp: the temp
+ *     forces `lw $v1` + `move $a1,$v1`; sched1 legally floats the arg load above the
+ *     D_801B1740/D_801B1744 store (different symbols) to reach the target's `lw $a1` form.
+ */
+s32 func_8017FD28(void *arg0, s32 arg1, s32 arg2) {
+    extern s16 *D_80188CA4[][2];
+    extern void *D_80188CBC[];
+    extern void *D_80188D0C[];
+    extern u8 D_80189054[];                        /* TU spelling, :4597 */
+    extern s16 D_801B1724;
+    extern s16 D_801B1740;
+    extern s16 D_801B1744;
+    extern void func_8012A828(s32 a0, void *a1);   /* TU spelling, :3475/:4416 */
+    extern void func_8012AD80(s32 a0);             /* TU spelling, :3393 */
+    extern s32 func_8012B744();                    /* unspecified params: the TU calls it with
+                                                    * ONE arg at :3876 */
+    extern void func_80181B90(s32 a0);             /* TU definition, :3934 */
+    extern void func_8017FF4C(s32 arg0, s16 *arg1, s32 arg2);  /* TU definition, :3069 */
+    extern s32 rand(void);                         /* TU spelling, :2854 */
+
+    s32 s0;
+    s16 **row;
+    s16 *q;
+    s16 *pp;
+    s32 v;
+    s32 diff;
+    s32 r;
+
+    row = D_80188CA4[arg1];
+    v = row[0][arg2];
+    s0 = (s32)arg0;
+    if (v <= 0) {
+        if (D_801B1724 != 0) {
+            return 2;
+        }
+        return 1;
+    }
+    q = row[1];
+    *(s16 *)(s0 + 0xDE) = q[arg2];
+    diff = v / 2 - *(s32 *)(s0 + 0x1C);
+    pp = (s16 *)&D_80189054[q[arg2] * 8];
+    if (diff >= 6) {
+        if (D_801B1744 != 1) {
+            D_801B1744 = 1;
+            func_8012A828(s0, D_80188D0C[D_801B1740]);
+        }
+        *(s16 *)(s0 + 0xA) = -0x1EE;
+        *(s16 *)(s0 + 0x8) = 0;
+    } else if (diff == 5) {
+        r = rand() % 3;
+        D_801B1740 = r;
+        func_8012A828(s0, D_80188CBC[r]);
+        D_801B1744 = 0;
+        func_8012B744((void *)(s0 + 4), pp);
+        func_8017FF4C(s0, pp, 5);
+    } else if (diff > 0) {
+        func_8012AD80(s0);
+        if (*(s16 *)(s0 + 0xA) >= -0x1ED) {
+            *(s16 *)(s0 + 0xA) = -0x1EE;
+        }
+    } else {
+        func_8012AD80(s0);
+        if (*(s16 *)(s0 + 0xA) >= -0x1ED) {
+            *(s16 *)(s0 + 0xA) = -0x1EE;
+        }
+        *(s16 *)(s0 + 0xA) = -0x1EE;
+        *(s16 *)(s0 + 0x8) = 0;
+        func_80181B90(*(s16 *)(s0 + 0xDE));
+        if (D_801B1724 != 0) {
+            return 2;
+        }
+        *(u16 *)(s0 + 0xDC) += 1;
+    }
+    return 0;
+}
+
 
 extern s32 D_80188A00;
 
@@ -3206,7 +3312,7 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_8018030
 extern s32 func_801789AC(s32 arg0);
 extern void func_80181700(void *a0);
 extern s32 func_8012BEE8(s32 a0);
-extern void func_8017FD28();      /* adopt sibling draft func_801805BC's spelling; return recovered by cast at the call (§183 SIGNATURE-cast-at-call) */
+extern s32 func_8017FD28();      /* adopt sibling draft func_801805BC's spelling; return recovered by cast at the call (§183 SIGNATURE-cast-at-call) */
 extern void func_80182148(void);      /* TU's own definition later in this file: void(void) */
 extern void func_80180520(void *a0);
 
@@ -3324,7 +3430,7 @@ void func_801805BC(void *arg0) {
     extern void func_80181700(void *arg0);
     extern void func_80180808();      /* fleet is SPLIT (void* x6 / s32 x4):
                                        * unspecified params conflict with neither */
-    extern void func_8017FD28();      /* no extern exists anywhere in src/; the only
+    extern s32 func_8017FD28();      /* no extern exists anywhere in src/; the only
                                        * banked def spelling is ('void',()) -- so take
                                        * that and cast at the use, TU house style */
     extern void func_80180950(void *arg0);
@@ -3561,7 +3667,21 @@ void func_80180B7C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_80180D28);
+void func_80180D28(void *arg0) {
+    extern s32 D_801270C8;
+    extern void func_8012E8E0(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_801889F8[];
+    extern s32 D_801A0FBC;
+
+    *(s16 *)((char *)arg0 + 0x2) = 7;
+    *(s16 *)((char *)arg0 + 0x34) = 0;
+    func_8012E8E0((s32)arg0, (s32)&D_801889F8);
+    func_8012A828((s32)arg0, &D_801A0FBC);
+    D_801270C8 = 0;
+    *(s32 *)((char *)arg0 + 0x1C) = 0x3C;
+}
+
 
 void func_80180D84(void *arg0) {
     /* block-scope layout type, named uniquely so it can never collide with the
diff --git a/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c b/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
index d5367dc19..6415c2d09 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
@@ -2654,7 +2654,13 @@ DEFINE_func_8014C118()  /* dedup: shared engine-core @0x8014c118 (src/shared) */
 DEFINE_func_8014C168()  /* dedup: shared engine-core @0x8014c168 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_801457A4", func_8014C1A0);
+extern void func_8014C1C8(s32 arg0, s32 arg1, void *arg2);
+extern s32 D_80184B70;
+
+void func_8014C1A0(s32 arg0, s32 arg1) {
+    func_8014C1C8(arg0, arg1, &D_80184B70);
+}
+
 
 DEFINE_func_8014C1C8()  /* dedup: shared engine-core @0x8014c1c8 (src/shared) */
 
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 a263881d6..fb983fc2e 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
@@ -4473,7 +4473,15 @@ void func_8017E268(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E2B8);
+extern void func_8017D288(void);
+
+s32 func_8017E2B8(void *arg0)
+{
+    func_8017D288();
+    M2C_FIELD(arg0, s16 *, 0x6) = 0;
+    M2C_FIELD(arg0, u16 *, 4) = (u16) (M2C_FIELD(arg0, u16 *, 4) + 1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E2F0);
 
@@ -4634,7 +4642,18 @@ void func_8017E5D8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E608);
+void func_8017E608(s32 arg0) {
+    s16 t;
+
+    t = *(u16 *)(arg0 + 0x4);
+    *(s32 *)(arg0 + 0x10) = -1;
+    *(u16 *)(arg0 + 0x8) = 0;
+    *(s16 *)(arg0 + 0xA) = -1;
+    *(u16 *)(arg0 + 0xC) = 0;
+    *(u16 *)(arg0 + 0x6) = 0;
+    *(u16 *)(arg0 + 0x4) = t + 1;
+}
+
 
 extern s32 func_80181334(s32 a0, s32 a1);
 extern void func_80181120();