diff --git a/src/md_MAIN_033/md_MAIN_033.c b/src/md_MAIN_033/md_MAIN_033.c
index 3ba24938f4..d87aee7f3a 100644
--- a/src/md_MAIN_033/md_MAIN_033.c
+++ b/src/md_MAIN_033/md_MAIN_033.c
@@ -91,7 +91,58 @@ void func_800CAFE8(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_033/nonmatchings/md_MAIN_033", func_800CB058);
+void func_800CB058(s32 arg0)
+{
+    extern u8 D_800CB8B0[];
+    extern s32 D_800CB984;
+    extern u8 D_800CB988[];
+    extern void func_80146578(void);
+    extern void func_800CB384(void);
+    extern void func_8001CB6C(u8 *a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80149374(s32 a0, s32 a1);
+    extern void func_80146DE8(s32 *a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80146E90(s32 *a0, s32 a1);
+    extern void func_80146CA0(void *a0);
+    extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
+    extern void func_80147324(s32 a0);
+    register s32 s1a __asm__("$17");
+    register s32 s2a __asm__("$18");
+    register s32 s0a __asm__("$16");
+    register s32 maska __asm__("$6");
+    register s32 fptr __asm__("$6");
+    register s32 q __asm__("$5");
+    register s32 p __asm__("$4");
+    s32 v0w;
+    s32 cnt;
+
+    s1a = arg0;
+    s2a = *(s32 *)(s1a + 0x4C);
+    s0a = ((s32 (*)(void))func_80146578)();
+    *(s32 *)(s1a + 0x20) = s0a;
+    if (s0a == 0) goto fail;
+    func_8001CB6C((u8 *)s0a, (s32)D_800CB8B0, 0x1A0, 0x100);
+    maska = 0x50001000;
+    p = s2a;
+    q = (s32)(s1a + 4);
+    v0w = *(u32 *)(s0a + 4);
+    *(u8 *)(s0a + 0x27) = 0x19;
+    *(u32 *)(s0a + 4) = (v0w | maska) & ~0x40;
+    fptr = *(s32 *)(p + 0x20);
+    cnt = D_800CB984++;
+    *(s16 *)(s0a + 0x12) = *(s16 *)(fptr + 0x12);
+    *(s16 *)(s0a + 0x10) = 0x400;
+    *(s32 *)(s0a + 0x34) = (s32)D_800CB988 + ((cnt & 7) * 32);
+    func_80149374(p, q);
+    func_80146DE8(s1a, 0, 0, -0x100000);
+    func_80146E90(s1a, 0x3C);
+    func_80146CA0(s1a);
+    func_80146A6C(0x4A, s1a, *(s16 *)(s1a + 6), *(s16 *)(s1a + 0xA), *(s16 *)(s1a + 0xE), 0, 0);
+    func_80147324(0x8EF);
+    return;
+fail:
+    ((void (*)(s32))func_800CB384)(s1a);
+}
+
 
 void func_800CB190(void *arg0) {
     extern void func_80147324(s32);
diff --git a/src/md_MAIN_045/md_MAIN_045.c b/src/md_MAIN_045/md_MAIN_045.c
index a3f5459055..0ad604f68b 100644
--- a/src/md_MAIN_045/md_MAIN_045.c
+++ b/src/md_MAIN_045/md_MAIN_045.c
@@ -181,7 +181,7 @@ void func_800CCFA8(s32 param_1)
 extern void func_80146578(void);
 extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3);
 extern void func_80146CA0(void *a0);
-extern void func_800CD204(void);
+extern void func_800CD204();
 extern void func_800CD1A8(void);
 
 extern u8 D_800CD66C;
@@ -211,7 +211,7 @@ void func_800CD010(s32 param_1)
 }
 
 
-extern void func_800CD204(void);
+extern void func_800CD204();
 extern s32 func_80163408(s32 a0, s32 a1, s32 a2, s32 a3);
 extern void func_80163328();
 extern s32 func_801632F0();
@@ -258,7 +258,47 @@ void func_800CD1A8(void) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD204);
+extern s16 func_8012A758(void);
+extern s32 func_80013694(s16 a0, void *a1, void *a2);
+extern void func_800139C8(s32 a0, void *a1, void *a2);
+extern void func_80015954(void *a0, s32 a1);
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80047948(s32 a0);
+extern u8 D_800CD6BC[];
+
+void func_800CD204(s32 arg0) {
+    u16 sp10[3];
+    s32 y;
+    s32 x;
+    s32 w;
+    s32 t;
+    s32 v1;
+    s16 ang;
+
+    y = *(s32 *)(arg0 + 0x4C);
+    x = *(s32 *)(arg0 + 0x20);
+    ang = func_8012A758();
+    func_80013694(*(s16 *)(x + 0x10), D_800CD6BC, sp10);
+    func_800139C8((s16)(ang + 0x400), sp10, sp10);
+    w = *(s32 *)(y + 0x20);
+    sp10[0] = sp10[0] + *(s32 *)(w + 0x48);
+    t = sp10[1] - 0x20;
+    sp10[1] = t + *(s32 *)(w + 0x4C);
+    sp10[2] = sp10[2] + *(s32 *)(w + 0x50);
+    v1 = func_80047948(*(s16 *)(arg0 + 0x60));
+    if (v1 < 0) {
+        v1 += 0x1FF;
+    }
+    sp10[0] = sp10[0] + (v1 >> 9);
+    v1 = func_8004787C(*(s16 *)(arg0 + 0x60));
+    if (v1 < 0) {
+        v1 += 0xFF;
+    }
+    sp10[1] = sp10[1] + (v1 >> 8);
+    *(u16 *)(arg0 + 0x60) = (*(u16 *)(arg0 + 0x60) + 0x38) & 0xFFF;
+    func_80015954(sp10, arg0 + 4);
+}
+
 
 extern s32 func_80161A00(s32 a0);
 extern void (*D_800CD6C4[])(void);
diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c b/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c
index 4f89feef50..c73c7583ca 100644
--- a/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c
+++ b/src/ov_SC01_000/ov_SC01_000_jr_8017BEBC.c
@@ -3442,7 +3442,55 @@ INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8017BEBC", func_8017E1A
 
 INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8017BEBC", func_8017E210);
 
-INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8017BEBC", func_8017E3A0);
+void func_8017E3A0(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg4, s32 arg5)
+{
+    extern u8 *D_800A5E60;
+    extern u8 D_800AF630[];
+    extern u8 D_800AA608[];
+
+    u8 *prim;
+    u8 *fl;
+    u32 *q;
+    u32 *addrw;
+    u32 v1;
+    u32 val;
+    u32 mlo, mhi;
+    volatile s32 pad;
+
+    prim = D_800A5E60;
+    fl = D_800AF630;
+    prim[3] = 4;
+    prim[7] = 0x50;
+    if (arg5 == 0) {
+        prim[0xC] = 0xFF;
+        prim[0xE] = 0;
+        prim[0xD] = 0;
+        prim[4] = arg4;
+        prim[6] = 0;
+    } else {
+        prim[0xE] = 0xFF;
+        prim[0xD] = 0;
+        prim[0xC] = 0;
+        prim[6] = arg4;
+        prim[4] = 0;
+    }
+    prim[5] = 0;
+    __asm__ __volatile__("");
+    mlo = 0xFFFFFF;
+    ((u16 *)prim)[5] = a1;
+    mhi = 0xFF000000;
+    ((u16 *)prim)[4] = a0;
+    ((u16 *)prim)[8] = a2;
+    ((u16 *)prim)[9] = a3;
+    *(u32 *)prim = (*(u32 *)prim & mhi) | (*(u32 *)&D_800AA608[*(u16 *)(fl + 0xA3D2) << 14] & mlo);
+    q = (u32 *)D_800AA608;
+    addrw = (u32 *)((s32)q + (*(u16 *)(fl + 0xA3D2) << 14));
+    v1 = (u32)prim & mlo;
+    val = *addrw;
+    D_800A5E60 = (prim += 20);
+    *addrw = (val & mhi) | v1;
+}
+
 
 void func_8017E4A0(void)
 {
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 7bf96b8922..9dee4dd288 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
@@ -4022,7 +4022,46 @@ void func_8017FE78(s32 a0)
 void func_8017FED0(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FED8);
+extern s16 D_801F32D8;
+extern u8 D_801202A0[];
+
+s32 func_8017FED8(s32 a0) {
+    s16 i;
+    u8 *e;
+    u8 *p;
+    s16 cur;
+
+    if (--*(s16 *)(a0 + 0x102) == -1) {
+        i = 0;
+        e = D_801202A0;
+        for (;;) {
+            p = e + 0x102;
+            __asm__ __volatile__("" :: "r"(p));
+            if (*(u16 *)(e + 0) != 0x1AB) goto next;
+            if (*(s16 *)(p - 0x92) != 0x2B) goto next;
+            cur = D_801F32D8;
+            if (*(s16 *)(p - 0x6) != cur - 1) goto next;
+            if (*(s32 *)(p - 0x36)) {
+                *(s16 *)(a0 + 0x102) = 0;
+                return 0;
+            }
+            D_801F32D8 = cur - 1;
+            *(s16 *)p = 1;
+            if (D_801F32D8 & 1) {
+                *(s16 *)(a0 + 0x102) = 9;
+            } else {
+                *(s16 *)(a0 + 0x102) = 4;
+            }
+            break;
+        next:
+            ++i;
+            e += 0x10C;
+            if ((s16)i >= 0x60) break;
+        }
+    }
+    return D_801F32D8 < 2;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FFD0);
 
diff --git a/src/ov_SC02_004/ov_SC02_004_jr_8017AE2C.c b/src/ov_SC02_004/ov_SC02_004_jr_8017AE2C.c
index 3a28d2a2f7..2684cb8559 100644
--- a/src/ov_SC02_004/ov_SC02_004_jr_8017AE2C.c
+++ b/src/ov_SC02_004/ov_SC02_004_jr_8017AE2C.c
@@ -4221,7 +4221,50 @@ void func_8017D9C4(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_004/nonmatchings/ov_SC02_004_jr_8017AE2C", func_8017DA30);
+extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_80128EA8();
+extern s32 rand(void);
+extern u8 D_800D387C[];
+extern u8 D_800D3888[];
+extern u8 D_801817A4[];
+extern u8 D_801817B0[];
+
+void func_8017DA30(s32 a0) {
+    register s32 ent __asm__("$16");
+    s32 sub;
+    s32 hw;
+    u32 r;
+
+    ent = a0;
+    sub = *(s32 *)((u8 *)ent + 0x20);
+    if (*(s16 *)((u8 *)ent + 0x2E) != 0) {
+        func_8001CC3C(sub, (s32)D_800D387C, 0, 0);
+        *(u8 *)((u8 *)sub + 0x27) = 0x9C;
+        *(u16 *)((u8 *)sub + 0x1A) = 0x4000;
+        *(u16 *)((u8 *)sub + 0x18) = 0x4000;
+        *(s32 *)((u8 *)sub + 4) |= 0x50000040;
+        func_80128EA8(sub, (s32)((u8 *)ent + 0x24), (s32)D_800D3888);
+        hw = 0x2C;
+    } else {
+        register s32 q __asm__("$4");
+        register s32 p __asm__("$5");
+        register s32 e __asm__("$6");
+        func_8001CC3C(sub, (s32)D_801817A4, 0, 0);
+        q = sub;
+        p = (s32)((u8 *)ent + 0x24);
+        e = (s32)D_801817B0;
+        __asm__ __volatile__("" : "=r"(q), "=r"(p), "=r"(e) : "0"(q), "1"(p), "2"(e));
+        *(u8 *)((u8 *)q + 0x27) = 0x33;
+        func_80128EA8(q, p, e);
+        hw = 0x1C;
+    }
+    *(u16 *)((u8 *)ent + 0x1A) = hw;
+    r = rand();
+    *(s16 *)((u8 *)ent + 0x12) = (r & 0x3F) - 0x20;
+    *(u16 *)((u8 *)ent + 0x16) = 0x20 - ((r >> 4) & 0x3F);
+    *(u16 *)((u8 *)ent + 2) += 1;
+}
+
 
 void func_8017DB2C(s32 a0) {
     s32 ret;
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
index e204053566..85563e7430 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
@@ -5793,7 +5793,48 @@ s16 param_3;
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80186424);
+extern u8 D_80126B5C;
+extern s32 D_80126B60;
+extern u16 D_80126B62;
+extern s32 D_80126B64;
+extern u16 D_80126B66;
+extern s32 *D_80126B78;
+extern void func_8012F0BC(s32 *a0, s32 *a1, s32 *a2);
+extern void func_8012F1A4(s32 *a0, s32 a1, s32 *a2);
+extern void func_80132784(s32 a0, s32 a1, u32 a2);
+
+void func_80186424(s32 arg0)
+{
+    if (*(u8 *)(arg0 + 0x74) != 0) {
+        extern s32 gVecX __asm__("D_80126B5C");
+        s32 in[4];
+        s32 out[4];
+        s32 tmp[4];
+        u16 h;
+
+        in[0] = gVecX;
+        in[1] = D_80126B60;
+        in[2] = D_80126B64;
+        func_8012F0BC((s32 *)(*(s32 *)(arg0 + 0x20) + 0x34), in, tmp);
+        func_80132784(arg0, *(s32 *)(arg0 + 0x64), *(u16 *)(arg0 + 0xFC));
+        func_8012F1A4((s32 *)(*(s32 *)(arg0 + 0x20) + 0x34), (s32)tmp, out);
+        gVecX = out[0];
+        D_80126B60 = out[1];
+        D_80126B64 = out[2];
+        h = *((u16 *)&gVecX + 1);
+        *(u16 *)((s32)D_80126B78 + 8) = h;
+        *(s32 *)((s32)D_80126B78 + 0x48) = (s32)(s16)h;
+        __asm__ __volatile__("" ::: "memory");
+        *(u16 *)((s32)D_80126B78 + 0xA) = D_80126B62;
+        *(s32 *)((s32)D_80126B78 + 0x4C) = (s32)(s16)D_80126B62;
+        __asm__ __volatile__("" ::: "memory");
+        *(u16 *)((s32)D_80126B78 + 0xC) = D_80126B66;
+        *(s32 *)((s32)D_80126B78 + 0x50) = (s32)(s16)D_80126B66;
+    } else {
+        func_80132784(arg0, *(s32 *)(arg0 + 0x64), *(u16 *)(arg0 + 0xFC));
+    }
+}
+
 
 #include "common.h"
 
@@ -5895,7 +5936,52 @@ void func_80186600(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018675C);
+extern u16 D_801E4BBC;
+extern u16 D_801E43B4;
+extern s32 D_801270C8;
+extern u8 D_80195AC4[];
+extern s16 D_80195ACE;
+
+
+extern D_80195AF4_t D_80195AF4[];
+
+s32 func_8018675C(void *a0)
+{
+    s32 flags = *(s32 *)((u8 *)a0 + 0xE8);
+
+    if (flags & 0x800) {
+        s16 t = *(s16 *)((u8 *)a0 + 0xE0);
+        if (t >= 0) {
+            if (*(s16 *)((u8 *)a0 + 6) < *(s16 *)((u8 *)D_80195AF4 + t * 8)) {
+                u16 old = D_801E43B4;
+                s32 f6 = *(s16 *)((u8 *)D_80195AF4 + t * 8 + 6);
+                D_801E43B4 = old + 1;
+                D_801270C8 = f6;
+                *(s16 *)((u8 *)a0 + 0xE0) = -1;
+            }
+        }
+        if (*(s32 *)((u8 *)a0 + 0x10) >= 0) {
+            return 0;
+        }
+        if (*(s16 *)((u8 *)a0 + 6) < D_80195ACE) {
+            *(s16 *)((u8 *)a0 + 0xFE) = 0;
+            *(s32 *)((u8 *)a0 + 0xE8) |= 8;
+            return 1;
+        }
+        return 0;
+    } else {
+        if (*(s32 *)((u8 *)a0 + 0x18) > 0) {
+            s32 phase = D_801E4BBC;
+            if (*(s16 *)((u8 *)D_80195AC4 + phase * 4) < *(s16 *)((u8 *)a0 + 0xE)) {
+                *(s32 *)((u8 *)a0 + 0xE8) = flags | ((phase == 2) ? 0x400 : 8);
+                *(s16 *)((u8 *)a0 + 0xFE) = 0;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
 
 extern u16 D_801E4BBC;
 extern s32 D_80195AD0[];
@@ -8267,7 +8353,7 @@ void func_8018A3B4(void *a0) {
  * which is gcc's emit_block_move for align < 4. */
 
 extern Blob8_8018A47C D_801E2F28;
-extern void func_8018A6A0(s32 a0, Blob8_8018A47C *a1);
+extern void func_8018A6A0();
 
 void func_8018A47C(s32 a0) {
     Blob8_8018A47C tmp;
@@ -8350,7 +8436,7 @@ void func_8018A4C4(s32 a0)
 /* 8-byte, alignment-1 blob: the target copies it with lwl/lwr + swl/swr,
  * which is gcc's emit_block_move for align < 4. */
 
-extern void func_8018A6A0(s32 a0, Blob8_8018A47C *a1);
+extern void func_8018A6A0();
 
 void func_8018A658(s32 a0) {
 
@@ -8362,7 +8448,77 @@ void func_8018A658(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018A6A0);
+void func_8018A6A0(s32 a0, u16 *a1)
+{
+    u8 *s0 = (u8 *)a0;
+    u16 *s1 = a1;
+    u16 vec0[4];
+    register u16 counter __asm__("$2");
+    s32 res[3];
+    s32 flags;
+    u8 *puVar;
+
+    func_8012B2CC(a0);
+
+    __asm__ __volatile__(
+        "lw $12, 0(%0)\n"
+        "lw $13, 4(%0)\n"
+        "ctc2 $12, $0\n"
+        "ctc2 $13, $1\n"
+        "lw $12, 8(%0)\n"
+        "lw $13, 12(%0)\n"
+        "lw $14, 16(%0)\n"
+        "ctc2 $12, $2\n"
+        "ctc2 $13, $3\n"
+        "ctc2 $14, $4\n"
+        "lw $12, 20(%0)\n"
+        "lw $13, 24(%0)\n"
+        "ctc2 $12, $5\n"
+        "lw $14, 28(%0)\n"
+        "ctc2 $13, $6\n"
+        "ctc2 $14, $7\n"
+        : : "r"((u8 *)*(s32 *)(s0 + 0x20) + 0x34) : "$12", "$13", "$14");
+
+    vec0[2] = 0;
+    vec0[0] = 0;
+    vec0[1] = counter = *s1;
+
+    goto test;
+body:
+    puVar = func_8012913C(0xC);
+    if (puVar != 0) {
+        __asm__ __volatile__(
+            "lwc2 $0, 0(%0)\n"
+            "lwc2 $1, 4(%0)\n"
+            "nop\n"
+            "nop\n"
+            "mvmva 1, 0, 0, 0, 0\n"
+            : : "r"(vec0) : "memory");
+        __asm__ __volatile__(
+            "swc2 $25, 0(%0)\n"
+            "swc2 $26, 4(%0)\n"
+            "swc2 $27, 8(%0)\n"
+            : : "r"(res) : "memory");
+        __asm__ __volatile__(
+            "cfc2 $12, $31\n"
+            "nop\n"
+            "sw $12, 0(%0)\n"
+            : : "r"(&flags) : "$12", "memory");
+        *(u16 *)(puVar + 6) = (u16)res[0];
+        *(u16 *)(puVar + 0xA) = (u16)res[1];
+        *(u16 *)(puVar + 0xE) = (u16)(res[2] - 8);
+    }
+    {
+        register u16 tmp __asm__("$3");
+        counter = vec0[1];
+        tmp = *(u16 *)(s1 + 2);
+        counter += tmp;
+        vec0[1] = counter;
+    }
+test:
+    if ((s16)counter < *(s16 *)(s1 + 1)) goto body;
+}
+
 
 void func_8018A7D0(void) {
 }
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8018EA04.c b/src/ov_SC02_005/ov_SC02_005_jr_8018EA04.c
index e210819de9..d779237f3d 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8018EA04.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8018EA04.c
@@ -3335,7 +3335,7 @@ extern Blk16_8018A1D8 D_801E2F18;
 extern u8 *func_8018A30C(s32 a0, s32 a1);
 extern u8 * func_8018A30C(s32 a0, s32 a1);
 extern Blob8_8018A47C D_801E2F28;
-extern void func_8018A6A0(s32 a0, Blob8_8018A47C *a1);
+extern void func_8018A6A0();
 extern Blob8_8018A4C4 D_801E2F30;
 extern Blk16_8018A4C4 D_801E2F38;
 extern void func_8018A4C4(s32 a0);
@@ -3912,7 +3912,54 @@ void func_8018F230(void *param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8018EA04", func_8018F2C4);
+extern s32 D_801270CC;
+extern s32 D_801270C8;
+extern u8 D_80196C34[];
+extern void func_8012C218(void *a0);
+extern s32 func_80185D6C();
+
+void func_8018F2C4(s32 a0)
+{
+    s32 var_s1;
+    s32 *p8;
+
+    var_s1 = 0;
+    if (*(u16 *)(*(s32 *)&D_801270CC) != 0x3D) {
+        func_8012C218((void *)a0);
+        return;
+    }
+
+    if ((*(u8 *)(*(s32 *)&D_801270CC + 0xC1) - 3U) < 2) {
+        *(u16 *)(a0 + 0x5C) = 0;
+        return;
+    }
+
+    p8 = &D_801270C8;
+    if (*p8 == 0x1B) {
+        *(s32 *)(a0 + 0x58) = (s32)D_80196C34;
+        *(u16 *)(a0 + 0x5C) = 0;
+        return;
+    }
+
+    if (func_80185D6C() != 0) {
+        var_s1 = 0x80;
+    }
+    *(u16 *)(a0 + 0x5C) = 0x800;
+    if (*p8 < 0x1B) {
+        if (*(s16 *)(a0 + 0xE) < *(s16 *)(*(s32 *)&D_801270CC + 0xE)) {
+            *(u16 *)(a0 + 0xDC) = *(s16 *)(*(s32 *)&D_801270CC + 0xE);
+        }
+        *(u16 *)(a0 + 6) = *(u16 *)(a0 + 0xDE);
+        *(u16 *)(a0 + 0xE) = *(u16 *)(a0 + 0xDC) + var_s1;
+    } else {
+        if (*(s16 *)(*(s32 *)&D_801270CC + 6) < *(s16 *)(a0 + 6)) {
+            *(u16 *)(a0 + 0xDE) = *(s16 *)(*(s32 *)&D_801270CC + 6);
+        }
+        *(u16 *)(a0 + 6) = *(u16 *)(a0 + 0xDE) - var_s1;
+        *(u16 *)(a0 + 0xE) = *(u16 *)(a0 + 0xDC);
+    }
+}
+
 
 extern void func_8013C414(void *a0, void *a1);
 extern s32 D_8019AA5C;
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c b/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
index f94cce44f4..766a986787 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_8017AE2C.c
@@ -6176,7 +6176,39 @@ void func_8017F05C(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_8017AE2C", func_8017F07C);
+void func_8017F07C(void) {
+    extern s32 D_801C9A5C;
+    extern s32 D_801C9968;
+    extern s32 D_801C996C;
+    extern s32 D_801C9970;
+    extern s32 D_801C9974;
+    extern u8 D_801A041C[];
+    extern s32 D_80187858[];
+    extern void func_8017F1B8(void *a0, s32 a1);
+
+    switch (D_801C9A5C) {
+    case 0:
+        D_801C9968 = 1;
+        D_801C996C = 0;
+        D_801C9970 = 1;
+        D_801C9974 = 1;
+        D_801C9A5C = 1;
+        break;
+    case 1:
+        if (--D_801C9968 == 0) {
+            D_801C9968 = 2;
+            func_8017F1B8(D_801A041C, D_801C996C * 6);
+            D_801C996C = (D_801C996C + 1) & 7;
+        }
+        if (--D_801C9970 == 0) {
+            D_801C9970 = 8;
+            func_800183E0(D_80187858[D_801C9974]);
+            D_801C9974 = (D_801C9974 + 1) & 0xF;
+        }
+        break;
+    }
+}
+
 
 
 void func_8017F1B8(void *a0, s32 a1)
diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c b/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
index 6d5c3790dc..a952e91f06 100644
--- a/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
+++ b/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
@@ -3813,7 +3813,50 @@ s32 func_8017DBD0(u32 a0v)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_jr_8017BEBC", func_8017DC7C);
+#include "common.h"
+
+extern u16 D_80126CAC;
+extern u16 D_8019B568[];
+extern void func_8002D59C(s32 a0, u16 a1, s32 a2);
+
+void func_8017DC7C(s32 a0)
+{
+    s16 t;
+    s16 temp;
+    s16 vol;
+
+    t = *(u16 *)(a0 + 6) - D_80126CAC;
+    if (t < 0) {
+        t = -t;
+    }
+
+    if (t >= 0x801) {
+        *(s32 *)(*(s32 *)(a0 + 0x20) + 4) |= 0x80000000;
+    } else {
+        *(s32 *)(*(s32 *)(a0 + 0x20) + 4) &= 0x7FFFFFFF;
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) += D_8019B568[*(s16 *)(a0 + 0x70)];
+    }
+
+    temp = t - 0x140;
+    if (temp < 0) {
+        vol = 0x7F;
+    } else if (temp >= 0x200) {
+        vol = 0;
+    } else {
+        vol = 0x7F - (temp >> 2);
+    }
+
+    if (vol == 0) {
+        if (*(s16 *)(a0 + 0x84) != 0) {
+            func_8002D59C(4, 0x6DD, *(u16 *)(a0 + 0x70));
+            *(s16 *)(a0 + 0x84) = 0;
+        }
+    } else {
+        func_8002D59C(0x6DD, (vol | 0x1000) & 0xFFFF, *(u16 *)(a0 + 0x70));
+        *(s16 *)(a0 + 0x84) = 1;
+    }
+}
+
 
 
 // @class: struct
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
index 679d219129..529ae2cb99 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
@@ -7831,7 +7831,71 @@ void func_80182F10(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80182F4C);
+extern u8 D_801AD31C[];
+
+s32 func_80182F4C(s32 a0, s16 a1)
+{
+    register u8 *base __asm__("$8");
+    s16 val;
+    register u16 c0 __asm__("$11");
+    register u16 c1 __asm__("$7");
+    u16 outerIdx;
+    u16 innerIdx;
+    u16 diff;
+    s32 prod;
+    u16 temp2;
+    u16 idx2;
+    u16 *tbl;
+    register s32 p1 __asm__("$4");
+    s32 p2;
+    s32 p3;
+    u16 dx;
+    u16 n;
+    u16 sample;
+    s32 addr;
+    s16 cur;
+    u16 v;
+
+    base = D_801AD31C;
+    c0 = 0xF800;
+    val = (s16)a0;
+
+    do {
+        c1 = 0xFA00;
+        outerIdx = (c0 + 0x8000) >> 7 & 0x1FF;
+        do {
+            innerIdx = (c1 + 0x8000) >> 7 & 0x1FF;
+            diff = innerIdx - *(u16 *)(base + 2);
+            prod = diff * *(u16 *)(base + 4);
+            p1 = *(s32 *)(base + 0x14);
+            p2 = *(s32 *)(base + 0x18);
+            p3 = *(s32 *)(base + 0x1C);
+            temp2 = outerIdx - *(u16 *)(base + 0);
+            tbl = *(u16 **)(base + 0x8);
+            idx2 = (prod + temp2) * 2;
+            dx = tbl[idx2];
+            n = tbl[idx2 + 1];
+            p1 += dx;
+            while (n--) {
+                sample = *(u16 *)p1;
+                if (!(sample & 0x8000)) {
+                    addr = p2 + sample * 18;
+                } else {
+                    v = sample & 0x7FFF;
+                    addr = p3 + v * 22;
+                }
+                cur = *(s16 *)addr;
+                if (cur == val) {
+                    *(s16 *)addr = a1;
+                }
+                p1 += 2;
+            }
+            c1 += 0x80;
+        } while (c1 <= 0xFDFF);
+        c0 += 0x80;
+    } while (c0 <= 0xFBFF);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC03_024/ov_SC03_024_jr_8017DF84.c b/src/ov_SC03_024/ov_SC03_024_jr_8017DF84.c
index 0eef23c8c5..3110a970ba 100644
--- a/src/ov_SC03_024/ov_SC03_024_jr_8017DF84.c
+++ b/src/ov_SC03_024/ov_SC03_024_jr_8017DF84.c
@@ -5038,7 +5038,63 @@ void func_8018162C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_024/nonmatchings/ov_SC03_024_jr_8017DF84", func_80181668);
+extern s32 D_8018B0BC;
+extern u8 D_800D387C[];
+extern u8 D_800D3888[];
+
+void func_80181668(s32 param_1)
+{
+    s32 p;
+    register s32 r1 __asm__("$16");
+    register s32 r2 __asm__("$17");
+    s32 r3;
+    s32 r4;
+    s16 v;
+    s32 buf[3];
+    s32 *pAddr;
+
+    p = *(s32 *)(param_1 + 0x20);
+    *(u8 **)(p + 0x20) = D_800D387C;
+    *(u8 *)(p + 0x27) = 0x9c;
+    *(u16 *)(p + 0x1a) = 0x4000;
+    *(u16 *)(p + 0x18) = 0x4000;
+    *(u8 *)(p + 0x24) = 0x40;
+    *(u8 *)(p + 0x25) = 0x30;
+    *(u8 *)(p + 0x26) = 0x30;
+    *(u32 *)(p + 4) = *(u32 *)(p + 4) | 0x50000000;
+
+    func_80128EA8(*(s32 *)(param_1 + 0x20), param_1 + 0x24, (s32)D_800D3888);
+
+    r1 = rand();
+    r2 = rand();
+    r3 = rand();
+    v = (r1 & 3) * 1024;
+    v += (r2 & 3) * 250;
+    v += (r3 & 3) * 68;
+
+    r4 = rand();
+    pAddr = &D_8018B0BC;
+    *pAddr = 0xFFFC0000 - ((r4 & 0xF) << 14);
+
+    func_8001382C(v, (void *)((s32)pAddr - 8), buf);
+
+    {
+        s32 b0, b1, b2;
+        s32 cnt;
+
+        b0 = buf[0];
+        cnt = *(u16 *)(param_1 + 2);
+        *(s32 *)(param_1 + 0x10) = b0;
+        b1 = buf[1];
+        cnt = cnt + 1;
+        *(s32 *)(param_1 + 0x14) = b1;
+        b2 = buf[2];
+        *(s32 *)(param_1 + 0x1c) = 0x1e;
+        *(u16 *)(param_1 + 2) = cnt;
+        *(s32 *)(param_1 + 0x18) = b2;
+    }
+}
+
 
 extern void func_8012931C(struct vec *a0);
 extern s32 func_80128ED8(s32 param_1, s32 *param_2);
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c b/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
index e8854dff06..8ffce487ef 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
@@ -4712,7 +4712,33 @@ void func_80182CA4(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017FF7C", func_80182D70);
+#include "common.h"
+
+typedef struct { s32 w[8]; } Blk20_80182D70;
+
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80047948(s32 a0);
+extern void RotMatrixY(s32 a0, void *a1);
+extern void func_800484EC(s32 a0, s32 a1, s32 a2);
+
+void func_80182D70(s32 arg) {
+    register void *s1 __asm__("$17") = (void *)arg;
+    extern Blk20_80182D70 aD800AE620_80182D70 __asm__("D_800AE620");
+    Blk20_80182D70 m;
+    s32 vec[3];
+    s32 out[3];
+
+    vec[0] = *(s16 *)(s1 + 0xE0) * func_80047948(*(s32 *)(s1 + 0x1C) << 7);
+    vec[1] = *(s16 *)(s1 + 0xE0) * func_8004787C(*(s32 *)(s1 + 0x1C) << 7);
+    vec[2] = 0;
+    m = aD800AE620_80182D70;
+    RotMatrixY(*(s16 *)(s1 + 0xFC), &m);
+    func_800484EC((s32)&m, (s32)vec, (s32)out);
+    *(s16 *)(s1 + 0x6) = *(u16 *)(s1 + 0x88) + (out[0] >> 12);
+    *(s16 *)(s1 + 0xA) = *(u16 *)(s1 + 0x8A) + (out[1] >> 12);
+    *(s16 *)(s1 + 0xE) = *(u16 *)(s1 + 0x8C) + (out[2] >> 12);
+}
+
 
 extern s32 D_801C48F0[];
 extern s32 func_8012C044(s32 a0);
diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
index 96c2579987..5335fcbd99 100644
--- a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
+++ b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
@@ -4558,7 +4558,69 @@ void func_80181AA0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80181B50);
+#include "common.h"
+
+
+
+extern u16 func_80148800(s32 *a0);
+extern void func_80181D30(s32 param_1, s16 *param_2);
+extern s32 func_80012F74(s32 a0, s32 a1, s32 a2, s32 a3);
+
+void func_80181B50(s32 a0) {
+
+    extern s32 D_80126B58;
+    extern s16 D_8018F780[];
+    extern Blk8_80126940_8017D6D0_80181C80 D_80126940;
+    Blk8_80126940_8017D6D0_80181C80 sp10;
+    u8 t;
+    s16 v1;
+    register s16 c __asm__("$4"); /* clamp store value — target stores every bound from $a0 */
+
+    if (func_80148800(&D_80126B58) & 3) {
+        t = (*(u8 *)(a0 + 5) + 1) & 1;
+        *(u8 *)(a0 + 5) = t;
+        *(s32 *)(a0 + 0x14) = D_8018F780[t];
+    }
+    sp10 = D_80126940;
+
+    v1 = sp10.v[0];
+    if (v1 < -0x43F) {
+        if (v1 < -0x4FF) {
+            *(s16 *)(a0 + 0x2E) = 0;
+        } else {
+            *(s16 *)(a0 + 0x2E) = -0x500 - v1;
+        }
+    } else {
+        *(s16 *)(a0 + 0x2E) = 0;
+    }
+
+    *(s16 *)(a0 + 0x28) = (s16)func_80012F74(*(s16 *)(a0 + 0x28), *(s16 *)(a0 + 0x2E), 4, 1);
+
+    {
+        s16 lo = -0x580;
+        if (sp10.v[0] < lo) {
+            c = -0x580;
+            sp10.v[0] = c;
+        }
+    }
+    {
+        s16 lim = -0x380;
+        if (lim < sp10.v[0]) {
+            c = -0x380;
+            sp10.v[0] = c;
+        }
+    }
+    {
+        s16 lo2 = 0xC0;
+        if (sp10.v[2] < lo2) {
+            c = 0xC0;
+            sp10.v[2] = c;
+        }
+    }
+
+    func_80181D30(a0, sp10.v);
+}
+
 
 
 /* 8 bytes, align 2 -> lwl/lwr/swl/swr copy (cookbook §48-C2) */
diff --git a/src/ov_SC03_091/ov_SC03_091_jr_80182268.c b/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
index 2ca8e6198d..693c5b4e1a 100644
--- a/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
+++ b/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
@@ -2923,7 +2923,67 @@ void func_801826C8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_jr_80182268", func_80182788);
+#include "/home/musashi/bfm-decomp/src/shared/engine_core.h"
+
+extern u16 func_80148800(s32 *a0);
+extern void func_80182B48(s32 param_1, s16 *param_2);
+extern s32 func_80012F74(s32 a0, s32 a1, s32 a2, s32 a3);
+
+void func_80182788(s32 a0) {
+
+    extern s32 D_80126B58;
+    extern s16 D_80190714[];
+    extern Blk8_80126940_8017D6D0_80182A98 D_80126940;
+    Blk8_80126940_8017D6D0_80182A98 sp10;
+    u8 t;
+    s16 v1;
+    register s16 c __asm__("$4");
+
+    if (func_80148800(&D_80126B58) & 3) {
+        t = (*(u8 *)(a0 + 5) + 1) & 1;
+        *(u8 *)(a0 + 5) = t;
+        *(s32 *)(a0 + 0x14) = D_80190714[t];
+    }
+    sp10 = D_80126940;
+
+    v1 = sp10.v[0];
+    if (v1 >= 0x700) {
+        if (v1 < 0x7C0) {
+            *(s16 *)(a0 + 0x2E) = 0x7C0 - v1;
+        } else {
+            *(s16 *)(a0 + 0x2E) = 0;
+        }
+    } else {
+        *(s16 *)(a0 + 0x2E) = 0;
+    }
+
+    *(s16 *)(a0 + 0x28) = (s16)func_80012F74(*(s16 *)(a0 + 0x28), *(s16 *)(a0 + 0x2E), 4, 1);
+
+    {
+        s16 lo = 0x540;
+        if (sp10.v[0] < lo) {
+            c = lo;
+            sp10.v[0] = c;
+        }
+    }
+    {
+        s16 lim = 0x800;
+        if (lim < sp10.v[0]) {
+            c = lim;
+            sp10.v[0] = c;
+        }
+    }
+    {
+        s16 lo2 = -0x3C0;
+        if (sp10.v[2] < lo2) {
+            c = lo2;
+            sp10.v[2] = c;
+        }
+    }
+
+    func_80182B48(a0, sp10.v);
+}
+
 
 
 /* 8 bytes, align 2 -> lwl/lwr/swl/swr copy (cookbook §48-C2) */
diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c b/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
index 2276b05787..9451840cef 100644
--- a/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
+++ b/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
@@ -3850,7 +3850,48 @@ void func_8017DD44(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017BEBC", func_8017DDDC);
+
+
+extern s32 func_8012DEB8(s32 a0, s32 a1, s32 a2);
+
+s32 func_8017DDDC(s32 a0, s32 a1) {
+    V4_8017FAC0_8017D708 p2;
+    V4_8017FAC0_8017D708 p1;
+    register s32 rp1 __asm__("$17");
+    s32 mid;
+
+    rp1 = (s32)&p1;
+
+    p2.x = p1.x = *(u16 *)(a1 + 4);
+    p2.y = p1.y = *(u16 *)(a1 + 8) - 0x10;
+    p2.z = *(u16 *)(a1 + 0xC);
+    p1.z = *(u16 *)(a1 + 0xE);
+    if (func_8012DEB8(a0, (s32)&p2, rp1) != 0) {
+        return 1;
+    }
+
+    p2.x = p1.x = mid = (*(s16 *)(a1 + 4) + *(s16 *)(a1 + 6)) >> 1;
+    if (func_8012DEB8(a0, (s32)&p2, rp1) != 0) {
+        return 1;
+    }
+
+    p2.x = p1.x = (u32)(*(s16 *)(a1 + 4) + mid) >> 1;
+    if (func_8012DEB8(a0, (s32)&p2, rp1) != 0) {
+        return 1;
+    }
+
+    p2.x = p1.x = (u32)(*(s16 *)(a1 + 6) + mid) >> 1;
+    if (func_8012DEB8(a0, (s32)&p2, rp1) != 0) {
+        return 1;
+    }
+
+    p2.x = p1.x = *(u16 *)(a1 + 6);
+    if (func_8012DEB8(a0, (s32)&p2, rp1) != 0) {
+        return 1;
+    }
+    return 0;
+}
+
 
 extern void func_8012C1B8(void);
 extern void func_8012CAE4(void *a0);
@@ -4052,7 +4093,51 @@ void func_8017E27C(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017BEBC", func_8017E3F8);
+typedef struct { s32 w[8]; } Blk20_8017E3F8;
+
+void func_8017E3F8(void *a0)
+{
+    extern Blk20_8017E3F8 D_800AE620;
+    extern s32 D_801847E0;
+    extern void RotMatrixY(s32 a0, void *a1);
+    extern void func_8004914C(void *a0);
+    extern void func_800491AC(void *a0);
+    extern void RotTransSV(void *a0, void *a1, void *a2);
+    extern void func_8012E32C(void);
+    extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3);
+
+    s32 s0 = (s32)a0;
+    s16 v[4];
+    Blk20_8017E3F8 mtx = D_800AE620;
+    s32 flag;
+    s32 sxy;
+    s32 z;
+    s32 ent;
+    u16 t;
+    s32 f;
+
+    mtx.w[5] = *(s16 *)(s0 + 0x6);
+    mtx.w[6] = *(s16 *)(s0 + 0xA);
+    mtx.w[7] = *(s16 *)(s0 + 0xE);
+
+    ent = *(s32 *)(s0 + 0x20);
+    RotMatrixY(*(s16 *)(ent + 0x12), &mtx);
+    func_8004914C(&mtx);
+    func_800491AC(&mtx);
+
+    RotTransSV(&D_801847E0, v, &flag);
+    func_8012E32C();
+
+    *(s32 *)(s0 + 0xE0) = RotTransPers((s32)v, (s32)&sxy, &z, &flag);
+
+    t = *(u16 *)&sxy;
+    f = flag;
+    *(s16 *)(s0 + 0x100) = t;
+    if (f < 0) {
+        *(s16 *)(s0 + 0x100) = -0x3E7;
+    }
+}
+
 
 typedef struct { s32 flag; u16 xy[2]; s32 sp1c; } Out_8017E910_8017E508;
 typedef struct { s16 a, b, c, d; } SV4_8017E910_8017E508;
diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
index e2943d24f9..334a148e97 100644
--- a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
+++ b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
@@ -7453,7 +7453,37 @@ s32 a2;
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181EE8);
+typedef struct { s32 w[8]; } Blk20_80181EE8;
+typedef struct { s16 vx, vy, vz, pad; } Svec_80181EE8;
+
+extern Blk20_80181EE8 D_800AE620;
+extern s32 func_8012B8A4(s16 *a0);
+extern void RotMatrixY(s32 a0, void *a1);
+extern void ApplyMatrixSV(void *a0, void *a1, void *a2);
+extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5);
+extern u8 D_801152A8[];
+
+void func_80181EE8(s32 param_1)
+{
+    Svec_80181EE8 out;
+    Svec_80181EE8 sv;
+    Blk20_80181EE8 m;
+    s16 r;
+    s32 t;
+
+    m = D_800AE620;
+    t = (*(s16 *)(*(u32 *)(param_1 + 0x20) + 0x18) * 9) >> 9;
+    sv.vx = sv.vy = 0;
+    sv.vz = -t;
+    r = func_8012B8A4((s16 *)param_1);
+    RotMatrixY(r, &m);
+    ApplyMatrixSV(&m, &sv, &out);
+    out.vx += *(u16 *)(param_1 + 6);
+    out.vy += *(u16 *)(param_1 + 0xA) - t;
+    out.vz += *(u16 *)(param_1 + 0xE);
+    func_8012F568(1, 0x4002, 0, 0x14, (s32)&out, (s32)D_801152A8);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182014);
 
@@ -7566,7 +7596,7 @@ extern void func_8012C218(void *a0);
 extern void func_801439C0(void*);
 extern void func_801821E0();
 extern s32 func_80181D1C(s32 a0);
-extern void func_80181EE8(void*);
+extern void func_80181EE8();
 
 void func_801823F4(s32 param_1) {
     s32 flag;
@@ -7606,7 +7636,7 @@ void func_801824A8(void) {
 extern void func_8012CBF4(s32);
 extern s32 func_80181D1C(s32);
 extern s32 func_80181DAC(s32);
-extern void func_80181EE8(void *);
+extern void func_80181EE8();
 extern void func_80182170(s32, s32);
 extern void func_801439C0(void *);
 extern void func_8012C218(void *);
diff --git a/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c b/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
index 91b3c95406..c155ccc6a4 100644
--- a/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
+++ b/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
@@ -4755,7 +4755,43 @@ void func_8017E394(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_jr_8017AE2C", func_8017E628);
+extern void (*D_8018EE98[])(void);
+extern void func_8012C218(void *a0);
+extern s32 func_80143C74(s32 a0, s32 a1);
+extern s32 rand(void);
+
+void func_8017E628(s32 a0)
+{
+    s32 s0;
+    s32 v0;
+    s32 v1;
+
+    s0 = a0;
+    D_8018EE98[*(u16 *)(s0 + 0x2)]();
+    if (*(s16 *)(s0 + 0x102) != 0) {
+        v0 = *(s32 *)(s0 + 0x20);
+        *(u16 *)(v0 + 0x18) -= 0x80;
+        v1 = *(s32 *)(s0 + 0x20);
+        if (*(s16 *)(v1 + 0x18) < 0x100) {
+            func_8012C218((void *)s0);
+        } else {
+            *(u16 *)(v1 + 0x1A) -= 0x80;
+            v1 = *(s32 *)(s0 + 0x20);
+            *(u16 *)(v1 + 0x1C) -= 0x80;
+            if (--*(s16 *)(s0 + 0x102) == 0) {
+                *(s16 *)(s0 + 0x102) = 3;
+                s0 = func_80143C74(s0, 0);
+                if (s0 != 0) {
+                    *(s16 *)(s0 + 0x16) = -8;
+                    *(u16 *)(s0 + 0xA) -= 0x20;
+                    *(s16 *)(s0 + 0x12) = (rand() & 7) - 4;
+                    *(s16 *)(s0 + 0x1A) = (rand() & 7) - 4;
+                }
+            }
+        }
+    }
+}
+
 
 
 void func_8017E754(s32 arg0) {
diff --git a/src/ov_SC04_016/ov_SC04_016_jr_8017BEBC.c b/src/ov_SC04_016/ov_SC04_016_jr_8017BEBC.c
index 01333d035f..44e929e04c 100644
--- a/src/ov_SC04_016/ov_SC04_016_jr_8017BEBC.c
+++ b/src/ov_SC04_016/ov_SC04_016_jr_8017BEBC.c
@@ -3456,7 +3456,49 @@ void func_8017D6D8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_jr_8017BEBC", func_8017D924);
+extern void func_800D20C0();
+extern unsigned char D_801A6B00;
+extern unsigned char D_801A6B01;
+extern unsigned char D_801A6B02;
+
+void func_8017D924(s32 arg0) {
+    short sp10[3];
+    short sp18[3];
+    s32 temp;
+    register s32 color __asm__("$2");
+    u16 cnt;
+
+    sp10[0] = -0x100;
+    sp10[1] = -0x252;
+    sp10[2] = 0x60;
+    func_800D20C0(sp10, sp18, 5);
+    *(u16 *)(arg0 + 6) = sp10[0];
+    *(u16 *)(arg0 + 0xA) = sp10[1];
+    *(u16 *)(arg0 + 0xE) = sp10[2];
+    temp = *(s32 *)(arg0 + 0x1C);
+    if (temp < 0x20) {
+        color = temp * 2 - 0x80;
+    } else {
+        color = (0x20 - temp) * 2 - 0x40;
+    }
+    D_801A6B01 = color;
+    D_801A6B00 = D_801A6B02 = (u8)color >> 2;
+    *(s32 *)(arg0 + 0x1C) += 1;
+    if (*(s32 *)(arg0 + 0x1C) >= 0x40) {
+        *(s32 *)(arg0 + 0x1C) = 0;
+    }
+    if (*(s16 *)(arg0 + 0xFC) != 0) {
+        D_801A6B02 = 0xE0;
+        D_801A6B00 = 0xE0;
+        D_801A6B01 = 0xFF;
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x18) = 0x1800;
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) = 0x2000;
+        cnt = *(u16 *)(arg0 + 2);
+        *(s32 *)(arg0 + 0x1C) = 0x20;
+        *(u16 *)(arg0 + 2) = cnt + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_jr_8017BEBC", func_8017DA50);
 
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_801816DC.c b/src/ov_SC06_016/ov_SC06_016_jr_801816DC.c
index ea60a48300..35c82e89b2 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_801816DC.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_801816DC.c
@@ -3981,7 +3981,46 @@ void func_80182CE0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_801816DC", func_80182D1C);
+void func_80182D1C(void *a0)
+{
+    extern u32 D_8019FF00;
+    void *s3 = a0;
+    void *s2;
+    u32 p;
+    u32 q;
+    s32 y;
+    s32 r1;
+    u16 h;
+
+    s2 = *(void **)((s32)s3 + 0x20);
+    func_80182F44(s3);
+    p = D_8019FF00;
+    if (p != 0) {
+        h = *(u16 *)((s32)s2 + 0x12) + 0x800;
+        q = *(u32 *)((s32)p + 0x20);
+        y = h & 0xFFF;
+        if (*(u16 *)((s32)q + 0x12) & 0x400) {
+            r1 = func_80012A60(y, 0x400);
+            __asm__ __volatile__("" ::: "memory");
+            __asm__ __volatile__("" ::: "memory");
+            if (!((s16)r1 > (s16)func_80012A60(y, 0xC00))) {
+                *(s16 *)((s32)s2 + 0x12) = 0x400;
+            } else {
+                *(s16 *)((s32)s2 + 0x12) = 0xC00;
+            }
+        } else {
+            r1 = func_80012A60(y, 0);
+            if (!((s16)r1 > (s16)func_80012A60(y, 0x800))) {
+                *(s16 *)((s32)s2 + 0x12) = 0;
+                goto done;
+            }
+            *(s16 *)((s32)s2 + 0x12) = 0x800;
+        }
+    }
+done:
+    func_80171990((u8 *)s3);
+}
+
 
 
 extern s32 func_80183020();
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 37e2ddbac0..ca1a32857e 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -4921,7 +4921,46 @@ void func_8017FE9C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017FEEC);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern u16 D_801865D8;
+extern u16 D_801865DA;
+extern u16 D_801865DC;
+extern u16 D_801865DE;
+extern void D_801866C8;
+extern s16 D_80186728;
+extern s32 func_8012AD50(void *a0);
+
+void func_8017FEEC(void *a0)
+{
+    s32 ret;
+    s32 t;
+
+    ret = func_8012C1B8();
+    *(s32 *)((u8 *)a0 + 0x20) = ret;
+    if (ret == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C2C4(ret);
+
+    *(s16 *)((u8 *)a0 + 0xFE) = *(u16 *)((u8 *)&D_801865D8 + (*(s16 *)((u8 *)a0 + 0x70) << 3)) & 0xFF00;
+    t = *(u16 *)((u8 *)&D_801865D8 + (*(s16 *)((u8 *)a0 + 0x70) << 3)) & 0x7;
+    *(u16 *)((u8 *)a0 + 0x5C) = 0x8C00;
+    *(s16 *)((u8 *)a0 + 0x6) = 0;
+    *(s16 *)((u8 *)a0 + 0x102) = t;
+    *(s32 *)((u8 *)a0 + 0x58) = ((s32)((u8 *)&D_801866C8 + (t << 4))) | 0x40000000;
+
+    *(s16 *)((u8 *)a0 + 0xA) = *(u16 *)((u8 *)&D_801865DA + (*(s16 *)((u8 *)a0 + 0x70) << 3));
+    *(s16 *)((u8 *)a0 + 0xE) = *(u16 *)((u8 *)&D_801865DC + (*(s16 *)((u8 *)a0 + 0x70) << 3));
+    *(s16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x10) = *(u16 *)((u8 *)&D_801865DE + (*(s16 *)((u8 *)a0 + 0x70) << 3)) & 0xFF0;
+    *(s16 *)((u8 *)a0 + 0x104) = 0;
+    *(s32 *)((u8 *)a0 + 0x1C) = *(s16 *)((u8 *)&D_80186728 + (*(s16 *)((u8 *)a0 + 0x70) << 1));
+    func_8012AD50(a0);
+}
+
 
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8018000C);
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 efa235055d..f5bd757ad8 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
@@ -4311,7 +4311,33 @@ void func_8017DAE8(void *a0, void *a1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DC20);
+extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2);
+extern s32 func_80012ABC(s32 a0, s32 a1, s32 a2);
+
+void func_8017DC20(void *param_1, void *param_2, void *param_3) {
+    s32 pad[12];
+    s32 p1 = (s32)param_1;
+    s32 p2 = (s32)param_2;
+    s32 p3 = (s32)param_3;
+
+    *(s32 *)(p1 + 0x8)  = (s16)func_80012C6C((s32)*(s16 *)(p1 + 0x8),  (s32)*(s16 *)(p1 + 0xC),  4);
+    *(s32 *)(p1 + 0x10) = (s16)func_80012C6C((s32)*(s16 *)(p1 + 0x10), (s32)*(s16 *)(p1 + 0x14), 4);
+    *(s16 *)(p1 + 0x18) = func_80012ABC((s32)*(s16 *)(p1 + 0x18), (s32)*(s16 *)(p1 + 0x20), 4);
+    *(s16 *)(p1 + 0x1A) = func_80012ABC((s32)*(s16 *)(p1 + 0x1A), (s32)*(s16 *)(p1 + 0x22), 4);
+    *(s16 *)(p1 + 0x1C) = func_80012ABC((s32)*(s16 *)(p1 + 0x1C), (s32)*(s16 *)(p1 + 0x24), 4);
+    *(s16 *)(p1 + 0x28) = func_80012C6C((s32)*(s16 *)(p1 + 0x28), (s32)*(s16 *)(p1 + 0x2E), 0x10);
+    *(s16 *)(p1 + 0x2A) = func_80012C6C((s32)*(s16 *)(p1 + 0x2A), (s32)*(s16 *)(p1 + 0x30), 0x10);
+    *(s16 *)(p1 + 0x2C) = func_80012C6C((s32)*(s16 *)(p1 + 0x2C), (s32)*(s16 *)(p1 + 0x32), 0x10);
+
+    *(s32 *)(p1 + 0x48) = (s32)*(s16 *)(p1 + 0x28) + (s32)*(s16 *)(p3 + 0);
+    *(s32 *)(p1 + 0x4C) = (s32)*(s16 *)(p1 + 0x2A) + (s32)*(s16 *)(p3 + 2);
+    *(s32 *)(p1 + 0x50) = (s32)*(s16 *)(p1 + 0x2C) + (s32)*(s16 *)(p3 + 4);
+
+    *(s32 *)(p1 + 0x3C) = (s32)*(s16 *)(p2 + 0);
+    *(s32 *)(p1 + 0x40) = (s32)*(s16 *)(p2 + 2);
+    *(s32 *)(p1 + 0x44) = (s32)*(s16 *)(p2 + 4);
+}
+