diff --git a/src/800.c b/src/800.c
index 394bc9391..18ee2c6fa 100644
--- a/src/800.c
+++ b/src/800.c
@@ -628,7 +628,40 @@ INCLUDE_ASM("asm/nonmatchings/800", func_80014588);
 
 INCLUDE_ASM("asm/nonmatchings/800", func_800145EC);
 
-INCLUDE_ASM("asm/nonmatchings/800", func_800146B0);
+void func_800146B0(s32 mode) {
+    extern void GsInitGraph2(s32 w, s32 h, s32 mode, s32 a3, s32 st);
+    extern void func_80053EEC(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80059234(s32);
+    extern void func_80053218(void);
+    extern void func_80014774(void);
+    extern void func_800147B8(void);
+    extern u8 D_80062A3C[];
+    extern u8 D_80062A3E[];
+    extern u8 D_80062A40[];
+    extern u16 D_800AF7BC;
+    extern u16 D_800AF7BE;
+    extern u16 D_800AF7C0;
+    s32 off;
+
+    off = (mode & 0xFFFF) * 6;
+
+    D_800AF7BC = *(u16 *) (D_80062A3C + off);
+    D_800AF7BE = *(u16 *) (D_80062A3E + off);
+    D_800AF7C0 = *(u16 *) (D_80062A40 + off);
+
+    GsInitGraph2(D_800AF7BC, D_800AF7BE, D_800AF7C0 | 4, 0, 0);
+
+    if (D_800AF7BE == 0x1E0) {
+        func_80053EEC(0, 0, 0, 0);
+    } else {
+        func_80053EEC(0, D_800AF7BE, 0, 0);
+    }
+
+    func_80059234(1);
+    func_80053218();
+    func_80014774();
+    func_800147B8();
+}
 
 
 extern void func_80059888(void *a0, s32 a1, s32 a2, s32 a3);
@@ -2166,7 +2199,38 @@ void func_80016940(s32 a0) {
     func_80016450(param, 0);
 }
 
-INCLUDE_ASM("asm/nonmatchings/800", func_80016978);
+extern u8 D_800AF630[];
+extern u8 D_80062BA0[];
+extern s32 D_800B9A18;
+extern u16 D_800AF7CE;
+extern void func_80016450(s32 a0, s32 a1);
+
+s32 func_80016978(s32 arg0) {
+    register u32 zr __asm__("$0");
+    register s32 v1 __asm__("$3");
+    s32 x = arg0 + zr;
+    u8 *s0 = D_800AF630;
+    s32 mask = arg0 & 3;
+    u32 raw;
+    u32 a0;
+    u32 v0;
+
+    if (mask == 0) {
+        v1 = D_80062BA0[D_800B9A18];
+    } else {
+        v1 = D_80062BA0[mask];
+    }
+    D_800AF7CE = D_800AF7CE + v1;
+    __asm__ __volatile__("" ::: "memory");
+    raw = *(u16 *)&s0[0x19E];
+    a0 = raw + zr;
+    if (a0 >= 0xFFU) {
+        a0 = 0xFF;
+    }
+    v0 = ((x & 0xFFFFU) < 4U) ? 0xFF - a0 : a0;
+    func_80016450(v0 & 0xFF, 0);
+    return *(u16 *)&s0[0x19E] >= 0xFF;
+}
 
 INCLUDE_ASM("asm/nonmatchings/800", func_80016A3C);
 
@@ -12277,7 +12341,40 @@ INCLUDE_ASM("asm/nonmatchings/800", func_8002E818);
 
 INCLUDE_ASM("asm/nonmatchings/800", func_8002E8DC);
 
-INCLUDE_ASM("asm/nonmatchings/800", func_8002E94C);
+void func_8002E94C(s32 a0)
+{
+    extern u16 D_800A4E8E;
+    extern u16 D_800A4E8C;
+    extern u8  D_800A4EE6;
+    extern u16 D_800A4EE4;
+    extern u16 D_800A4EE2;
+    extern u16 D_8006A9EC[];
+    extern void func_8002EAB0(void);
+    register u8 *a1 __asm__("$5");
+    u8 fl;
+    u8 clr;
+    u16 v;
+
+    if ((D_800A4E8E & 0x4) != 0 && D_800A4E8C == 0x3E && (D_800A4E8E & 0x10) != 0) {
+        func_8002EAB0();
+    }
+
+    a1 = &D_800A4EE6;
+    fl = *a1;
+    if (fl & 0x4) {
+        clr = fl & 0xFB;
+        *a1 = clr;
+        if (!(fl & 0x2)) {
+            if ((u16)a0 >= 5) {
+                a0 = 4;
+            }
+            D_800A4EE4 = 0x4000;
+            v = D_8006A9EC[(u16)a0];
+            *a1 = clr | 0x1;
+            D_800A4EE2 = v;
+        }
+    }
+}
 
 INCLUDE_ASM("asm/nonmatchings/800", func_8002EA10);
 
diff --git a/src/800c3.c b/src/800c3.c
index 2f4f46e2a..6413da6eb 100644
--- a/src/800c3.c
+++ b/src/800c3.c
@@ -182,7 +182,61 @@ INCLUDE_ASM("asm/nonmatchings/800c3", func_8005D244);
 
 INCLUDE_ASM("asm/nonmatchings/800c3", func_8005D33C);
 
-INCLUDE_ASM("asm/nonmatchings/800c3", func_8005D410);
+extern void* (*D_80072970)(void);
+
+__asm__(
+    "\t.set\tnoreorder\n"
+    ".set noreorder\n"
+    "\t.globl\tfunc_8005D410\n"
+    "func_8005D410:\n"
+    "lui $v0, %hi(D_80072970)\n"
+    "lw $v0, %lo(D_80072970)($v0)\n"
+    "addiu $sp, $sp, -32\n"
+    "sw $s0, 16($sp)\n"
+    "addu $s0, $a1, $zero\n"
+    "sw $s1, 20($sp)\n"
+    "sw $ra, 24($sp)\n"
+    "jalr $v0\n"
+    "addu $s1, $a2, $zero\n"
+    "bgez $s0, 1f\n"
+    "addu $v1, $v0, $zero\n"
+    "lbu $v0, 234($v1)\n"
+    "j 4f\n"
+    "nop\n"
+    "1:\n"
+    "lbu $v0, 234($v1)\n"
+    "nop\n"
+    "slt $v0, $s0, $v0\n"
+    "beq $v0, $zero, 3f\n"
+    "sll $v0, $s0, 3\n"
+    "lw $v1, 8($v1)\n"
+    "bgez $s1, 2f\n"
+    "addu $v1, $v1, $v0\n"
+    "lbu $v0, 0($v1)\n"
+    "j 4f\n"
+    "nop\n"
+    "2:\n"
+    "lbu $v0, 0($v1)\n"
+    "nop\n"
+    "slt $v0, $s1, $v0\n"
+    "beq $v0, $zero, 4f\n"
+    "addu $v0, $zero, $zero\n"
+    "lw $v0, 4($v1)\n"
+    "nop\n"
+    "addu $v0, $v0, $s1\n"
+    "lbu $v0, 0($v0)\n"
+    "j 4f\n"
+    "nop\n"
+    "3:\n"
+    "addu $v0, $zero, $zero\n"
+    "4:\n"
+    "lw $ra, 24($sp)\n"
+    "lw $s1, 20($sp)\n"
+    "lw $s0, 16($sp)\n"
+    "jr $ra\n"
+    "addiu $sp, $sp, 32\n"
+    ".set reorder\n"
+);
 
 INCLUDE_ASM("asm/nonmatchings/800c3", func_8005D4B8);
 
@@ -529,7 +583,17 @@ INCLUDE_ASM("asm/nonmatchings/800c3", func_8005F450);
 
 INCLUDE_ASM("asm/nonmatchings/800c3", func_8005F6CC);
 
-INCLUDE_ASM("asm/nonmatchings/800c3", func_8005F704);
+extern u8 D_80078A48;
+
+s32 func_8005F704(s32 arg0) {
+    s32 var_v0 = (s32)&D_80078A48;
+    if (arg0 & 0xF0) {
+        var_v0 += 0xF0;
+    }
+    return var_v0;
+}
+
+__asm__(".word 0x00000000\n");
 
 INCLUDE_ASM("asm/nonmatchings/800c3", func_8005F728);
 
diff --git a/src/md_MAIN_013/md_MAIN_013.c b/src/md_MAIN_013/md_MAIN_013.c
index f853a7b4b..740ce83ca 100644
--- a/src/md_MAIN_013/md_MAIN_013.c
+++ b/src/md_MAIN_013/md_MAIN_013.c
@@ -72,32 +72,7 @@ void func_800CB510(void *arg0) {
 
 INCLUDE_ASM("asm/md_MAIN_013/nonmatchings/md_MAIN_013", func_800CB56C);
 
-void func_800CB6E4(void *arg0) {
-    extern s32 func_80146A6C(s32, void *, s32, s32, s32, s32, s32);
-    extern void func_80146C3C();
-    u8 *a0 = *(u8 **)((s32)arg0 + 0x34);
-    if (*(s32 *)((s32)arg0 + 0x30) == *(s16 *)(a0 + 0x36)) {
-        s16 var;
-        if (*(s32 *)(a0 + 0x58) < 0) {
-            u8 *p = (u8 *)(*(s32 *)(a0 + 0x58) & (s32)0x8FFFFFFF);
-            var = ((*(s16 *)(p + 8) + *(s16 *)(p + 0xA)) >> 1) - 0x10;
-        } else {
-            var = -0x30;
-        }
-        *(s32 *)((s32)arg0 + 0x4C) = *(s16 *)(a0 + 6);
-        *(s32 *)((s32)arg0 + 0x50) = *(s16 *)(a0 + 0xA) + (s16)var;
-        *(s32 *)((s32)arg0 + 0x54) = *(s16 *)(a0 + 0xE);
-    }
-    if (*(s32 *)((s32)arg0 + 0x1C) < 0x18 && *(u16 *)a0 != 0) {
-        if (*(s32 *)((s32)arg0 + 0x1C) < 0xE) {
-            func_80146A6C(0x15, arg0, 0, 0, 0, 0x8000, *(s32 *)((s32)arg0 + 0x1C));
-        }
-        *(s32 *)((s32)arg0 + 0x1C) = *(s32 *)((s32)arg0 + 0x1C) + 1;
-    } else {
-        func_80146C3C(arg0);
-    }
-}
-
+INCLUDE_ASM("asm/md_MAIN_013/nonmatchings/md_MAIN_013", func_800CB6E4);
 
 extern s32 func_80128ED8(s32 param_1, s32 *param_2);
 extern void func_80146C3C();
diff --git a/src/md_MAIN_027/md_MAIN_027.c b/src/md_MAIN_027/md_MAIN_027.c
index a393566c9..f5f37b2a9 100644
--- a/src/md_MAIN_027/md_MAIN_027.c
+++ b/src/md_MAIN_027/md_MAIN_027.c
@@ -208,7 +208,42 @@ void func_800CB2CC(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB3E0);
+extern void func_800CB82C(s32 a0, s32 a1);
+extern s32 func_80146E98(s32 a0);
+extern void func_80146D90(s32 a0);
+extern void func_80146CA0(void *a0);
+
+void func_800CB3E0(s32 a0) {
+    u8 *s0;
+    u16 w;
+
+    s0 = *(u8 **)(a0 + 0x20);
+    func_800CB82C(a0, *(s32 *)(a0 + 0x58));
+
+    *(u16 *)(a0 + 0xA) -= 1;
+
+    w = *(u16 *)(s0 + 0x18);
+    w += 0x100;
+    *(u16 *)(s0 + 0x18) = w;
+    if ((s16)w >= 0x1CCD) {
+        *(u16 *)(s0 + 0x18) = 0x1CCC;
+    }
+
+    w = *(u16 *)(s0 + 0x1A);
+    w += 0x100;
+    *(u16 *)(s0 + 0x1A) = w;
+    if ((s16)w >= 0x1CCD) {
+        *(u16 *)(s0 + 0x1A) = 0x1CCC;
+    }
+
+    if (func_80146E98(a0) != 0) {
+        *(u16 *)(s0 + 0x18) = 0x1CCC;
+        *(u16 *)(s0 + 0x1A) = 0x1CCC;
+        func_80146D90(a0);
+        func_80146CA0((void *)a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB4A4);
 
diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 59d04dae1..07fd7a730 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -1187,7 +1187,12 @@ void func_801A4A18(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4AAC);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801A4AAC(void *a0) {
+    func_8012AD44((s32 *)a0, 3);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4ACC);
 
diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c b/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
index 1ae5c8257..b98cebfde 100644
--- a/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
+++ b/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
@@ -3425,7 +3425,19 @@ INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180BD
 
 INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180C98);
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180D10);
+#include "common.h"
+
+extern u8 D_801BC6C8[];
+
+void func_80180D10(void *a0) {
+    if (*(s32 *)((char *)a0 + 0x1c) != 0) {
+        *(s32 *)((char *)a0 + 0x1c) = *(s32 *)((char *)a0 + 0x1c) - 1;
+    } else {
+        *(void **)((char *)a0 + 0xcc) = D_801BC6C8;
+        *(u16 *)((char *)a0 + 2) = *(u16 *)((char *)a0 + 2) + 1;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
index 053ba026c..b4a6687c8 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
@@ -3281,7 +3281,32 @@ void func_8017F8D8(s32 *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F8E4);
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F900);
+extern s32 ratan2(s32 dx, s32 dy);
+extern void func_80171B10(void *a0);
+
+s32 func_8017F900(void *a0) {
+    extern s32 D_80126B58;
+    extern s32 D_801E97C4;
+    s16 pos[3];
+    s32 old;
+
+    if (*(s32 *)((char *)a0 + 0x1C) < 0x82) {
+        pos[0] = *(u16 *)(*(s32 *)((char *)a0 + 0xD4) + 6);
+        pos[1] = 0;
+        pos[2] = *(u16 *)(*(s32 *)((char *)a0 + 0xD4) + 0xE);
+        ((void (*)(void *, void *))func_80171B10)(&D_80126B58, pos);
+        old = *(s32 *)((char *)a0 + 0x1C);
+        *(s32 *)((char *)a0 + 0x1C) = old + 1;
+        if (old >= 0x56) {
+            pos[0] = pos[0] - *(u16 *)((char *)a0 + 6);
+            pos[2] = pos[2] - *(u16 *)((char *)a0 + 0xE);
+            D_801E97C4 = -ratan2(pos[0], pos[2]);
+        }
+        return 1;
+    }
+    return 0;
+}
+
 
 extern void func_8001AAA0(s32 arg0);
 extern s32 func_8001B710(void);
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
index 20ea77d86..914d2b87a 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
@@ -3666,7 +3666,42 @@ void func_8017E97C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E9B8);
+#include "common.h"
+
+/* engine_types.h:497 `Blk8` VERBATIM -- the real TU reaches it via engine_core.h ->
+ * engine_types.h, so the bank driver strips this local copy; match_one's standalone
+ * compile cannot see that header, hence the restatement. */
+
+
+extern void func_80015978(s32 a0, s32 *a1);
+extern s32 func_80013294(void *a0, void *a1);
+extern s32 func_8014C168(s32 *a0, s32 a1);
+extern void func_8017EDF8();
+extern Blk8 D_801274E8;
+extern s32 D_80126B58;
+
+void func_8017E9B8(void *a0) {
+    Blk8 buf1;
+    Blk8 buf2;
+    s32 *s0;
+    s32 cmp;
+    s32 res;
+
+    s0 = &D_80126B58;
+    func_80015978(func_8014C168(s0, 0x3D) + 4, &buf1);
+    func_80015978((s32)(s0 + 1), &buf2);
+    s0 = &buf2;
+    cmp = func_80013294(&buf1, s0);
+    if (cmp < 0x100) {
+        res = func_80013294(&buf1, s0) + 0x28A;
+    } else {
+        res = 0x38A;
+    }
+    *(s32 *)((u8 *)a0 + 0x14) = res;
+    D_801274E8 = buf1;
+    func_8017EDF8(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017EA74);
 
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
index fef0b6680..60f38c598 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
@@ -4265,7 +4265,21 @@ s32 func_80187414(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_80184BD8", func_80187454);
+extern void func_8002D59C(s32 a0, u16 a1, s32 a2);
+extern void func_8012C218(void *a0);
+
+/* §37/§124 def-side asm-label alias: the TU declares `extern void func_80187454(void);`
+ * (L4194) for the no-argument caller at L4205, while the byte-true definition takes a
+ * pointer in $a0 (sw $s0 / addu $s0,$a0,$zero prologue). Neither side can move, so the
+ * definition gets a private C identifier and binds the emitted symbol with a GNU asm
+ * label. Same class as banked func_8017EF54 (ov_SC06_008_jr_8017C294.c:4152). */
+void aF80187454(void *arg0) __asm__("func_80187454");
+
+void aF80187454(void *arg0) {
+    func_8002D59C(4, 0x64E, *(u16 *)((char *)arg0 + 0x104));
+    func_8012C218(arg0);
+}
+
 
 extern void func_8002D59C(s32 a0, u16 a1, s32 a2);
 
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 cfa55bdc8..27fd911f4 100644
--- a/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c
+++ b/src/ov_SC02_031/ov_SC02_031_jr_8017AE2C.c
@@ -7246,7 +7246,16 @@ s32 func_801832F4(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_jr_8017AE2C", func_80183314);
+extern void (*D_801893D4[])(void);
+extern s32 func_80183B90(void);
+
+void func_80183314(void *a0) {
+    D_801893D4[*(u16 *)((s32)a0 + 0x2)]();
+    if ((*(u16 *)((s32)a0 + 0x100) & 0x10) && func_80183B90() == 1) {
+        *(u16 *)((s32)a0 + 0x100) &= ~0x10;
+    }
+}
+
 
 extern s32 func_80183AC8(s32 a0, s32 a1, s16 a2, s16 a3, s32 a4);
 
diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c b/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
index b0dafd94c..90cca2033 100644
--- a/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
+++ b/src/ov_SC03_012/ov_SC03_012_jr_8017AE2C.c
@@ -4011,7 +4011,35 @@ INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8017AE2C", func_8017DE9
 
 INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8017AE2C", func_8017DEB0);
 
-INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8017AE2C", func_8017DEF0);
+extern void func_8017D6B4(void);
+
+void func_8017DEF0(void *a0) {
+    s16 val16;
+    u16 val;
+
+    val = *(u16 *)((char *)a0 + 0xE4);
+    val--;
+    *(u16 *)((char *)a0 + 0xE4) = val;
+    val16 = (s16)val;
+    if (val16 == 0) {
+        func_8017D6B4();
+    }
+    val = *(u16 *)((char *)a0 + 0xE0);
+    val--;
+    *(u16 *)((char *)a0 + 0xE0) = val;
+    val16 = (s16)val;
+    if (val16 < 4) {
+        *(u16 *)((char *)a0 + 0xE2) = 0x10;
+    }
+    if (*(s16 *)((char *)a0 + 0xE0) < 2) {
+        *(u16 *)((char *)a0 + 0xE2) = 8;
+    }
+    *(u16 *)(*(s32 *)((char *)a0 + 0x20) + 0x10) = *(u16 *)(*(s32 *)((char *)a0 + 0x20) + 0x10) + *(u16 *)((char *)a0 + 0xE2);
+    if (*(s16 *)(*(s32 *)((char *)a0 + 0x20) + 0x10) >= 0x401) {
+        *(u16 *)((char *)a0 + 2) += 1;
+    }
+}
+
 
 void func_8017DFBC(void *a0) {
         *(short *)(*(int *)((char *)a0 + 0x64) + 0xe0) = 2;
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 188f0cf00..d040f5c8a 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -8005,7 +8005,37 @@ void func_8018947C(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189518);
+void func_80189518(s32 arg0)
+{
+    extern void func_800183E0(s32);
+    extern u8 D_801CFAFC[];
+    extern u8 D_801CFB1C[];
+    extern u8 D_80078E78[];
+    u8 *base;
+    s32 a;
+    s32 b;
+    s32 cond;
+
+    base = D_80078E78;
+    if (*(u16 *)(arg0 + 0xFC) & 0xF) {
+        func_800183E0(D_801CFB1C);
+    } else {
+        func_800183E0(D_801CFAFC);
+    }
+
+    a = *(s16 *)(arg0 + 0xDE);
+    if (a >= 0x564 && (b = *(s16 *)(base + 0x1A)) < 0x3D) {
+        cond = b + 0x5A0 < a;
+    } else {
+        cond = *(s16 *)(arg0 + 0xDE) > *(s16 *)(base + 0x1A);
+    }
+    if (cond == 0) {
+        *(s16 *)(arg0 + 2) = 2;
+        *(u8 *)(arg0 + 0xC1) = 0;
+        *(u16 *)(arg0 + 0x5C) = 0x8000;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_801895CC);
 
diff --git a/src/ov_SC03_119/ov_SC03_119_jr_8017FB84.c b/src/ov_SC03_119/ov_SC03_119_jr_8017FB84.c
index a726a6221..95a36d996 100644
--- a/src/ov_SC03_119/ov_SC03_119_jr_8017FB84.c
+++ b/src/ov_SC03_119/ov_SC03_119_jr_8017FB84.c
@@ -3792,7 +3792,7 @@ DEFINE_func_80181E58()  /* dedup: shared engine-core @0x80181E58 (src/shared) */
 extern int func_80178970(void);
 extern s32 D_801D4300;
 extern s32 func_8012BEE8(s32 a0);
-extern s32 func_8018219C(s32 a0);
+extern s32 func_8018219C();
 extern s32 func_80183178(void);
 extern void func_8013CABC(void);
 extern void func_8018226C(s32 a0);
@@ -3843,7 +3843,43 @@ void func_8018201C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_jr_8017FB84", func_8018219C);
+extern u16 D_800B99D8;
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+s32 func_8018219C(s32 arg0)
+{
+    s32 owner;
+    s32 i;
+    register s32 obj __asm__("$4");
+    register s32 d __asm__("$2");
+    u16 a;
+    u16 b;
+
+    owner = arg0;
+    i = 0;
+    do {
+        obj = func_80132EF4(owner, 0x22);
+        if (obj != 0) {
+            a = *(u16 *)(obj + 6) - 0x28;
+            *(u16 *)(obj + 6) = a;
+            b = *(u16 *)(obj + 0xA) - 0x20;
+            *(u16 *)(obj + 0xA) = b;
+            d = (i + (D_800B99D8 & 4) * 3) - 0x2A;
+            *(u16 *)(obj + 0xE) = *(u16 *)(obj + 0xE) + d;
+            d = (s16)d;
+            if (d >= 0) {
+                d = d << 7;
+            } else {
+                d = -(d << 7);
+            }
+            *(u16 *)(obj + 0x34) = d + 0x1000;
+            *(s32 *)(obj + 0x14) = 0xFFFE0000;
+            *(s32 *)(obj + 0x10) = 0xFFFD0000;
+        }
+        i += 0x18;
+    } while (i < 0x49);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_jr_8017FB84", func_8018226C);
 
diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c b/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
index b72149f7a..5f6a0ab08 100644
--- a/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
+++ b/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
@@ -5487,7 +5487,37 @@ void func_80180F90(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180FE8);
+s32 func_80180FE8(u8 *a0, u8 *a1, s32 a2) {
+    extern s32 D_801F89E0;
+    extern s16 D_801F8A10;
+    extern s16 D_801F8A12;
+    extern s16 D_801F8A14;
+    extern s32 D_801F8AEC;
+    register u8 *p __asm__("$5");
+    register s16 *pa __asm__("$6");
+    register u8 *self __asm__("$7");
+    s32 aec;
+
+    p = a1 + (s16)a2 * 14;
+    pa = &D_801F8A10;
+    __asm__ __volatile__("" : "=r"(pa) : "0"(pa));
+    self = a0;
+    if (*(s16 *)(p + 0xC) == 0x7FFF) {
+        (*(u16 *)(self + 0x38))--;
+        p -= 14;
+    }
+    *(s32 *)(self + 0x3C) = (*(s16 *)(p + 0) * D_801F89E0 >> 12) + pa[0];
+    *(s32 *)(self + 0x40) = (*(s16 *)(p + 2) * D_801F89E0 >> 12) + (&D_801F8A10)[1];
+    *(s32 *)(self + 0x44) = (*(s16 *)(p + 4) * D_801F89E0 >> 12) + (&D_801F8A10)[2];
+    *(s32 *)(self + 0x48) = (*(s16 *)(p + 6) * D_801F89E0 >> 12) + pa[0];
+    *(s32 *)(self + 0x4C) = (*(s16 *)(p + 8) * D_801F89E0 >> 12) + D_801F8A12;
+    *(s32 *)(self + 0x50) = (*(s16 *)(p + 0xA) * D_801F89E0 >> 12) + D_801F8A14;
+    aec = D_801F8AEC;
+    *(s32 *)(self + 0x54) = *(s16 *)(p + 0xC) << 5;
+    *(s32 *)(self + 0x08) = aec;
+    return 0;
+}
+
 
 s32 func_80181120(u8 *a0, s32 a1, u8 *a2, u8 *a3) {
     a1 = (s16)a1;
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
index 871bd41cc..e4fc62e70 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
@@ -6067,7 +6067,58 @@ void func_80182E24(void *param)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182E64);
+extern u8 D_801202A0[];
+extern s32 func_80013328(s32 a0, s32 a1);
+extern void func_800D1724(s32 a0);
+extern void func_80171928(void *a0);
+
+typedef struct {
+    u16 f_00;
+    u8 pad_02[0x5A];
+    u16 f_5C;
+    u8 pad_5E[0x7E];
+    s32 f_DC;
+} Ent_80182E64;
+
+void func_80182E64(void *arg0)
+{
+    register Ent_80182E64 *found __asm__("$20");
+    s32 best;
+    s32 i;
+    s32 off;
+    s32 d;
+    Ent_80182E64 *p;
+
+    found = NULL;
+    best = 0x7FFFFFFF;
+    i = 0;
+    off = 0;
+loop:
+    p = (Ent_80182E64 *)(D_801202A0 + off);
+    if (p->f_00 == 0) {
+        goto next;
+    }
+    if (!(p->f_5C & 0x80)) {
+        goto next;
+    }
+    d = (s16)func_80013328((s32)arg0 + 4, (s32)p + 4);
+    if (d >= best) {
+        goto next;
+    }
+    best = d;
+    found = p;
+next:
+    i++;
+    if (i < 0x60) {
+        off += 0x10C;
+        goto loop;
+    }
+    if (found != NULL) {
+        func_800D1724(found->f_DC);
+    }
+    func_80171928(arg0);
+}
+
 
 extern s32 func_80013328(s32 a0, s32 a1);
 extern void func_80015978(s32 a0, s32 *a1);
diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
index 8d5bd8519..cc6e20238 100644
--- a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
+++ b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
@@ -8202,7 +8202,38 @@ extern void func_8012A018(s32 a, s32 b);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80188988);
+void func_80188988(int param_1) {
+    extern s32 D_801DFFE0;
+    extern s32 D_801DFFE4;
+    extern s32 D_801DFFE8;
+    extern s32 D_801DFFEC;
+    extern s32 func_80012CB8(s32 a0, s32 a1, s32 a2);
+    register s16 *psVar1 __asm__("$5");
+    s16 *psVar2;
+    s16 *psVar3;
+    s16 *psVar5;
+    s16 sVar4;
+
+    psVar1 = (s16 *)D_801DFFE0;
+    psVar2 = (s16 *)D_801DFFE4;
+    *(s32 *)(param_1 + 0x4C) = psVar1[1];
+    *(s32 *)(param_1 + 0x50) = psVar1[2];
+    *(s32 *)(param_1 + 0x40) = psVar2[1];
+    psVar3 = (s16 *)D_801DFFE8;
+    *(s32 *)(param_1 + 0x44) = psVar2[2];
+    sVar4 = func_80012CB8(*psVar3, *psVar1, 0x80);
+    ((struct { s32 f; } *)(param_1 + 0x48))->f += sVar4;
+    sVar4 = func_80012CB8(*(s16 *)D_801DFFEC, *(s16 *)D_801DFFE4, 0x80);
+    psVar5 = (s16 *)D_801DFFE0;
+    *(s32 *)(param_1 + 0x3C) += sVar4;
+    if (psVar5[0] < *(s32 *)(param_1 + 0x48)) {
+        *(s32 *)(param_1 + 0x48) = psVar5[0];
+    }
+    if (*(s16 *)D_801DFFE4 < *(s32 *)(param_1 + 0x3C)) {
+        *(s32 *)(param_1 + 0x3C) = *(s16 *)D_801DFFE4;
+    }
+}
+
 
 extern u16 D_801913E4[];
 extern u16 D_801913EC[];
diff --git a/src/ov_SC06_030/ov_SC06_030_jr_8017C8D0.c b/src/ov_SC06_030/ov_SC06_030_jr_8017C8D0.c
index 3bc9b0b3f..79de63e5d 100644
--- a/src/ov_SC06_030/ov_SC06_030_jr_8017C8D0.c
+++ b/src/ov_SC06_030/ov_SC06_030_jr_8017C8D0.c
@@ -3345,7 +3345,45 @@ void func_8017DB58(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_030/nonmatchings/ov_SC06_030_jr_8017C8D0", func_8017DB94);
+typedef struct {
+    s16 v[4];
+} Blk8_80126940_8017DB94;
+
+void func_8017DB94(s32 a0) {
+
+    extern s32 D_80126B58;
+    extern s16 D_80185924[];
+    extern Blk8_80126940_8017DB94 D_80126940;
+    Blk8_80126940_8017DB94 sp10;
+    u8 t;
+    s16 v0, v1;
+
+    if (func_80148800(&D_80126B58) & 3) {
+        t = (*(u8 *)(a0 + 5) + 1) & 1;
+        *(u8 *)(a0 + 5) = t;
+        *(s32 *)(a0 + 0x14) = D_80185924[t];
+    }
+    sp10 = D_80126940;
+
+    /* Clamp sp10.v[0] */
+    v1 = sp10.v[0];
+    if (v1 < -0xE0) {
+        sp10.v[0] = -0xE0;
+    } else if (v1 < 0xE1) {
+        /* v1 stays unchanged */
+    } else {
+        sp10.v[0] = 0xE0;
+    }
+
+    /* Clamp sp10.v[2] */
+    v0 = sp10.v[2];
+    if (v0 < -0xE0) {
+        sp10.v[2] = -0xE0;
+    }
+
+    func_8017DC70(a0, sp10.v);
+}
+
 
 
 // @class: schedule