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 fb17a7c33..7f45f2026 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
@@ -3167,9 +3167,37 @@ void func_8017D898(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017E778);
+extern u8 D_8018F494[];
+extern u8 D_8018F570[];
+extern u8 *D_801274C8;
+extern void *D_801274CC;
+extern s32 D_8012704C;
+extern s32 func_8017FB44(s32 param_1);
+
+void func_8017E778(void)
+{
+    D_801274C8 = D_8018F494;
+    D_801274CC = D_8018F570;
+    func_8017FB44(0);
+    D_8012704C = 1;
+}
+
+
+extern s32 func_8017FB44(s32 param_1);
+
+void func_8017E7C4(void)
+{
+    extern u8 D_8018F494[];
+    extern u8 D_8018F570[];
+    extern u8 *D_801274C8;
+    extern void *D_801274CC;
+    extern s32 D_8012704C;
+    D_801274C8 = D_8018F494;
+    D_801274CC = ((s16 *)D_8018F570);
+    func_8017FB44(0);
+    D_8012704C = 1;
+}
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017E7C4);
 
 
 extern int func_8017FB44(int param_1);
@@ -3632,7 +3660,36 @@ void func_8017F0F0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017F188);
+/* A-prop sibling of func_8017F054 / func_8017F0F0 in this TU (same skeleton,
+ * different per-overlay constants + func_8012A018's second arg). Symbol
+ * surface taken from asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898/func_8017F188.s. */
+extern void func_8012A018(s32 a0, s32 a1);
+extern void func_8012A094(s32 a0);
+extern void func_8017F3E4(void *a0);
+extern u8 D_80126948[];
+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;
+
+void func_8017F188(void) {
+    D_80126954 = 0x12C;
+    D_8012695C = 0x2BC;
+    D_80126968 = 0x71;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x70;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017F3E4, 2);
+    func_8012A094((s32)D_80126948);
+    func_8017F3E4(D_80126948);
+}
+
 
 extern void func_8012A018(s32 a, s32 b);
 extern void func_8012A094(s32 a0);
diff --git a/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c b/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c
index d4bf0dcfc..346f9c618 100644
--- a/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c
+++ b/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c
@@ -7224,7 +7224,78 @@ void func_801821F4(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_jr_8017AE2C", func_80182328);
+#include "common.h"
+
+extern void func_8012AD80(s32 a0);
+extern void func_80182674(s32 a0, s16 *vec, s32 count, s32 flag);
+extern void func_80182848(void *a0, u8 *a1, s32 a2, s32 a3, s32 a4);
+extern s32 func_80133784(s32 a0, void *a1, s32 a2);
+extern void func_8013C98C(void);
+extern void func_8013C9C4(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+extern u16 D_80188E58;
+extern u16 D_80188E5A;
+extern u16 D_80188E5C;
+extern u16 D_80188E60;
+extern u16 D_80188E62;
+extern u16 D_80188E64;
+extern u8 D_80188E68[];
+
+void func_80182328(void *a0)
+{
+    extern void (*D_80188F48[])(void);
+    s16 sp18[3];
+    s16 sp20[3];
+    s16 sp28[3];
+    s32 v0;
+    s32 pad[2];
+
+    func_8012AD80((s32)a0);
+
+    sp18[0] = *(u16 *)((s8 *)a0 + 0x3A);
+    sp18[1] = *(u16 *)((s8 *)a0 + 0x3E);
+    sp18[2] = *(u16 *)((s8 *)a0 + 0x42);
+
+    sp20[0] = *(u16 *)((s8 *)a0 + 0x6);
+    sp20[1] = *(u16 *)((s8 *)a0 + 0xA);
+    sp20[2] = *(u16 *)((s8 *)a0 + 0xE);
+
+    sp28[0] = sp20[0] + D_80188E60;
+    sp28[1] = sp20[1] + D_80188E62;
+    sp28[2] = sp20[2] + D_80188E64;
+
+    func_80182674((s32)a0, sp28, 5, 0);
+
+    if ((*(s32 *)((s8 *)a0 + 0x1C) & 7) == 0) {
+        func_80182848(a0, D_80188E68, 5, 0, 0);
+        func_80182848(a0, D_80188E68, 5, 0, 1);
+    }
+
+    sp18[0] = sp18[0] + D_80188E58;
+    sp18[1] = sp18[1] + D_80188E5A;
+    sp18[2] = sp18[2] + D_80188E5C;
+
+    sp20[0] = sp20[0] + D_80188E58;
+    sp20[1] = sp20[1] + D_80188E5A;
+    sp20[2] = sp20[2] + D_80188E5C;
+
+    *(s32 *)((s8 *)a0 + 0x1C) = *(s32 *)((s8 *)a0 + 0x1C) + 1;
+    v0 = func_80133784(1, sp18, (s32)sp20);
+
+    if ((v0 & 0x2000) != 0) {
+        *(u16 *)((s8 *)a0 + 0x2) = 4;
+        *(s32 *)((s8 *)a0 + 0x1C) = 0x3C;
+        *(u16 *)((s8 *)a0 + 0x34) = 0;
+        func_8013C98C();
+        func_8013C9C4(&D_80188F48);
+        *(s32 *)((s8 *)a0 + 0xE0) = 3;
+        func_8002D4C8(0x63E, 0);
+    }
+
+    func_80182618(a0);
+}
+
 
 extern s32 D_80188E80[];
 
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8017AE2C.c b/src/ov_SC03_028/ov_SC03_028_jr_8017AE2C.c
index f3955306e..629fa8bb3 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017AE2C.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017AE2C.c
@@ -3315,7 +3315,12 @@ DEFINE_func_8017BEAC()  /* dedup: shared engine-core @0x8017BEAC (src/shared) */
 
 DEFINE_func_8017BEB4()  /* dedup: shared engine-core @0x8017BEB4 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017AE2C", func_8017BEBC);
+extern void func_8017BF34(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
+
+void func_8017BEBC(s32 arg0, s32 arg1) {
+    func_8017BF34(arg0, arg1, 0xC, 0);
+}
+
 
 DEFINE_func_8017BEE0()  /* dedup: shared engine-core @0x8017BEE0 (src/shared) */
 
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 f0342ca64..490148673 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -4973,7 +4973,26 @@ skip_escape:;
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80182628);
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012BA10(s32 a0, s32 a1);
+extern u8 D_801ADE54[];
+
+void func_80182628(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) = 0x1A;
+        func_8012A828((s32)a0, D_801ADE54);
+    }
+}
+
 
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern void func_8012A828(s32 a0, void *a1);
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_80185C14.c b/src/ov_SC03_028/ov_SC03_028_jr_80185C14.c
index 80ee44f45..4079a53bf 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_80185C14.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_80185C14.c
@@ -3519,7 +3519,21 @@ void func_80186894(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_80185C14", func_801869C0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801ADC6C;
+
+void func_801869C0(s32 param_1)
+{
+    s32 v0;
+
+    v0 = *(s32 *)(param_1 + 0x1c) - 1;
+    *(s32 *)(param_1 + 0x1c) = v0;
+    if (v0 == 0) {
+        *(s16 *)(param_1 + 2) = 6;
+        func_8012A828(param_1, &D_801ADC6C);
+    }
+}
+
 
 void func_80186A00(s32 a0) {
     extern s32 func_8012B8E4(s32 a0, s32 a1);
@@ -4064,7 +4078,26 @@ void func_8018741C(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_80185C14", func_801874D0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801ADE54[];
+
+void func_801874D0(s32 a0) {
+    register s32 s0 __asm__("$16");
+    s32 v0;
+
+    s0 = a0;
+    if ((*(u16 *)(s0 + 0x72) & 0x4000) != 0) {
+        func_8002D4C8(0x619, 0);
+    }
+    v0 = *(s32 *)(s0 + 0x1C) - 1;
+    *(s32 *)(s0 + 0x1C) = v0;
+    if (v0 == 0) {
+        func_8012A828(s0, D_801ADE54);
+        *(s16 *)(s0 + 0x2) = 3;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c b/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
index e101ef9cd..2331d01fa 100644
--- a/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
+++ b/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
@@ -3305,7 +3305,36 @@ void func_8017ECF0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017ED18);
+extern s32 D_80126954;
+extern s32 D_80126950;
+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 void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern u8 D_80126948[];
+extern void func_8017EDBC(void *a0);
+
+void func_8017ED18(void) {
+    D_80126954 = 0x12C;
+    D_80126950 = 0x12C;
+    D_8012695C = 0x4B0;
+    D_80126968 = 0x2AA;
+    D_8012696A = 0x800;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0x100;
+    func_8012A018((s32) func_8017EDBC, 0);
+    func_8012A094((s32) D_80126948);
+    func_8017EDBC((void *) D_80126948);
+}
+
 
 
 extern void (*D_80185FB8[])(void);
@@ -3476,9 +3505,53 @@ void func_8017F1B4(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F23C);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017F23C(void *a0) {
+    *(u16 *)((s32)a0 + 0x2) = 3;
+    func_8012B200(a0);
+    func_8012B178((s32)a0, 0xFFFE0000);
+    *(s32 *)((s32)a0 + 0x1C) = 0x41;
+    func_8002D4C8(0x5C2, 0);
+}
+
+
+extern void func_8012AD80(s32);
+extern s32 func_8012BEE8(s32);
+extern void func_8017BEBC(s32 a0, s16 *a1, s16 a2);
+extern void func_8013C9C4(void *a0);
+extern s8 D_80186174[];
+extern u8 D_80186114[];
+
+void func_8017F28C(void *arg0)
+{
+    u8 *s0 = arg0;
+    s32 v1;
+    s16 *s2;
+    s32 i;
+
+    v1 = *(s32 *)(s0 + 0x20);
+    *(u16 *)(v1 + 0x10) += 0x10;
+
+    func_8012AD80((s32) s0);
+
+    if (func_8012BEE8((s32) s0) != 0) {
+        v1 = *(s32 *)(s0 + 0x20);
+        *(u16 *)(v1 + 0x10) = 0x400;
+        *(u16 *)(s0 + 2) = 4;
+        s2 = (s16 *)(D_80186174 + ((*(u16 *)(s0 + 0x70) & 0xF) << 3));
+        for (i = 0; i < 5; i++) {
+            func_8017BEBC((s32) s0, s2, 0);
+        }
+    }
+
+    if (*(s32 *)(s0 + 0x1C) == 0x38) {
+        func_8013C9C4(D_80186114);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F28C);
 
 extern void func_8012B200(u8 *a0);
     extern s32 func_8017F860(void *a0);
@@ -3515,7 +3588,22 @@ void func_8017F394(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F428);
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F6B8);
+#include "common.h"
+
+extern void func_8017F95C(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern u8 D_80185FF0[];
+extern s32 D_801860F4;
+
+void func_8017F6B8(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 8;
+    *(s16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0x500;
+    *(s32 *)(a0 + 0x58) = (s32)D_80185FF0 | 0x40000000 | 0x20000000;
+    *(s32 *)(*(s32 *)(a0 + 0x20) + 0x20) = (s32)&D_801860F4;
+    func_8017F95C(a0);
+    func_8012B2CC(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F728);
 
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 25d71c6ea..f9c50ad05 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_8017AE2C.c
@@ -5769,7 +5769,33 @@ s32 func_8017FD58(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8017AE2C", func_8017FD70);
+#include "common.h"
+
+void func_8017FD70(s32 arg0) {
+    extern s32 D_80126B9C;
+    extern s32 func_80178B18(s32 param_1, s32 param_2);
+    extern void func_80029514(s32);
+    extern s16 D_8018F7C8;
+    extern int func_80178970();
+    extern void func_80178D18();
+    extern void func_8017F40C(void *arg0);
+    switch (*(u16 *)(arg0 + 0x34)) {
+    case 0:
+        if (D_80126B9C & 0x8000000) {
+            *(u16 *)(arg0 + 0x34) = 1;
+            func_80178B18(arg0, &D_8018F7C8);
+        }
+        break;
+    case 1:
+        if (((s32 (*)(s32))func_80178970)(arg0) != 0) {
+            ((void (*)(s32))func_80178D18)((s32)arg0);
+            func_80029514(0x1AE);
+            func_8017F40C((void *)arg0);
+        }
+        break;
+    }
+}
+
 
 void func_8017FE10(void) {
 }
@@ -5919,7 +5945,20 @@ void func_80180230(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8017AE2C", func_8018023C);
+extern u16 D_800B99DA;
+extern u8 D_8018FC10;
+extern u8 D_8018FC11;
+extern u8 D_8018FC12;
+extern u8 D_8018FC13;
+extern s32 func_801842F8(u8 a0, u8 a1, u8 a2, u8 a3);
+extern void func_8017FF64(void *a0);
+
+void func_8018023C(void *a0) {
+    if ((D_800B99DA & 3) == 0 && func_801842F8(D_8018FC10, D_8018FC11, D_8018FC12, D_8018FC13) != 0) {
+        func_8017FF64(a0);
+    }
+}
+
 
 extern s32 func_801846CC(s32 a0);
 extern void func_801845FC(s32, s32, s32, s32);
@@ -6133,7 +6172,31 @@ extern void func_800D1724(s32 a0);
 void func_8018072C(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8017AE2C", func_80180734);
+extern s32 func_80029178(s32 arg);
+extern int func_800D0F8C(int a0);
+extern void func_80178CBC(s32 *a0, s32 a1);
+extern void func_80029124(s32, s32);
+extern void func_800D0F4C(s32 a0);
+extern u8 D_8018FD84;
+extern u8 D_8018FC54;
+extern u8 D_8018FCB4;
+
+void func_80180734(s32 a0) {
+    s32 t;
+
+    *(s16 *)(a0 + 2) = 3;
+    t = func_80029178(0x106);
+    if ((t & 0xFF) != 0) {
+        func_80178CBC((s32 *)a0, (s32)&D_8018FD84);
+    } else if (func_800D0F8C(0x58) == 0) {
+        func_80178CBC((s32 *)a0, (s32)&D_8018FC54);
+    } else {
+        func_80178CBC((s32 *)a0, (s32)&D_8018FCB4);
+        func_80029124(0x106, 1);
+        func_800D0F4C(0x58);
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c b/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
index 967505717..4790adcac 100644
--- a/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
+++ b/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
@@ -6317,7 +6317,23 @@ void func_80181D04(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_80181D4C);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80181D4C(s32 arg0) {
+    extern u16 D_80126980;
+    extern s32 func_80182334(void);
+    extern void func_8012C098(void);
+    extern void func_801823B8();
+
+    if (*(s32 *)((s32)arg0 + 0xDC) - 0xA == D_80126980) {
+        func_8002D4C8(0x88E, 0);
+    }
+    func_801823B8(arg0, 2, 0);
+    if (!((s32 (*)(s32))func_80182334)(arg0)) {
+        ((void (*)(s32))func_8012C098)(arg0);
+    }
+}
+
 
 
 extern s32 func_80013328(s32 a0, s32 a1);
@@ -6350,7 +6366,21 @@ extern s32 func_8012AD50(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_80181E88);
+void func_80181E88(void *a0) {
+    extern void func_8012C1B8(void);
+    extern void func_8018227C(void *, void *);
+    extern s32 func_8012AD50(void *);
+    extern s32 D_8019BA68;
+    s32 ret;
+
+    ret = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = ret;
+    if (ret != 0) {
+        func_8018227C(a0, &D_8019BA68);
+        func_8012AD50(a0);
+    }
+}
+
 
 void func_80181ED0(s32 arg0) {
     extern u16 D_80126980;
@@ -6449,9 +6479,39 @@ extern s32 func_8012AD50(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_8018218C);
+extern void func_8012C1B8(void);
+extern void func_8018227C(void*, void*);
+extern s32 func_8012AD50(void *a0);
+extern s32 D_8019C8B8;
+
+void func_8018218C(void *a0) {
+    s32 ret;
+
+    ret = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = ret;
+    if (ret != 0) {
+        func_8018227C(a0, &D_8019C8B8);
+        func_8012AD50(a0);
+    }
+}
+
+
+void func_801821D4(void *a0) {
+    extern s32 D_801151D4;
+    extern s32 func_80182334(void);
+    extern void func_8012C098(void);
+
+    s32 wp = D_801151D4;
+
+    if (((s32 (*)(s32))func_80182334)((s32)a0) == 0) {
+        ((void (*)(s32))func_8012C098)((s32)a0);
+    } else {
+        if (*(s32 *)((s32)a0 + 0xDC) - 0xA == *(u16 *)(wp + 0x38)) {
+            func_8002D4C8(0x88E, 0);
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_801821D4);
 
 INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_80182240);
 
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 c6b648e9f..f5b7a52df 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
@@ -4721,7 +4721,44 @@ extern void func_8012CBCC(s32 a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80186624);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8012B200(u8 *a0);
+extern void func_8001CA1C(void *a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 rand(void);
+
+extern u8 D_80192AFC[];
+extern u8 D_80192B38[];
+
+void func_80186624(s32 param_1)
+{
+    s32 v0;
+    s32 v1;
+
+    if ((*(s32 *)(param_1 + 0x20) = func_8012C1B8()) == 0) {
+        func_8012CAE4((void *)param_1);
+    } else {
+        func_8012B200((u8 *)param_1);
+        func_8001CA1C((void *)(*(s32 *)(param_1 + 0x20)), D_80192AFC);
+        func_8012A828(param_1, D_80192B38);
+        *(s16 *)(param_1 + 2) = 1;
+        *(u32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x50000000;
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10;
+        v1 = *(s32 *)(param_1 + 0x20);
+        *(s16 *)(v1 + 0x1A) = 0x4000;
+        *(s16 *)(v1 + 0x18) = 0x4000;
+        v0 = rand();
+        v1 = ((v0 & 0x7FF) - 0x400) * 0x156;
+        *(s32 *)(param_1 + 0x10) = v1;
+        v0 = rand();
+        *(s32 *)(param_1 + 0x14) = ((v0 & 0x7FF) - 0x400) * 0x80;
+        *(s16 *)(param_1 + 6) = 0x270;
+        *(s16 *)(param_1 + 0xA) = -0xC0;
+        *(s16 *)(param_1 + 0xE) = -0x40;
+    }
+}
+
 
 extern s32 func_8012C1B8(void);
 extern void func_8012CAE4(void *a0);
@@ -4927,7 +4964,38 @@ void func_80186BD8(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80186C44);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s32 rand(void);
+
+void func_80186C44(s32 a0)
+{
+    s32 s1 = a0;
+    s32 v;
+    s32 i;
+    s32 s0;
+
+    v = *(s32 *)(s1 + 0x1C) - 1;
+    *(s32 *)(s1 + 0x1C) = v;
+    if (v == 0) {
+        *(s32 *)(s1 + 0x1C) = 2;
+        *(u16 *)(s1 + 2) = 3;
+        func_8002D4C8(0x89D, 0);
+        for (i = 0; i < 8; i++) {
+            s0 = func_8012C588(0x2ED, s1);
+            if (s0 != 0) {
+                *(s16 *)(s0 + 0x16) = -0x10;
+                *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) + 0x20;
+                *(s16 *)(s0 + 0xE) = *(u16 *)(s0 + 0xE) - 0x18;
+                *(u16 *)(s0 + 0x12) = (rand() & 7) - 4;
+                *(u16 *)(s0 + 0x1A) = -4 - (rand() & 7);
+            }
+        }
+    } else {
+        *(u16 *)(s1 + 6) = *(u16 *)(s1 + 6) ^ 4;
+    }
+}
+
 
 void func_80186D38(void) {
 }
@@ -5158,7 +5226,36 @@ extern void func_8012C218(void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80187438);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8012B23C(s32 a0);
+extern void func_8001CA1C(void *a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+
+extern u8 D_80192E3C[];
+extern u8 D_80192E48[];
+
+void func_80187438(s32 param_1)
+{
+    s32 v0;
+
+    if ((*(s32 *)(param_1 + 0x20) = func_8012C1B8()) == 0) {
+        func_8012CAE4((void *)param_1);
+    } else {
+        func_8012B23C(param_1);
+        func_8001CA1C((void *)(*(s32 *)(param_1 + 0x20)), D_80192E3C);
+        func_8012A828(param_1, D_80192E48);
+        v0 = *(s32 *)(param_1 + 0x20);
+        *(u16 *)(param_1 + 2) = 1;
+        *(s16 *)(param_1 + 0xE) = -0x30;
+        *(u32 *)(v0 + 4) |= 0x8000000;
+        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x14) = 0xC00;
+        *(s32 *)(param_1 + 0x1C) = 0x14;
+    }
+}
+
 
 extern void func_8012C218(void*);
 extern void func_8017ECE4(void);
@@ -5518,7 +5615,32 @@ void func_80187D00(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80187D70);
+extern s32 func_8017EC7C(s32 a0);                        /* match-first, arity 1 */
+extern void func_80149020(s32 *a0);
+extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2);
+extern void func_80146CA0(void *a0);
+
+void func_80187D70(s32 a0)
+{
+    extern s16 D_801C3D10;
+    extern s16 D_801C3D12;
+    extern s16 D_801C3D14;
+    s16 *sp0 = &D_801C3D10;
+
+    *sp0 = func_8017EC7C(a0);
+    func_80149020((s32 *)a0);
+    *(s16 *)(a0 + 0x6) = func_80012C6C(*(s16 *)(a0 + 0x6), *sp0, 8);
+    *(s16 *)(a0 + 0xA) = func_80012C6C(*(s16 *)(a0 + 0xA), D_801C3D12, 8);
+    *(s16 *)(a0 + 0xE) = func_80012C6C(*(s16 *)(a0 + 0xE), D_801C3D14, 8);
+    if ((*(s16 *)(a0 + 0x6) == *sp0) &&
+        (*(s16 *)(a0 + 0xA) == D_801C3D12) &&
+        (*(s16 *)(a0 + 0xE) == D_801C3D14)) {
+        *(u8 *)(a0 + 0xDE) = 0;
+        *(u8 *)(a0 + 0xDF) = 0;
+        func_80146CA0((void *)a0);
+    }
+}
+
 
 void func_80187E48(s32 a0) {
     s32 pad[4];
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
index 6541753a5..aa1e56508 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
@@ -3160,9 +3160,43 @@ void func_8017BEBC(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017CD9C);
+#include "common.h"
+
+extern void func_8002931C(s32 a0);
+extern s32 func_8017D7D4(s32 param_1);
+
+extern u8 D_801939DC[];
+extern u8 D_80193B1C[];
+
+extern u8 *D_801274C8;
+extern void *D_801274CC;
+
+void func_8017CD9C(void)
+{
+    func_8002931C(0x3C00000);
+
+    D_801274C8 = D_801939DC;
+    D_801274CC = D_80193B1C;
+
+    func_8017D7D4(0);
+}
+
+
+extern void func_8002931C(s32 a0);
+extern u8 D_80193B80[];
+extern u8 D_80193BE4[];
+extern u8 *D_801274C8;
+extern void *D_801274CC;
+extern int func_8017D7D4(int);
+
+void func_8017CDE4(void)
+{
+    func_8002931C(0x3C00000);
+    D_801274C8 = D_80193B80;
+    D_801274CC = D_80193BE4;
+    func_8017D7D4(1);
+}
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017CDE4);
 
 
 extern void (*D_8019327C[])(void);
@@ -3595,7 +3629,24 @@ int func_8017D7D4(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D804);
+extern void (*D_80193514[])(void);
+extern s32 func_8017E8F8(s32 a0);
+extern void func_8017F4FC(void *a0);
+extern s32 func_8012BDBC(s32, s32);
+
+void func_8017D804(s32 a0) {
+    D_80193514[*(u16 *)(a0 + 0x2)]();
+    if (*(u16 *)(a0 + 0x0) != 0) {
+        func_8017E8F8(a0);
+        func_8017F4FC((void *)a0);
+        if (func_8012BDBC(a0, 0x200) == 0) {
+            *(u16 *)(a0 + 0x5C) |= 0x4000;
+        } else {
+            *(u16 *)(a0 + 0x5C) &= 0xBFFF;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D89C);
 
@@ -4131,7 +4182,63 @@ void func_8017EADC(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017EC4C);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017F4FC);
+extern u16 D_800B99DA;
+extern s32 D_801E1158;
+extern s32 D_801935B0;
+extern s32 D_801935B8;
+extern void func_8012EC04(s32 a0, s32 a1, s32 *a2);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern s32 rand(void);
+
+void func_8017F4FC(void* a0)
+{
+    s16 m[16];
+    s16 vec[4];
+    s32 obj;
+
+    if (*(s32 *)(a0 + 0xE4) & 1) {
+        if (D_800B99DA % 5 == 0) {
+            obj = func_80132EF4(a0, 0x22);
+            if (obj != 0) {
+                func_8012EC04(a0, D_801E1158, (s32 *)m);
+                func_8012F14C((s32)m, (s32)&D_801935B0, (s32)vec);
+                *(u16 *)(obj + 0x34) = 0x2001;
+                *(u16 *)(obj + 0x6) = vec[0];
+                *(u16 *)(obj + 0xA) = vec[1];
+                *(u16 *)(obj + 0xE) = vec[2];
+                *(s32 *)(obj + 0x14) = -0x60000 - ((rand() % 3) << 16);
+            }
+        }
+    }
+    if (*(s32 *)(a0 + 0xE4) & 2) {
+        if (D_800B99DA % 5 == 0) {
+            obj = func_80132EF4(a0, 0x22);
+            if (obj != 0) {
+                func_8012EC04(a0, D_801E1158, (s32 *)m);
+                func_8012F14C((s32)m, (s32)&D_801935B0, (s32)vec);
+                *(u16 *)(obj + 0x34) = 0x2001;
+                *(u16 *)(obj + 0x6) = vec[0];
+                *(u16 *)(obj + 0xA) = vec[1];
+                *(u16 *)(obj + 0xE) = vec[2];
+                *(s32 *)(obj + 0x14) = -0x60000 - ((rand() % 3) << 16);
+            }
+        }
+        if (D_800B99DA % 6 == 0) {
+            obj = func_80132EF4(a0, 0x22);
+            if (obj != 0) {
+                func_8012EC04(a0, D_801E1158, (s32 *)m);
+                func_8012F14C((s32)m, (s32)&D_801935B8, (s32)vec);
+                *(u16 *)(obj + 0x34) = 0x2001;
+                *(u16 *)(obj + 0x6) = vec[0];
+                *(u16 *)(obj + 0xA) = vec[1];
+                *(u16 *)(obj + 0xE) = vec[2];
+                *(s32 *)(obj + 0x14) = -0x60000 - ((rand() % 3) << 16);
+            }
+        }
+    }
+}
+
 
 
 extern void (*D_801935C8[])(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 993f149c1..2dba506ee 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
@@ -4859,7 +4859,62 @@ s32 func_801825D8(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_801825EC);
+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_801A249C;
+extern s32 func_801399F0(s32 a0);
+extern s32 D_801B1B54;
+extern void func_80174714(void);
+extern void func_801823FC(s32 a0);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern u8 D_801889F8[];
+extern u8 D_801A08B4[];
+extern s16 D_801B1714;
+extern s16 D_801B1708;
+extern s16 D_801B1724;
+extern s16 D_801B1744;
+extern s16 D_801B1710;
+extern s32 D_801270C8;
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void func_8016F388();
+extern void func_80180D84(void *arg0);
+extern u8 D_80188E40[];
+
+void func_801825EC(s32 param_1)
+{
+    u16 var;
+
+    if ((func_80029178(0x120) & 0xFF) != 0) {
+        func_80029124(0x120, 0);
+        func_8012A828(param_1, &D_801A249C);
+    }
+
+    if (func_801399F0(D_801B1B54) != 0) {
+        func_80174714();
+        func_801823FC(D_801B1B54);
+        *(u16 *)(param_1 + 2) = 3;
+        func_8012E8E0(param_1, (s32)&D_801889F8);
+        func_8012A828(param_1, &D_801A08B4);
+        *(s32 *)(param_1 + 0x1C) = 0x3C;
+        var = (*(u16 *)&D_801B1714);
+        *(u16 *)(param_1 + 0x34) = 0;
+        *(u16 *)(param_1 + 0xDC) = 0;
+        *(u16 *)(param_1 + 0xDE) = 0;
+        D_801B1708 = 0;
+        D_801B1724 = 0;
+        D_801B1744 = 1;
+        D_801B1710 = var + 1;
+        if (D_801B1710 >= 4) {
+            func_80180D84((void *)param_1);
+        } else {
+            func_80178B18(param_1, (s32)&D_80188E40);
+            func_8016F388();
+            D_801270C8 = 2;
+        }
+    }
+}
+
 
 extern s32 func_8012BEE8(s32 arg);
 extern s16 D_80126B66;
@@ -4931,7 +4986,27 @@ void func_80182850(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_801828A0);
+extern void func_8012AD80(s32 a0);
+extern s32 D_80188EF4;
+extern void func_80015D4C(s32 a0, s32 a1, s32 a2, s32 a3, u8 a4, u8 a5, u8 a6, u16 a7, u16 a8);
+
+void func_801828A0(s32 a0) {
+    s32 s0;
+    register s32 sum __asm__("$2");
+    s32 x;
+
+    s0 = a0;
+    func_8012AD80(s0);
+    *(u16 *)(*(s32 *)(s0 + 0x20) + 0x10) += D_80188EF4;
+    sum = *(s32 *)(s0 + 0x1C) + 4;
+    x = sum;
+    *(s32 *)(s0 + 0x1C) = x;
+    if (x >= 0x100) {
+        x = 0xFF;
+    }
+    func_80015D4C(-0xA0, -0x78, 0x140, 0xF0, x, x, x, 0x20, 1);
+}
+
 
 s32 func_80182938(u8 *param_1)
 {
@@ -4941,7 +5016,19 @@ s32 func_80182938(u8 *param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_80182950);
+void func_80182950(u8 *param_1)
+{
+    s32 x;
+
+    x = *(s32 *)(param_1 + 0x1C) - 0x10;
+    *(s32 *)(param_1 + 0x1C) = x;
+    if (x < 0) {
+        x = 0;
+    }
+    x &= 0xFF;
+    func_80015D4C(-0xA0, -0x78, 0x140, 0xF0, x, x, x, 0x20, 1);
+}
+
 
 extern int func_80178970(void);
 extern void func_80178D18(void);
@@ -5101,7 +5188,47 @@ void func_80182C74(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_80182D4C);
+extern void func_8012C1B8(void);   /* fleet-modal spelling, cast at call */
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern void (*D_80189094[])(void);
+extern void (*D_801890A4[])(void);
+
+void func_80182D4C(void *a0)
+{
+    s32 v0;
+    s32 v1;
+    s16 v;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C810(v0, ((s32 *)D_80189094)[*(s16 *)((s32)a0 + 0x70)]);
+
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(s32 *)(v1 + 0x4) |= 0x8000;
+
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)(v1 + 0x2C) |= 0x10;
+
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)(v1 + 0x1C) = 0xC00;
+    *(u16 *)(v1 + 0x1A) = 0xC00;
+    *(u16 *)(v1 + 0x18) = 0xC00;
+
+    *(s16 *)((s32)a0 + 0x2) = 1;
+    v = *(s16 *)((s32)a0 + 0x70);
+    func_8012E8E0((s32)a0, (s32)D_801890A4 + (v << 3));
+
+    *(s32 *)((s32)a0 + 0x1C) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_80182E14);
 
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8017AE2C.c b/src/ov_SC06_033/ov_SC06_033_jr_8017AE2C.c
index 5bbcda5bd..b030d680e 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8017AE2C.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8017AE2C.c
@@ -3429,7 +3429,41 @@ s32 param_1;
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017AE2C", func_8017C120);
+extern s32 func_8004787C(s32 a0);
+extern void func_800139C8(s32 a0, void *a1, void *a2);
+extern void func_80146E90(s32 *a0, s32 a1);
+extern s16 D_80195254;
+
+void func_8017C120(param_1)
+int param_1;
+{
+    int addr;
+    int tmp;
+    int iVar1;
+    int cnt;
+    s16 *p;
+    u16 local[4];
+
+    addr = *(int *)(param_1 + 0x20);
+    tmp = *(int *)(param_1 + 0x2C) + 0xE3;
+    *(int *)(param_1 + 0x2C) = tmp;
+    iVar1 = func_8004787C(tmp);
+    p = &D_80195254;
+    if (iVar1 < 0) {
+        iVar1 = iVar1 + 0xFF;
+    }
+    *p = (s16)(iVar1 >> 8);
+    func_800139C8(*(short *)(addr + 0x14), p - 2, local);
+    *(short *)(param_1 + 6) = *(u16 *)(param_1 + 0x12) + local[0];
+    *(short *)(param_1 + 0xE) = *(u16 *)(param_1 + 0x1A) + local[2];
+    cnt = *(int *)(param_1 + 0x1C) - 1;
+    *(int *)(param_1 + 0x1C) = cnt;
+    if (cnt == -1) {
+        func_80146E90(param_1, 0x10);
+        *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+    }
+}
+
 
 extern s32 func_80146E98(s32 a0);
 extern void func_80146C3C();
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
index 6ef33854e..e64969355 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
@@ -3429,7 +3429,46 @@ void func_8017D6A4(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017D6CC);
+#ifndef BFM_ENGINE_TYPES_H
+
+#endif
+
+extern void func_8012A018(s32 a0, s32 a1);
+extern void func_8012A094(s32 a0);
+extern void func_8017DC10(void *a0);
+extern void func_8017D7A4(void *a0);
+
+void func_8017D6CC(void) {
+
+    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 Blk8 D_80126940;
+    extern Blk8 D_801274E8;
+    extern Blk8 D_801274F0;
+
+    D_80126954 = 0x190;
+    D_8012695C = 0x4b0;
+    D_80126968 = 0x2aa;
+    D_8012696A = 0x800;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017D7A4, 0);
+    func_8012A094((s32)D_80126948);
+    D_801274E8 = D_80126940;
+    *(s16 *)&D_801274F0 = 0;
+    func_8017DC10(D_80126948);
+    func_8017D7A4(D_80126948);
+}
+
 
 
 extern void (*D_801952F4[])(void);
@@ -3439,7 +3478,104 @@ void func_8017D7A4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017D7E0);
+#include "common.h"
+
+void func_8017D7E0(s32 param_1) {
+    typedef struct { s16 x0, x1, x2, x3; } UnalignedShortBlock;
+
+    extern u16 func_80148800(s32 *a0);
+    extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2);
+    extern void func_8017DA78(s32 a0, s16 *a1);
+    extern void func_8017DC18(void);
+    extern void func_8017DD48(void);
+    extern void func_8017DD88(void);
+
+    extern s32 D_80126B58;
+    extern UnalignedShortBlock D_80126940;
+    extern s16 D_801274E8;
+    extern s16 D_801274EA;
+    extern s16 D_801274EC;
+    extern s16 D_801274F0;
+    extern s16 D_801952F8[];
+
+    UnalignedShortBlock sp10;
+    s16 lo;
+    s16 hi;
+    s16 zc;
+    s16 v2E;
+    s16 v32;
+    s32 idx;
+    s16 *p;
+    s16 *q;
+
+    if (func_80148800(&D_80126B58) & 3) {
+        idx = (*(u8 *)(param_1 + 5) + 1) & 1;
+        *(u8 *)(param_1 + 5) = idx;
+        *(s32 *)(param_1 + 0x14) = D_801952F8[idx];
+    }
+
+    sp10 = D_80126940;
+
+    if (sp10.x2 > 0xF80) {
+        sp10.x2 = 0xF80;
+    }
+
+    if (sp10.x2 < 0x240) {
+        lo = -0x1C0; hi = 0x1C0; zc = -0x100; v2E = 0; v32 = 0xA0;
+    } else if (sp10.x2 < 0x6C0) {
+        lo = -0x1C0; hi = 0x1C0; zc = -0x100; v2E = 0; v32 = 0x40;
+    } else if (sp10.x2 < 0xC00) {
+        lo = 0; hi = 0; zc = -0x100; v2E = 0; v32 = 0;
+    } else {
+        lo = -0x140; hi = 0x140; zc = -0x1000; v2E = 0; v32 = 0;
+    }
+
+    p = &D_801274F0;
+    switch (*p) {
+    case 0:
+        zc = -0x100;
+        if (sp10.x2 > 0xAC0) {
+            zc = -0x1000;
+            *(s16 *)(param_1 + 0x20) = 0xE3;
+            *p = 1;
+            func_8017DD48();
+        }
+        break;
+    case 1:
+        zc = -0x1000;
+        if (sp10.x2 < 0x9C0) {
+            zc = -0x100;
+            *(s16 *)(param_1 + 0x20) = 0x2AA;
+            *p = 0;
+            func_8017DD88();
+        }
+        break;
+    }
+
+    if (sp10.x0 < lo) {
+        sp10.x0 = lo;
+    } else if (sp10.x0 > hi) {
+        sp10.x0 = hi;
+    }
+    if (sp10.x1 < zc) {
+        sp10.x1 = zc;
+    }
+
+    q = &D_801274E8;
+    *q = func_80012C6C((s32)*q, (s32)sp10.x0, 8);
+    D_801274EA = sp10.x1;
+    D_801274EC = sp10.x2;
+    if ((u16)sp10.x2 >= 0xAC1 && (u16)sp10.x2 < 0xC00) {
+        *(s32 *)(param_1 + 0x14) = 0x4B0;
+    } else {
+        *(s32 *)(param_1 + 0x14) = D_801952F8[*(u8 *)(param_1 + 5)];
+    }
+    *(s16 *)(param_1 + 0x2E) = v2E;
+    *(s16 *)(param_1 + 0x32) = v32;
+    func_8017DA78(param_1, &D_801274E8);
+    ((void (*)(s32, s16 *))func_8017DC18)(param_1, &D_801274E8);
+}
+
 
 
 // @class: schedule
@@ -3565,7 +3701,19 @@ void func_8017DD48(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017DD88);
+extern u8 D_801202A0[];
+
+void func_8017DD88(void) {
+    s32 i;
+
+    for (i = 0; i < 0x60; i++) {
+        u8 *rec = &D_801202A0[i * 0x10C];
+        if (*(u16 *)rec == 0x315) {
+            *(u16 *)(rec + 0x104) = 0;
+        }
+    }
+}
+
 
 
 extern void (*D_801952FC[])(void);
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
index 964740bb0..53d7a83f3 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -4629,7 +4629,27 @@ void func_8017F3FC(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F464);
+extern void func_8017F4F8(s32 a0);
+
+void func_8017F464(s32 a0)
+{
+    s16 v1;
+
+    v1 = *(s16 *)(a0 + 0x100);
+    switch (v1) {
+    case 0x3c:
+        func_8017F4F8(1);
+        break;
+    case 0x3f:
+        func_8017F4F8(0);
+        break;
+    case 0x60:
+        *(s16 *)(a0 + 0x100) = 0;
+        break;
+    }
+    *(u16 *)(a0 + 0x100) = *(u16 *)(a0 + 0x100) + 1;
+}
+
 
 extern u16 D_8018657C[];
 extern u16 D_8018657E[];
@@ -4650,7 +4670,19 @@ s32 a0;
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F554);
+extern void func_8017F958(s32 a0);
+extern s16 D_801CC230;
+extern void func_8012A828();
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_8017F554(s32 a0)
+{
+    s32 s0 = a0;
+    func_8017F958(0);
+    func_8012A828(s0, &D_801CC230);
+    func_8012AD44((s32 *)s0, 2);
+}
+
 
 extern s32 func_80132EF4();
 extern void func_8012A828();
@@ -5098,7 +5130,46 @@ void func_8018096C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801809A4);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void D_801B9C88;
+extern void D_80186550;
+extern void func_8017F888(s32 *a0, s32 *a1);
+extern s32 func_80143970(s32 a0);
+extern void D_801BCCAC;
+extern void func_8012A828();
+extern void func_8017F4F8(s32 a0);
+extern void func_8017EE40(s32 a0);
+
+void func_801809A4(void *a0) {
+    s32 ret;
+    s32 p;
+
+    ret = func_8012C1B8();
+    *(s32 *)((u8 *)a0 + 0x20) = ret;
+    if (ret == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(ret, (s32)&D_801B9C88);
+
+    p = *(s32 *)((u8 *)a0 + 0x20);
+    *(u16 *)((u8 *)p + 0x2C) |= 0x10;
+    func_8017F888((s32 *)a0, (s32 *)&D_80186550);
+
+    func_80143970((s32)a0);
+
+    func_8012A828(a0, &D_801BCCAC);
+
+    func_8017F4F8(0);
+
+    func_8017EE40((s32)a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180A3C);
 
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 cf1a80931..6319efdc0 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -6083,7 +6083,22 @@ void func_801829F0(s32* a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80182AD4);
+extern u8 D_801202A0[];
+
+s32 func_80182AD4(s32 a0) {
+    s32 i;
+    u8 *v1;
+
+    v1 = D_801202A0;
+    for (i = 0; i < 0x60; i++) {
+        if (*(u16 *)v1 == 0x306) {
+            return (s32) v1;
+        }
+        v1 += 0x10C;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80182B10);
 
@@ -6328,7 +6343,97 @@ void func_801830D8(s32 *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_801831FC);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(s32 a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012C51C(void *a0, s32 a1);
+extern void func_80132288(s32 *a0, s32 *a1, s32 a2);
+extern void GsMapModelingData(u32 *p);
+extern s16 D_8019FD68;
+extern u8 D_8019F0F0[];
+extern s32 D_8019F0E0[];
+extern u32 *D_80197DCC;
+extern s32 D_80186B14;
+extern void (*D_8018A4B4)(void *);
+
+void func_801831FC(s32 param_1)
+{
+    /* the 0x10..0x20 sub-block handed to func_8012C51C — same spelling as func_801830D8 */
+    struct {
+        u16 f0;  /* 0x10 */
+        s16 f2;  /* 0x12 */
+        u16 f4;  /* 0x14 */
+        u16 f6;  /* 0x16 */
+        u16 f8;  /* 0x18 */
+        u16 fA;  /* 0x1A */
+        u16 fC;  /* 0x1C */
+        u16 fE;  /* 0x1E */
+        s32 f10; /* 0x20 */
+    } sub;
+    s16 i;      /* ONE pseudo: the loop counter AND the 0x200/0x600 value -> $s0 in both arms */
+    s16 *pp;
+    u32 **pd;   /* &D_80197DCC held in a call-saved reg across GsMapModelingData */
+    s32 o;
+    s32 t;
+
+    if (*(s16 *)(param_1 + 0x70) < 0) {
+        sub.f6 = 0x352;
+        sub.fA = 0;
+        sub.fC = 0;
+        sub.f10 = *(s16 *)(param_1 + 0xFC);
+        sub.f0 = *(u16 *)(param_1 + 6);
+        sub.f2 = -0x208;
+        sub.f4 = *(u16 *)(param_1 + 0xE);
+        for (i = 0; i < 0x13; i++) {
+            sub.f8 = i;
+            sub.fE = D_8019FD68++;
+            func_8012C51C(&sub, param_1);
+        }
+        if (*(s16 *)(param_1 + 0x10A) == 0) {
+            pd = &D_80197DCC;
+            GsMapModelingData(*pd);
+            func_80132288(D_8019F0E0, (s32 *)&D_8018A4B4, (s32)*pd);
+        }
+        pp = (s16 *)(param_1 + 0xF0);
+        /* both stores duplicated in each arm: cross-jump merges only the last 3 ins */
+        if (*(s16 *)(param_1 + 0xFC) == 0) {
+            pp[*(s16 *)(param_1 + 0x10A) * 2 + 1] = 0x38;
+            pp[*(s16 *)(param_1 + 0x10A) * 2] = 0x600;
+        } else {
+            pp[*(s16 *)(param_1 + 0x10A) * 2 + 1] = 0x38;
+            pp[*(s16 *)(param_1 + 0x10A) * 2] = 0x200;
+        }
+        *(s16 *)(param_1 + 2) = 1;
+    } else {
+        o = func_8012C1B8();
+        *(s32 *)(param_1 + 0x20) = o;
+        if (o == 0) {
+            func_8012CAE4(param_1);
+            return;
+        }
+        func_8001C214(o, (s32)&D_80197DCC);
+        func_8001D0E8(*(s32 *)(param_1 + 0x20), 0x7FFF, 0x7FFF);
+        func_8012A828(param_1, &D_80186B14);
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0xA0;
+        *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x80) =
+            (s32)&D_8019F0F0[*(s16 *)(param_1 + 0xFC) * 0x38];
+        i = 0x200;
+        if (*(s32 *)(param_1 + 0xDC) == 0) {
+            i = 0x600;
+        }
+        t = *(s32 *)(param_1 + 0x20);
+        *(s16 *)(t + 0x1C) = i;
+        *(s16 *)(t + 0x18) = i;
+        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x1A) = 0;
+        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(s16 *)(param_1 + 0x70) * 0xE3;
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10;
+        *(s32 *)(param_1 + 0x1C) = 8;
+        *(s16 *)(param_1 + 2) = 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80183458);
 
@@ -6525,7 +6630,50 @@ void func_80183AAC(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80183F28);
+
+
+
+
+
+
+
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_8012CBF4(s32 a0);
+extern void func_8012AD80(s32 a0);
+extern void func_80183FE0(s32 p);
+extern void func_8012C218(void *arg0);
+
+void func_80183F28(s32 param_1)
+{
+    s32 iVar1;
+
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + *(u16 *)(param_1 + 0xFE);
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + *(u16 *)(param_1 + 0x100);
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) + *(u16 *)(param_1 + 0x102);
+
+    iVar1 = func_8012BEE8(param_1);
+    if (iVar1 != 0) {
+        goto LAB_80183FAC;
+    }
+    if (*(s16 *)(param_1 + 0x70) != 0) {
+        goto LAB_80183FBC;
+    }
+    iVar1 = func_8012CBF4(param_1);
+    if (iVar1 == 0) {
+        goto LAB_80183FC4;
+    }
+LAB_80183FAC:
+    func_8012C218((void *)param_1);
+    return;
+LAB_80183FBC:
+    func_8012AD80(param_1);
+LAB_80183FC4:
+    func_80183FE0(param_1);
+}
+
 
 #define gte_SetRotMatrix_1(r0) __asm__ __volatile__ ( \
     "lw $12, 0( %0 );"   \
diff --git a/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c b/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
index fccd0283b..7b21fb824 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
@@ -2741,7 +2741,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_006/nonmatchings/ov_SC07_006_jr_801457A4", func_8014C1A0);
+extern void func_8014C1C8(s32 arg0, s32 arg1, void *arg2);
+extern s16 (*D_8018C04C[])();
+
+void func_8014C1A0(s32 arg0, s32 arg1) {
+    func_8014C1C8(arg0, arg1, D_8018C04C);
+}
+
 
 DEFINE_func_8014C1C8()  /* dedup: shared engine-core @0x8014c1c8 (src/shared) */
 
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 f6ae02593..0674738c8 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c
@@ -5081,7 +5081,45 @@ void func_80182158(s32 x)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182268);
+extern s32 D_801BFCDC;
+extern void (*D_8018E4B0[])(void);
+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_80182268(s32 param_1, s32 param_2) {
+    s32 work;
+    s32 mod;
+    s32 a;
+    s32 d;
+
+    func_8017D8A4(D_801BFCDC + 0x60, D_8018E4B0, D_8018E4B0 + 3, param_2, 1);
+    if (param_2 <= 0) {
+        return;
+    }
+    work = ((s32 (*)())func_80143C74)(param_1, 0);
+    if (work == 0) {
+        return;
+    }
+    mod = rand() % ((param_2 * 160) >> 12);
+    a = rand() & 0x7F;
+    d = *(u16 *)(D_801BFCDC + 0x60) - 0x40;
+    *(u16 *)(work + 0xE) = *(u16 *)(work + 0xE) - (d + a);
+    __asm__("" ::: "memory");
+    *(u16 *)(work + 0xA) = *(u16 *)(work + 0xA) + (*(u16 *)(D_801BFCDC + 0x62) + mod);
+    __asm__("" ::: "memory");
+    *(u16 *)(work + 6) = *(u16 *)(work + 6) + (*(u16 *)(D_801BFCDC + 0x64) + mod);
+    *(u32 *)(work + 0x18) = ((rand() & 0xFF) - 0x80) << 10;
+    *(u16 *)(work + 0x16) = -((rand() & 3) + 4);
+    *(u32 *)(work + 0x10) = (rand() & 0xFF) << 11;
+    func_80128EA8(*(u32 *)(work + 0x20), (void *)(work + 0xD0), &D_8018DF10);
+    func_8012C658(0x3AC, 6, work);
+    func_8012C658(0x3AC, 6, work);
+}
+
 
 
 /* func_801823F8 — banked from the S40 wave-1 draft.
@@ -5184,6 +5222,119 @@ void func_80182B8C(s32 param_1, s32 param_2) {
 
 INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182D4C);
 
-INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182F3C);
+#include "common.h"
+
+extern void func_800599B8(u16 *);
+extern void func_8017FDF8(s32 a0);
+extern void func_80181148(s32 a0);
+extern void func_8017DC1C(s32 a0);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_80143994(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8017F3D4(s32 a0, s32 a1);
+extern void func_80182D4C(s32 a0, s32 a1);
+extern void func_80182B8C(s32 a0, s32 a1);
+extern void func_801826E0(s32 a0, s32 a1);
+extern void func_80182268(s32 a0, s32 a1);
+extern void func_80182000(s32 a0, s32 a1);
+extern void func_80181C74(s32 a0, s32 a1);
+extern void func_8017D8A4(s32 a0, void *a1, void *a2, s32 a3, s32 a4);
+extern void func_8012B23C(s32 a0);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern u8 *func_8012913C(s32 a0);
+extern void func_800233CC(void *, unsigned short);
+extern void func_8001CD50(s32 a0, s32 a1);
+extern s32 rand(void);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+extern u8 D_8018DFB0[];
+extern u16 D_8018E254[];
+extern s32 D_8018E61C;
+extern s32 D_801BFCB4;
+extern s32 D_801BFCBC;
+extern s32 D_801BFCC4;
+extern s32 D_801BFCD4;
+extern u8 D_8018E3A8[];
+extern u8 D_8018E27C[];
+extern u8 D_8018E288[];
+extern u8 D_8018E294[];
+extern u8 D_8018E2A0[];
+extern u8 D_8018E2DC[];
+extern u8 D_8018E2E8[];
+extern u8 D_8018E2F4[];
+extern u8 D_8018E300[];
+extern u8 D_801F6180[];
+extern u8 D_801F6140[];
+extern s32 D_801F61C0[];
+
+void func_80182F3C(s32 a0)
+{
+    u8 *p;
+    s32 i;
+
+    ((void (*)(u8 *, u16 *))func_800599B8)(D_8018DFB0, D_8018E254);
+    func_8017FDF8(0);
+    func_80181148(0);
+    func_8017DC1C(0);
+    if (func_8012C354(a0, (s32)&D_8018E61C) == 0) {
+        return;
+    }
+    *(s8 *)(a0 + 0xC0) = 1;
+    *(s32 *)(a0 + 0xB4) = -1;
+    func_80143994(a0, 0x7000);
+    func_8012A828(a0, &D_801BFCB4);
+    func_8017F3D4(a0, 0);
+    func_80182D4C(a0, 0);
+    func_80182B8C(a0, 0);
+    func_801826E0(a0, 0);
+    func_80182268(a0, 0);
+    func_8017D8A4(D_801BFCD4, D_8018E3A8, &D_8018E3A8[0xB4], 0, 1);
+    func_80182000(a0, 0);
+    func_80181C74(a0, 0);
+    { s32 m = (s32)D_8018E2DC; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCC4 + 0x84, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E2E8; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCC4 + 0x90, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E2F4; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCC4 + 0x9C, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E2DC; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x84, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E2E8; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x90, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E2F4; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x9C, (void *)m, (void *)(m + 0x30), 0, 1); }
+    func_8017D8A4(D_801BFCBC + 0xA8, D_8018E300, D_8018E300 + 0x30, 0, 1);
+    { s32 m = (s32)D_8018E27C; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x3C, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E288; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x48, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E294; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCBC + 0x54, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E27C; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCB4 + 0x3C, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E288; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCB4 + 0x48, (void *)m, (void *)(m + 0x30), 0, 1); }
+    { s32 m = (s32)D_8018E294; __asm__ __volatile__("" : "=r"(m) : "0"(m)); func_8017D8A4(D_801BFCB4 + 0x54, (void *)m, (void *)(m + 0x30), 0, 1); }
+    func_8017D8A4(D_801BFCB4 + 0x60, D_8018E2A0, D_8018E2A0 + 0x30, 0, 1);
+    *(s16 *)(a0 + 0x2) = 1;
+    func_8012B23C(a0);
+    *(s8 *)(a0 + 0x75) = 2;
+    func_8001D0E8(*(s32 *)(a0 + 0x20), 0x280, 0x1E0);
+    *(s16 *)(a0 + 0x102) = 0x1C7;
+    *(s32 *)(a0 + 0x1C) = 0xF;
+    p = func_8012913C(0x78);
+    if (p != 0) {
+        *(s32 *)(a0 + 0xCC) = (s32)p;
+        func_800233CC(D_801F6180, 0x80);
+        *(u16 *)(p + 0x6) = *(u16 *)(a0 + 0x6) - 0x20;
+        *(u16 *)(p + 0xA) = *(u16 *)(a0 + 0xA) - 0xA8;
+        *(u16 *)(p + 0xE) = *(u16 *)(a0 + 0xE);
+        func_8001CD50(*(s32 *)(p + 0x20), (s32)D_801F6180);
+    }
+    p = func_8012913C(0x78);
+    if (p != 0) {
+        *(s32 *)(a0 + 0xD0) = (s32)p;
+        func_800233CC(D_801F6140, 0xA0);
+        *(u16 *)(p + 0x6) = *(u16 *)(a0 + 0x6) - 0x28;
+        *(u16 *)(p + 0xA) = *(u16 *)(a0 + 0xA) - 0xA8;
+        *(u16 *)(p + 0xE) = *(u16 *)(a0 + 0xE);
+        func_8001CD50(*(s32 *)(p + 0x20), (s32)D_801F6140);
+        *(s32 *)(p + 0x2C) = 1;
+    }
+    for (i = 0; i < 16; i++) {
+        D_801F61C0[i] = rand() & 0x7FFF;
+    }
+    func_8002D4C8(0xBB7, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80183374);
diff --git a/src/ov_SC07_006/ov_SC07_006_jr_80183814.c b/src/ov_SC07_006/ov_SC07_006_jr_80183814.c
index 9b621d207..704d91573 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_80183814.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_80183814.c
@@ -5716,7 +5716,39 @@ void func_80189D98(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_80183814", func_80189DB8);
+extern void func_80143C74(s32, s32);
+extern void func_8012C218(void *a0);
+extern void func_8012CBCC(s32);
+
+void func_80189DB8(void *a0) {
+    s32 s1;
+
+    if (*(s32 *)((s32)a0 + 0x1C) == 0x1E) {
+        s1 = ((s32 (*)(s32, s32))func_80143C74)((s32)a0, 0);
+        if (s1 != 0) {
+            *(u16 *)(s1 + 0x6) = *(u16 *)((s32)a0 + 0x6) + (*(u16 *)((s32)a0 + 0x12) << 2);
+            *(u16 *)(s1 + 0xA) = *(u16 *)((s32)a0 + 0xA) + (*(u16 *)((s32)a0 + 0x16) << 2);
+            *(u16 *)(s1 + 0xE) = *(u16 *)((s32)a0 + 0xE) + (*(u16 *)((s32)a0 + 0x1A) << 2);
+        }
+    }
+    *(s32 *)((s32)a0 + 0x1C) = *(s32 *)((s32)a0 + 0x1C) - 1;
+    if ((((s32 (*)(s32))func_8012CBCC)((s32)a0) & 0x2000) != 0 ||
+        *(s32 *)((s32)a0 + 0x1C) == 0) {
+        func_8012C218((void *)a0);
+    } else {
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) =
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) - 0x88;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) =
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) - 0x88;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) =
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) + 0x200;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) + 0x100;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) =
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) + 0x80;
+    }
+}
+
 
 extern void func_8012C218(void *a0);
 extern void func_8012CBCC(s32 a0);