diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 9bc1efd28..9e0ce7f09 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -76,7 +76,20 @@ void func_801A0230(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A03A4);
+extern void func_801A4328(s32 a0);
+extern void func_801A34C4(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_801EEEA0;
+
+void func_801A03A4(s32 a0) {
+    func_801A4328(2);
+    *(u16 *)(a0 + 0x5C) &= 0xDFFF;
+    func_801A34C4(a0);
+    func_8012A828(a0, &D_801EEEA0);
+    func_8012AD44((s32 *)a0, 2);
+}
+
 
 INCLUDE_RODATA("asm/md_SC07_004/nonmatchings/md_SC07_004", D_801A00D8);
 
@@ -86,17 +99,82 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A09E4);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0A98);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0C58);
+extern void func_801A36F0(void *a0);
+extern void func_801A34C4(s32 a0);
+extern void func_801A4328(s32 a0);
+extern void func_8017F9CC(void);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 rand(void);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_801EEB70;
+
+void func_801A0C58(s32 *a0)
+{
+    s32 *s0 = a0;
+    s32 v0;
+
+    func_801A36F0(s0);
+    func_801A34C4((s32)s0);
+    func_801A4328(6);
+    func_8017F9CC();
+
+    v0 = *(u16 *)((s32)s0 + 0x5C);
+    *(u16 *)((s32)s0 + 0x5C) = v0 & 0xDFFF;
+    func_8012A828((s32)s0, &D_801EEB70);
+
+    *(u16 *)((s32)s0 + 0x100) = 0;
+    *(u16 *)((s32)s0 + 0x102) = rand() & 3;
+    func_8012AD44(s0, 4);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0CD0);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0D40);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A108C);
+void func_801A108C(s32 arg0)
+{
+    extern s32 func_8012C588(s32 a0, s32 a1);
+    extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+    s32 temp;
+
+    temp = *(s32 *)(arg0 + 0x1C);
+    if (temp == (temp / 24) * 24) {
+        if (*(s16 *)(arg0 + 0x100) == *(s16 *)(arg0 + 0x102)) {
+            func_8012C658(0x34, 1, arg0);
+        } else {
+            func_8012C588(0x34, arg0);
+        }
+        *(u16 *)(arg0 + 0x100) = *(u16 *)(arg0 + 0x100) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A1124);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A115C);
+#include "common.h"
+
+extern void func_8017F184(void *a0);
+extern void func_801A4328(s32 a0);
+extern void func_801A36F0(void *a0);
+extern void func_801A34C4(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801EECB8;
+
+void func_801A115C(s32 a0) {
+    *(u16 *)(a0 + 0x5C) &= 0xDFFF;
+    func_8017F184((void *)a0);
+    func_801A4328(5);
+    func_801A36F0((void *)a0);
+    func_801A34C4(a0);
+    func_8012A828(a0, &D_801EECB8);
+    func_8012AD44((s32 *)a0, 6);
+    func_8002D4C8(0xBA5, 0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A11D4);
 
@@ -221,7 +299,14 @@ void func_801A2310(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2330);
+extern s32 D_801F871C;
+
+void func_801A2330(void) {
+    if (D_801F871C != 0) {
+        *(u16 *)(D_801F871C + 0x34) = 6;
+    }
+}
+
 
 
 s32 func_801A2350(s32 arg0) {
@@ -229,7 +314,41 @@ s32 func_801A2350(s32 arg0) {
     }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2364);
+extern void func_80178B18(s32 a0, s32 a1);
+extern void func_801A7D18(s32);
+extern void func_801A36F0(void *a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_800D0C48(u16 a0);
+extern void func_8002A088(s32 a0);
+extern void func_8002A2D4(s32 a0);
+extern void func_8002A544(s32 a0);
+extern void func_8002A7B4(s32 a0);
+extern s32 D_801AFD8C;
+extern s16 D_801F8868;
+extern s32 D_801F8720;
+
+void func_801A2364(s32 a0)
+{
+    register s32 flag __asm__("$4");
+
+    func_80178B18(a0, (s32)&D_801AFD8C);
+    flag = *(s32 *)(a0 + 0xD4);
+    *(s32 *)(a0 + 0x1C) = 0x20;
+    (*(u16 *)&D_801F8868) = 0;
+    if (flag != 0) {
+        ((void (*)(void))func_801A7D18)();
+        *(s32 *)(a0 + 0xD4) = 0;
+        func_801A36F0((void *)a0);
+    }
+    func_8012AD44((s32 *)a0, 0xF);
+    func_800D0C48(1);
+    D_801F8720 = 0;
+    func_8002A088(0x320);
+    func_8002A2D4(0x64);
+    func_8002A544(0x190);
+    func_8002A7B4(0x12C);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2400);
 
@@ -250,7 +369,14 @@ void func_801A2C68(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2C88);
+extern s16 D_801F8868;
+extern s16 D_801F886C;
+
+void func_801A2C88(void) {
+    D_801F8868 = 1;
+    D_801F886C = 0;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A2CA4);
 
@@ -327,9 +453,35 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A395C);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A39D0);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3A6C);
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void RotTransSV(s32 a0, s32 a1, void *a2);
+
+void func_801A3A6C(u8 *s0)
+{
+    s16 vec[3];           /* sp+0x10 */
+    s32 flag;             /* sp+0x18 */
+
+    func_8004914C((void *)(*(s32 *)(s0 + 0x20) + 0x34));
+    func_800491AC((void *)(*(s32 *)(s0 + 0x20) + 0x34));
+
+    vec[1] = 0x40;
+    vec[0] = 0;
+    vec[2] = -0x30;
+    RotTransSV((s32)vec, (s32)vec, &flag);
+
+    *(s16 *)(s0 + 0x6) = *(s32 *)(*(s32 *)(s0 + 0x20) + 0x48) = vec[0];
+    *(s16 *)(s0 + 0xA) = *(s32 *)(*(s32 *)(s0 + 0x20) + 0x4C) = vec[1];
+    *(s16 *)(s0 + 0xE) = *(s32 *)(*(s32 *)(s0 + 0x20) + 0x50) = vec[2];
+}
+
+
+extern s32 D_801F8864;
+
+void func_801A3B08(s32 a0) {
+    D_801F8864 = 0;
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3B08);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3B18);
 
@@ -337,9 +489,33 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3D60);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3EA8);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3EEC);
+extern u16 D_8019FF8A;
+extern s16 D_801F8860;
+
+void func_801A3EEC(s32 a0) {
+    D_801F8860 = a0;
+    D_8019FF8A |= 0x820;
+}
+
+
+extern u16 D_8019FF8A;
+extern s16 D_801F8860;
+extern s32 func_8013D13C(s16 a0);
+extern s32 func_8018184C(s16 a0);
+
+void func_801A3F10(void) {
+    if (D_8019FF8A & 0x20) {
+        if (func_8013D13C(D_801F8860) == 0) {
+            D_8019FF8A &= 0xFFDF;
+        }
+    }
+    if (D_8019FF8A & 0x800) {
+        if (func_8018184C(D_801F8860) == 0) {
+            D_8019FF8A &= 0xF7FF;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3F10);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3FB0);
 
@@ -365,9 +541,59 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A41CC);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4258);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4328);
+extern u8 D_801F8744[];
+extern u8 D_801AFEF8[];
+extern u8 D_801AFEF9[];
+extern u8 D_801AFEFA[];
+extern s16 D_801F8870;
+extern s16 D_801F8872;
+extern s16 D_801F8874;
+extern s16 D_801F8878;
+extern s16 D_801F887A;
+extern s16 D_801F887C;
+extern s16 D_801F8880;
+extern s16 D_801F8882;
+extern s16 D_801F8884;
+
+void func_801A4328(s32 a0) {
+    s32 idx;
+    s32 b0;
+    s32 b1;
+    s32 b2;
+    s32 p;
+    s32 q;
+    s32 r;
+
+    idx = a0 * 4;
+    b0 = D_801F8744[0];
+    b1 = D_801F8744[1];
+    b2 = D_801F8744[2];
+    D_801F8870 = b0 << 7;
+    D_801F8872 = b1 << 7;
+    D_801F8874 = b2 << 7;
+    p = D_801AFEF8[idx];
+    D_801F8878 = p << 7;
+    q = D_801AFEF9[idx];
+    D_801F887A = q << 7;
+    r = D_801AFEFA[idx];
+    D_801F8880 = (p - b0) << 4;
+    D_801F8882 = (q - b1) << 4;
+    D_801F887C = r << 7;
+    D_801F8884 = (r - b2) << 4;
+}
+
+
+#include "common.h"
+
+extern s32 D_801F8720;
+extern s32 func_801819CC(s32 a0);
+
+void func_801A43EC(s32 a0) {
+    if (D_801F8720 == 0) {
+        D_801F8720 = func_801819CC(a0);
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A43EC);
 
 
 
@@ -378,7 +604,26 @@ void func_801A4420(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A445C);
+extern u16 D_8019FF8A;
+extern void func_801A9C00(void *a0);
+
+void func_801A445C(void *arg0) {
+    u16 v0;
+    s32 v1;
+
+    v0 = *(u16 *)((u8 *)arg0 + 0x5C);
+    v1 = *(s16 *)((u8 *)arg0 + 0xFE);
+    *(u8 *)((u8 *)arg0 + 0xC1) = 0;
+    *(u16 *)((u8 *)arg0 + 0x5E) = 0;
+    *(u16 *)((u8 *)arg0 + 0x5C) = v0 & 0xFFFE;
+    if (v1 == 0) {
+        if ((D_8019FF8A & 0x200) == 0) {
+            func_801A9C00(arg0);
+            *(s16 *)((u8 *)arg0 + 0xFE) = 8;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A44C4);
 
@@ -449,15 +694,65 @@ void func_801A4570(void *arg0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A46B8);
+void func_801A46B8(s32 arg0) {
+    *(u16 *)(*(s32 *)(arg0 + 0xD8) + 0x5C) &= 0x7FFF;
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A46D4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A46F0);
+void func_801A46D4(s32 a0) {
+    s32 v1;
+    v1 = *(s32 *)(a0 + 0xD8);
+    *(u16 *)(v1 + 0x5C) |= 0x8000;
+}
+
+
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801A46F0(s32 *a0) {
+    s32 *v0;
+
+    v0 = *(s32 **)(((u8 *)a0) + 0x20);
+    *(s32 *)(((u8 *)a0) + 0x1C) = 0;
+    *(s16 *)(((u8 *)v0) + 0x1C) = 0;
+    *(s16 *)(((u8 *)v0) + 0x1A) = 0;
+    *(s16 *)(((u8 *)v0) + 0x18) = 0;
+    func_8012AD44(a0, 1);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4724);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4A18);
+#include "common.h"
+
+extern void func_80132288(s32 *a0, s32 *a1, s32 a2);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+extern s32 D_801F8888;
+extern s32 D_801F8898;
+extern s32 D_801B007C;
+extern s32 D_801B00B4;
+extern s32 D_801B75EC;
+extern u8 D_801B80FC[];
+
+void func_801A4A18(s32 a0)
+{
+    s16 cond;
+    s32 mirror;
+
+    cond = *(s16 *)(a0 + 0x70);
+    mirror = *(s32 *)(a0 + 0xCC);
+
+    if (cond == 0) {
+        func_80132288(&D_801F8888, &D_801B007C, D_801B75EC);
+        if (mirror != 0) {
+            func_80132288(&D_801F8898, &D_801B00B4, (*(s32 *)D_801B80FC));
+        }
+    }
+
+    *(s16 *)(a0 + 0x84) = 0;
+    func_8012AD44((s32 *)a0, 2);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4AAC);
 
@@ -521,7 +816,41 @@ void func_801A4EBC(u8 *a0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4FDC);
+#include "common.h"
+
+typedef struct { s16 vx, vy, vz, pad; } Vec16_801A4FDC;
+typedef struct { s32 vx, vy, vz, pad; } Vec32_801A4FDC;
+
+extern int rand(void);
+extern void RotTransSV(s32 a0, s32 a1, void *a2);
+extern u8 * func_801290DC(s32 a0, u8 *a1);
+extern void ApplyRotMatrixLV(void *in, void *out);
+
+void func_801A4FDC(void)
+{
+    Vec16_801A4FDC vec0;
+    Vec32_801A4FDC vec1;
+    s32 flag;
+    s32 p;
+
+    vec0.vx = (rand() & 0xFF) - 0x80;
+    vec0.vy = 0;
+    vec0.vz = -(rand() & 0x7F);
+
+    RotTransSV((s32)&vec0, (s32)&vec0, &flag);
+
+    vec0.vy = -0x200;
+    p = (s32)func_801290DC(0x22, (u8 *)&vec0);
+    if (p != 0) {
+        *(u16 *)(*(s32 *)(p + 0x20) + 0x2C) = 0xC020;
+        vec1.vx = 0;
+        vec1.vy = -0x40000;
+        vec1.vz = -(((rand() & 0xF) + 0x1C) << 16);
+        ApplyRotMatrixLV(&vec1, (void *)(p + 0x10));
+        *(s16 *)(p + 0x34) = 0x3000;
+    }
+}
+
 
 #include "common.h"
 
@@ -631,7 +960,17 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A54AC);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A54F0);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5654);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_801A5654(s32 param_1, s16 param_2, s32 param_3) {
+    s32 v0;
+
+    v0 = func_8012C658(0x339, param_3, param_1);
+    if (v0 != 0) {
+        *(s16 *)(v0 + 0xFE) = param_2;
+    }
+}
+
 
 #include "common.h"
 
@@ -685,7 +1024,14 @@ void func_801A5698(u8 *s2, s32 a1)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5798);
+void func_801A5798(s32 arg0) {
+    s32 i;
+
+    for (i = 0; i < 10; i++) {
+        func_8012C658(0x31f, i + 0x100, arg0);
+    }
+}
+
 
 #include "common.h"
 
@@ -803,7 +1149,32 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5B5C);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5C44);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5CE8);
+typedef struct { s16 vx, vy, vz, pad; } SVec_801A5CE8;
+
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void RotTransSV(s32 a0, s32 a1, void *a2);
+extern u16 D_801F885C;
+extern u8 D_801F88A8[];
+extern u8 D_801F88B0[];
+
+void func_801A5CE8(void *a0)
+{
+    SVec_801A5CE8 in;
+    SVec_801A5CE8 out;
+
+    func_8004914C((void *)(*(s32 *)((u8 *)a0 + 0x20) + 0x34));
+    func_800491AC((void *)(*(s32 *)((u8 *)a0 + 0x20) + 0x34));
+
+    in.vz = 0;
+    in.vy = 0;
+    in.vx = 0;
+    RotTransSV((s32)&in, (s32)D_801F88A8, &out);
+
+    in.vy = D_801F885C;
+    RotTransSV((s32)&in, (s32)D_801F88B0, &out);
+}
+
 
 #include "common.h"
 
@@ -947,7 +1318,26 @@ void func_801A6184(u8 *s2, s32 p1, s32 p2)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6330);
+extern u16 D_801202A0[];
+extern void func_801A63A8(void *arg0);
+
+void func_801A6330(void) {
+    u16 *p;
+    s32 i;
+
+    p = D_801202A0;
+    i = 0;
+    do {
+        if (*p == 0x31F) {
+            if (*(s16 *)(p + 0x82) == 0) {
+                func_801A63A8(p);
+            }
+        }
+        i = i + 1;
+        p = p + 0x86;
+    } while (i < 0x60);
+}
+
 
 
 /* func_801A63A8 — guard-then-free tail (cookbook §71 sibling shape:
@@ -977,13 +1367,73 @@ void func_801A63EC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6428);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_801A6428(void *a0) {
+    s32 *v1;
+
+    v1 = (s32 *)func_80132EF4((s32)a0, 0x6A);
+    if (v1 != NULL) {
+        *(s32 *)((u8 *)v1 + 0x34) = (s32)a0;
+        *(s32 *)((u8 *)v1 + 0x10) = -(*(s32 *)(*(s32 *)((u8 *)a0 + 0x64) + 0x10) >> 1);
+        *(s32 *)((u8 *)v1 + 0x18) = -(*(s32 *)(*(s32 *)((u8 *)a0 + 0x64) + 0x18) >> 1);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A649C);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A64DC);
+extern s16 D_801AFBC8;
+extern s16 D_801AFBCA;
+extern s16 D_801AFBCC;
+extern s16 D_801AFBCE;
+extern s16 D_801AFBD0;
+extern s16 D_801AFBD2;
+extern s32 D_801F871C;
+
+void func_801A64DC(s32 arg0) {
+    s32 var = D_801F871C;
+
+    *(u16 *)(arg0 + 0) = *(u16 *)(var + 6) + ((D_801AFBC8 + D_801AFBCA) >> 1);
+    *(u16 *)(arg0 + 2) = *(u16 *)(var + 0x52) + (*(u16 *)(var + 0xA) + ((D_801AFBCC + D_801AFBCE) >> 1));
+    *(u16 *)(arg0 + 4) = *(u16 *)(var + 0xE) + ((D_801AFBD0 + D_801AFBD2) >> 1);
+}
+
+
+#include "common.h"
+
+extern void func_801A5C44(void);
+extern void func_801A5B5C(void *a0);
+extern void func_801A5D68(void *a0);
+extern void func_801A5CE8(void *a0);
+extern void func_8017E5D4(void *a0);
+extern void func_8017E1E8(void *a0, void *a1, void *a2);
+
+extern u16 D_8019FF8A;
+extern u8 D_801F88A8[];
+extern u8 D_801F88B0[];
+
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801A6560(s32 arg0) {
+    func_801A5C44();
+    func_801A5B5C((void *)arg0);
+
+    if (!(D_8019FF8A & 4)) {
+        if (*(void **)(arg0 + 0xD0) != NULL) {
+            func_8017E5D4(*(void **)(arg0 + 0xD0));
+            *(void **)(arg0 + 0xD0) = NULL;
+        }
+        func_8012AD44((s32 *)arg0, 1);
+    } else {
+        func_801A5D68((void *)arg0);
+        func_801A5CE8((void *)arg0);
+        if (*(s32 *)(arg0 + 0xD0) != 0) {
+            func_8017E1E8(*(void **)(arg0 + 0xD0), D_801F88A8, D_801F88B0);
+        }
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6560);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6610);
 
@@ -1055,10 +1505,10 @@ extern void func_801A85A8(s32 a0, s32 a1, s32 a2, s32 a3);
 extern void func_801AAA6C(s32 a0);
 extern void func_801A36A8(s32 a0);
 extern void func_801A36F0(void *a0);
-extern void func_801A7C58(void *a0);
+extern void func_801A7C58();
 extern void func_801A8C58(s32 a0);
 extern void func_801A1984(s32 a0);
-extern void func_801A2364(s32 a0);
+extern void func_801A2364();
 
 void func_801A67F8(s32 a0) {
     if (((s32 (*)(s32, s32))func_801A395C)(a0, -0x250) != 0) {
@@ -1150,13 +1600,86 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6CA8);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6D90);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6DF4);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void func_8012AD50(void *a0);
+
+extern u8 D_801B80FC[];
+
+void func_801A6DF4(void *a0)
+{
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C810(v0, (s32)D_801B80FC);
+
+    *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 4) |= 0x50000040;
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x2C) |= 0x10;
+    func_8012AD50(a0);
+}
+
+
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_801A5798(s32);
+extern s32 func_80143970(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_801A53F4(void *a0);
+extern u8 D_801BA9E8[];
+extern u8 D_801EFA00[];
+
+void func_801A6E78(void *a0) {
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+    } else {
+        func_8001C214(v0, (s32)D_801BA9E8);
+        ((void (*)(void *))func_801A5798)(a0);
+        *(s32 *)((s32)a0 + 0xD0) = func_80143970((s32)a0);
+        func_8012A828((s32)a0, D_801EFA00);
+        func_801A53F4(a0);
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6E78);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6EF4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A6F3C);
+extern void func_8012AD80(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_801439C0(u8 *a0);
+extern void func_801A54AC(s32 a0);
+extern s32 D_801F8844[];
+
+void func_801A6F3C(s32 param_1) {
+    func_8012AD80(param_1);
+    *(s32 *)(param_1 + 0xF0) = *(s32 *)(param_1 + 0xF0) - 0x20000;
+    func_8012B178(param_1, *(s32 *)(param_1 + 0xF0));
+    if (func_8012BEE8(param_1) != 0) {
+        D_801F8844[*(s16 *)(param_1 + 0x70)] = 0;
+        func_8012C218((void *)param_1);
+        if (*(u8 **)(param_1 + 0xD0) != NULL) {
+            func_801439C0(*(u8 **)(param_1 + 0xD0));
+        }
+    } else {
+        func_801A54AC(param_1);
+    }
+}
+
 
 #include "common.h"
 
@@ -1195,7 +1718,32 @@ void func_801A6FD4(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A70D0);
+#include "common.h"
+
+extern u16 D_8019FF8A;
+extern s32 D_801B02B8[];
+extern void func_801A5B5C(void *a0);
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+extern int rand(void);
+extern s32 func_80128ED8(s32 a0, s32 *a1);
+
+void func_801A70D0(void *arg0) {
+    s32 s1;
+    void *s2;
+
+    s1 = *(s32 *)((u8 *)arg0 + 0xCC);
+    func_801A5B5C(arg0);
+    s2 = (u8 *)arg0 + 0xF0;
+
+    if ((D_8019FF8A & 4) && *(s16 *)((u8 *)arg0 + 0xFE) == 0xB) {
+        *(s32 *)(s1 + 4) |= 0x80000000;
+    }
+
+    if (func_80128ED8(s1, (s32 *)s2) != 0) {
+        func_80128EA8(s1, (s32)s2, D_801B02B8[rand() & 3]);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7184);
 
@@ -1374,21 +1922,77 @@ void func_801A77CC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7808);
+void func_801A7808(s32 a0, s32 a1) {
+    if (a1 != 0) {
+        *(u16 *)(a1 + 0x8) = *(u16 *)(a0 + 0x6);
+        *(u16 *)(a1 + 0xA) = *(u16 *)(a0 + 0xA);
+        *(u16 *)(a1 + 0xC) = *(u16 *)(a0 + 0xE);
+        *(u16 *)(a1 + 0x18) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x18);
+        *(u16 *)(a1 + 0x1A) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1A);
+    }
+}
+
+
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+s32 func_801A7864(void *a0, s32 a1) {
+    return func_8012C658(0x3A4, a1 & 1, (s32)a0);
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7864);
 
 INCLUDE_RODATA("asm/md_SC07_004/nonmatchings/md_SC07_004", D_801A01E8);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A788C);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7AF8);
+void func_801A7AF8(s32 a0) {
+    *(u16 *)(a0 + 2) = 1;
+    *(u16 *)(a0 + 0x2A) = 0;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7B08);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7C34);
+void func_801A7C34(s32 a0) {
+    s32 v0;
+
+    v0 = *(s32 *)(a0 + 0x20);
+    *(u16 *)(v0 + 0x1A) = 0;
+    *(u16 *)(v0 + 0x18) = 0;
+    *(s32 *)(a0 + 0x1C) = 1;
+    *(u16 *)(a0 + 0x2) = 2;
+}
+
+
+extern u8 D_801F88C8[];
+extern u8 D_801F88CA[];
+extern u8 D_801F8A38[];
+extern u8 D_801F8A3A[];
+
+void func_801A7C58(s32 a0) {
+    s32 i;
+    s32 j;
+    s32 v;
+    s32 temp;
+
+    i = 0;
+    j = 0;
+    do {
+        v = *(u16 *)(D_801F88C8 + i);
+        *(u16 *)(D_801F8A38 + j) = v;
+        v = *(u16 *)(D_801F88CA + i);
+        i += 8;
+        *(u16 *)(D_801F8A3A + j) = v;
+        j += 4;
+    } while (i < 0x30);
+
+    temp = *(s32 *)(a0 + 0x20);
+    *(s32 *)(a0 + 0x1C) = 6;
+    *(u16 *)(temp + 0x1A) = 0x400;
+    *(u16 *)(temp + 0x18) = 0x400;
+    *(u16 *)(a0 + 2) = 3;
+    *(u16 *)(a0 + 0x2C) = 0;
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7C58);
 
 
 void func_801A7CC8(void *a0) {
@@ -1397,9 +2001,36 @@ void func_801A7CC8(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7CDC);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A7D18);
+extern Blk4_801A7358 D_801F88B8;
+
+s32 func_801A7CDC(void *a0)
+{
+    void *v1;
+    s32 r;
+
+    *(s32 *)((char *)a0 + 0x30) = *(s32 *)&D_801F88B8;
+    v1 = *(void **)((char *)a0 + 0x20);
+    *(s16 *)((char *)v1 + 0x1A) = 0x2000;
+    *(s16 *)((char *)v1 + 0x18) = 0x2000;
+    v1 = *(void **)((char *)a0 + 0x20);
+    *(u16 *)((char *)v1 + 0x2C) = 0xC040;
+    *(s32 *)((char *)a0 + 0x1C) = 1;
+    __asm__("" : "=r"(r) : "0"(5));
+    *(s16 *)((char *)a0 + 2) = (s16)r;
+    return r;
+}
+
+
+void func_801A7D18(s32 arg0) {
+    s32 var;
+
+    var = *(s32 *)(arg0 + 0x20);
+    *(u16 *)(var + 0x1A) = 0x400;
+    *(u16 *)(var + 0x18) = 0x400;
+    *(u16 *)(arg0 + 0x2) = 6;
+}
+
 
 #include "common.h"
 
@@ -1642,9 +2273,43 @@ void func_801A8404(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8440);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8494);
+typedef struct { s16 x, y, z, pad; } Svec_801A8494;
+
+void func_801A8494(void *a0)
+{
+    Svec_801A8494 vec;   /* sp+0x10 : RotTransSV in/out */
+    s32 flag;            /* sp+0x18 */
+    void *t;
+
+    t = *(void **)((u8 *)a0 + 0x34);
+    func_8004914C((void *)(*(s32 *)((u8 *)t + 0x20) + 0x34));
+    func_800491AC((void *)(*(s32 *)((u8 *)t + 0x20) + 0x34));
+
+    vec.y = -0x40;
+    vec.x = 0;
+    vec.z = 0x20;
+
+    RotTransSV((s32)&vec, (s32)&vec, &flag);
+
+    *(u16 *)((u8 *)a0 + 0x06) = vec.x;
+    *(u16 *)((u8 *)a0 + 0x0A) = vec.y;
+    *(u16 *)((u8 *)a0 + 0x0E) = vec.z;
+}
+
+
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+s32 func_801A8528(s32 a0) {
+    s32 var;
+
+    var = func_80132EF4(a0, 0x30);
+    if (var != 0) {
+        *(u16 *)(var + 0x2E) = 0;
+        *(s32 *)(var + 0x34) = a0;
+    }
+    return var;
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8528);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8564);
 
@@ -1656,9 +2321,32 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8670);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A86B4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A86F8);
+extern u8 D_801F8978[3];
+extern void func_801A8738();
+
+void func_801A86F8(void) {
+    u8 *p = D_801F8978;
+    func_801A8738(p);
+    func_801A8738(&p[1]);
+    func_801A8738(&p[2]);
+}
+
+
+void func_801A8738(s32 a0) {
+    s32 v;
+    s16 c;
+
+    c = *(u8 *)a0;
+    if (c == 0xFF) {
+        return;
+    }
+    c += 2;
+    if (c > 0xFF) {
+        c = 0xFF;
+    }
+    *(u8 *)a0 = c;
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8738);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A876C);
 
@@ -1688,7 +2376,34 @@ void func_801A8954(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8990);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8A64);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern s16 D_801B03CC;
+extern u8 D_801B03CE[];
+
+void func_801A8A64(s32 a0) {
+    s16 *s0;
+    s32 s1;
+    s32 s4;
+    s32 s2 = 0;
+
+    if (D_801B03CC == 0xFFF) {
+        return;
+    }
+    s4 = 0xFFF;
+    s0 = &D_801B03CC;
+    s1 = 0;
+    do {
+        s32 ret = func_8012C658(0xC1, s2, a0);
+        if (ret != 0) {
+            *(s16 *)(*(s32 *)(ret + 0x20) + 0x12) = *(u16 *)(D_801B03CE + s1);
+            *(s16 *)(*(s32 *)(ret + 0x20) + 0x14) = *(u16 *)s0;
+        }
+        s0 += 2;
+        s1 += 4;
+        s2 += 1;
+    } while (*s0 != s4);
+}
+
 
 
 
@@ -1867,9 +2582,45 @@ void func_801A90D8(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9270);
+#include "common.h"
+
+extern int rand(void);
+extern void func_801439C0(u8 *a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s16 D_801F8E98;
+
+void func_801A9270(void *a0) {
+    s32 p;
+    s32 t;
+    s32 g;
+
+    t = (rand() & 7) + 0x50;
+    p = *(s32 *)((s32)a0 + 0xD0);
+    *(s32 *)((s32)a0 + 0x1C) = t;
+    if (p != 0) {
+        func_801439C0((u8 *)p);
+    }
+    func_8012AD44((s32 *)a0, 2);
+    func_8012C658(0x44, 1, (s32)a0);
+    g = D_801F8E98;
+    *(u16 *)((s32)a0 + 6) = *(u16 *)((s32)a0 + 6) - 0x20;
+    if (g == 0) {
+        func_8002D4C8(0xABD, 0);
+    }
+    D_801F8E98 = D_801F8E98 + 1;
+}
+
+
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801A930C(s32 arg0)
+{
+    *(s32 *)(arg0 + 0x1C) = *(s32 *)(*(s32 *)(arg0 + 0x64) + 0x1C);
+    func_8012AD44((s32 *)arg0, 3);
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A930C);
 
 
 
@@ -1893,7 +2644,19 @@ void func_801A93B8(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A93F4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9454);
+s32 func_801A9454(s32 self, s32 amount) {
+    s32 obj;
+    u16 v;
+
+    obj = func_80132EF4(self, 0x2D);
+    if (obj != 0) {
+        v = *(u16 *)(obj + 0xA);
+        *(u16 *)(obj + 0x2C) = 2;
+        *(u16 *)(obj + 0xA) = v + amount;
+    }
+    return obj;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A94A0);
 
@@ -1901,7 +2664,7 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A94A0);
 
 extern s32 func_80128ED8(s32 param_1, s32 *param_2);
 extern void func_8012AD80(s32 a0);
-extern void func_801A9810(void *a0);
+extern void func_801A9810();
 extern void func_801A9908(void *a0, s32 a1);
 extern void func_801A9954(void *a0);
 extern u16 D_801B070C[];
@@ -1958,7 +2721,39 @@ void func_801A9674(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9810);
+#include "common.h"
+
+extern void func_801439C0(u8*);
+extern void func_801AA60C(void *a0, s32 a1);
+extern void func_801A99A4(void *a0);
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+extern u8 D_801B0604[];
+extern u8 D_801B061C[];
+extern u8 D_801B0694[];
+
+void func_801A9810(void *a0) {
+    s32 s1;
+
+    s1 = *(s32 *)((s32)a0 + 0xCC);
+    if (*(s32 *)((s32)a0 + 0xD0) != 0) {
+        ((void (*)(s32))func_801439C0)(*(s32 *)((s32)a0 + 0xD0));
+        *(s32 *)((s32)a0 + 0xD0) = 0;
+    }
+    if (*(s16 *)((s32)a0 + 0xFE) != 0) {
+        func_801AA60C(a0, 0xAB7);
+        func_801A99A4(a0);
+        func_80128EA8(s1, (s32)a0 + 0xF0, (s32)D_801B061C);
+    } else {
+        func_80128EA8(s1, (s32)a0 + 0xF0, (s32)D_801B0694);
+    }
+    *(s32 *)(s1 + 0x20) = (s32)D_801B0604;
+    *(s16 *)(s1 + 0x28) = 0x340;
+    *(s16 *)(s1 + 0x2A) = 0x100;
+    func_8012AD44((s32 *)a0, 2);
+}
+
 
 
 
@@ -1971,11 +2766,33 @@ void func_801A98CC(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9908);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9954);
+extern void func_801439C0(u8 *a0);
+extern void func_80016714(void *a0, s32 a1);
+extern void func_8012C218(void *a0);
+
+void func_801A9954(void *arg0) {
+    void *temp_a0;
+
+    temp_a0 = *(void **)((char *)arg0 + 0xD0);
+    if (temp_a0 != NULL) {
+        func_801439C0(temp_a0);
+    }
+    temp_a0 = *(void **)((char *)arg0 + 0xCC);
+    func_80016714(temp_a0, 0x38);
+    func_8012C218(arg0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A99A4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9AAC);
+void func_801A9AAC(void) {
+    extern void func_80128D60(s32, s32 *, s32 *);
+    extern s32 D_801F8A50;
+    extern s32 D_801B0748;
+
+    func_80128D60(0, &D_801F8A50, &D_801B0748);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9ADC);
 
@@ -1988,7 +2805,18 @@ void func_801A9B04(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9B40);
+extern void StoreImage(s32, void *);
+
+void func_801A9B40(void *a0, u16 a1, u16 a2) {
+    u16 buf[4];
+
+    buf[2] = 0x10;
+    buf[0] = a1;
+    buf[1] = a2;
+    buf[3] = 1;
+    StoreImage((s32)&buf, (void *)a0);
+}
+
 
 extern void func_800599B8(void*, void*);
 
@@ -2122,7 +2950,25 @@ void func_801A9FC8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA004);
+
+typedef struct { s32 vx, vy, vz; } Vec32_801AA004;
+
+extern Mtx32_801A90D8 D_800AE620;
+extern void RotMatrixY(s32 a0, void *a1);
+extern void func_800484EC(s32 a0, s32 a1, s32 a2);
+
+void func_801AA004(void *arg0, void *arg1)
+{
+    Vec32_801AA004 off;
+
+    *(Mtx32_801A90D8 *)arg1 = D_800AE620;
+    RotMatrixY(-*(s16 *)(*(s32 *)((s32)arg0 + 0x20) + 0x14), arg1);
+    off.vy = 0;
+    off.vx = 0;
+    off.vz = 0xFFE40000;
+    func_800484EC((s32)arg1, (s32)&off, (s32)arg0 + 0x10);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA0B4);
 
@@ -2136,11 +2982,43 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA3CC);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA4A8);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA4EC);
+s32 func_801AA4EC(s32 param_1, s32 param_2)
+{
+    if (func_8012DF34(param_1, param_2, param_2 + 8) == 0) {
+        return func_8012DF34(param_1, param_2, param_2 + 0x10) != 0;
+    }
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA540);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA584);
+extern s32 func_8012DEB8(s32 a0, s32 a1, s32 a2);
+
+s32 func_801AA584(s32 a0) {
+    s16 local_10[3]; /* sp+0x10 */
+    s16 local_18[3]; /* sp+0x18 */
+    s32 v0;
+
+    local_18[0] = 0x18;
+    local_10[0] = 0x18;
+    local_18[1] = -0x30;
+    local_10[1] = 0;
+    local_18[2] = -0x20;
+    local_10[2] = -0x20;
+
+    v0 = func_8012DEB8(a0, (s32)local_10, (s32)local_18);
+
+    if (v0 == 0) {
+        local_18[0] = -0x18;
+        local_10[0] = -0x18;
+        v0 = func_8012DEB8(a0, (s32)local_10, (s32)local_18);
+        return (v0 != 0) ? 1 : 0;
+    }
+
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA60C);
 
@@ -2230,7 +3108,28 @@ void func_801AA7E4(u8 *s2)
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA91C);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA9D4);
+void func_801AA9D4(s32 a0, s32 a1) {
+    extern u8 *func_8012913C(s32 a0);
+
+    typedef struct { u16 w0, w1, w2, w3; } Blk8;
+
+    s32 work;
+    s32 ptr;
+
+    work = (s32)func_8012913C(0x71);
+
+    if (a0 != 0) {
+        *(u16 *)(work + 0x6) = *(u16 *)(a0 + 0x6);
+        *(u16 *)(work + 0xA) = *(u16 *)(a0 + 0xA);
+        *(u16 *)(work + 0xE) = *(u16 *)(a0 + 0xE);
+        ptr = *(s32 *)(work + 0x20);
+        *(Blk8 *)(ptr + 0x10) = *(Blk8 *)a1;
+        *(u16 *)(work + 0x30) = 5;
+        *(u16 *)(work + 0x32) = 1;
+        *(u32 *)(work + 0x34) = 0x180F0F0;
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AAA6C);
 
@@ -2635,7 +3534,7 @@ extern u8 D_801F88F9;
 extern u8 D_801F88FA;
 
 extern void func_8012AD80(s32 a0);
-extern void func_801A7808(void *a0, void *a1);
+extern void func_801A7808();
 extern s32 func_8012BEE8(s32 a0);
 extern void func_8012AD50(void *a0);
 
@@ -2695,13 +3594,62 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB818);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB8C0);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB9AC);
+extern u16 D_8019FF8A;
+extern void func_801A8884(s32 *a0);
+extern void func_801A88AC(s32 a0);
+extern void func_801A8990(s32 a0);
+
+void func_801AB9AC(s32 arg0) {
+    s32 v1;
+
+    v1 = D_8019FF8A;
+    if (!(v1 & 1)) {
+        func_801A8884(arg0);
+    } else if (v1 & 0x400) {
+        func_801A88AC(arg0);
+    }
+
+    *(u16 *)(arg0 + 0x104) = *(u16 *)(*(s32 *)(arg0 + 0x64) + 6);
+    *(u16 *)(arg0 + 0x106) = *(u16 *)(*(s32 *)(arg0 + 0x64) + 0xA);
+    *(u16 *)(arg0 + 0x108) = *(u16 *)(*(s32 *)(arg0 + 0x64) + 0xE);
+    func_801A8990(arg0);
+
+    if (*(s16 *)(arg0 + 0xFE) < 0x28) {
+        *(s16 *)(arg0 + 0xFE) = *(s16 *)(arg0 + 0xFE) + 2;
+    }
+    *(u16 *)(arg0 + 0x100) += 0x28;
+    *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x10) += *(u16 *)(arg0 + 0x102);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ABA74);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ABBA4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ABC04);
+#include "common.h"
+
+extern u8 D_801B03F4[];
+extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3);
+extern int rand(void);
+
+void func_801ABC04(void *a0) {
+    s32 t;
+    u16 h;
+
+    func_8001CC3C(*(s32 *)((s32)a0 + 0x20), (s32)D_801B03F4, 0x2F8, 0x1C0);
+
+    *(u32 *)(*(s32 *)((s32)a0 + 0x20) + 4) |= 0x58000000;
+
+    h = (rand() & 0xF8) | 0x200;
+    t = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)(t + 0x1A) = h;
+    *(u16 *)(t + 0x18) = h;
+
+    *(u8 *)(*(s32 *)((s32)a0 + 0x20) + 0x27) = 0x55;
+
+    *(u16 *)((s32)a0 + 2) += 1;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ABC8C);
 
@@ -2715,7 +3663,7 @@ extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3);
 extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
 extern s32 func_80143994(s32 a0, s32 a1);
 extern void func_801A90D8();
-extern void func_801A930C(void *a0);
+extern void func_801A930C();
 
 extern u8 D_801B0408[];
 extern u8 D_801B0414[];
@@ -2827,7 +3775,31 @@ void func_801ABEE0(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ABFF8);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC0D4);
+#include "common.h"
+
+extern s32 func_80128ED8(s32 param_1, s32 *param_2);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80016714(void *a0, s32 a1);
+extern void func_8012C218(void *a0);
+
+void func_801AC0D4(void *arg0) {
+    void *s0;
+    s16 val;
+
+    s0 = *(void **)((char *)arg0 + 0xCC);
+    func_80128ED8((s32)s0, (s32 *)((char *)arg0 + 0xF0));
+
+    val = *(s16 *)((char *)s0 + 0x1A);
+    if (val >= 0x1801) {
+        *(s16 *)((char *)s0 + 0x1A) = val - 0x400;
+    }
+
+    if (func_8012BEE8((s32)arg0) != 0) {
+        func_80016714(*(void **)((char *)arg0 + 0xCC), 0x38);
+        func_8012C218(arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC150);
 
@@ -2991,7 +3963,29 @@ void func_801AC794(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC8B8);
+
+
+extern void func_8001CD9C(s32, s32);
+extern int rand(void);
+extern Blk4_801A7358 D_801F88B8;
+
+void func_801AC8B8(s32 param_1)
+{
+    s32 t;
+    s32 ptr;
+
+    *(u16 *)(param_1 + 0x2C) = 0;
+    func_8001CD9C(*(s32 *)(param_1 + 0x20), (s32)&D_801F88B8);
+    *(u32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x50000000;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) = 0xC020;
+    t = (rand() & 0x1F0) + 0x500;
+    ptr = *(s32 *)(param_1 + 0x20);
+    *(u16 *)(ptr + 0x1A) = t;
+    *(u16 *)(ptr + 0x18) = t;
+    *(s32 *)(param_1 + 0x1C) = 0x14;
+    *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC940);
 
@@ -3054,7 +4048,37 @@ void func_801ACD10(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ACD4C);
+#include "common.h"
+
+extern void func_800599B8(void *, void *);
+extern u8 D_801F8B18;
+
+void func_801ACD4C(void) {
+    u16 sp10[4];
+    u16 *base;
+    u16 *p;
+    s32 i;
+    u16 first;
+    u16 t;
+
+    base = (u16 *) &D_801F8B18;
+    first = base[0];
+    i = 0;
+    p = base;
+    do {
+        t = p[1];
+        i++;
+        p[0] = t;
+        p++;
+    } while (i < 0x5E);
+    base[i] = first;
+    sp10[0] = 0x100;
+    sp10[1] = 0x1E0;
+    sp10[2] = 0x100;
+    sp10[3] = 1;
+    func_800599B8(sp10, (void *) &D_801F8B18);
+}
+
 
 
 
@@ -3065,7 +4089,10 @@ void func_801ACDC8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ACE04);
+s32 func_801ACE04(s32 arg0) {
+    return *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) >= 0x801;
+}
+
 
 
 
@@ -3091,7 +4118,7 @@ extern void func_80016450(s32 a0, s32 a1);
 /* same-TU, still INCLUDE_ASM stubs in md_SC07_004.c (lines 1544 / 1614); no declaration
    exists anywhere in the tree, so these are free choice -- rawest form (law 4). */
 extern void func_801ADE1C(void *a0, u16 *a1, s8 *a2, u8 *a3);
-extern void func_801AD220(void *a0, void *a1);
+extern void func_801AD220();
 
 extern u8 D_801B07F0[];
 extern u8 D_801F8A98[];
@@ -3179,11 +4206,50 @@ void func_801AD1E4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD220);
+void func_801AD220(s32 a0, s32 a1) {
+    s32 v0;
+    s16 v1;
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD294);
+    if (a1 != 0) {
+        v0 = *(s32 *)(a0 + 0x64);
+        *(u16 *)(a1 + 8) = *(u16 *)(v0 + 6);
+        v0 = *(s32 *)(a0 + 0x64);
+        *(u16 *)(a1 + 0xA) = *(u16 *)(v0 + 0xA) - 0x40;
+        v0 = *(s32 *)(a0 + 0x64);
+        *(u16 *)(a1 + 0xC) = *(u16 *)(v0 + 0xE) + 0x20;
+        v1 = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18);
+        v0 = v1 * 3;
+        *(u16 *)(a1 + 0x18) = v0;
+        *(u16 *)(a1 + 0x1A) = v0;
+    }
+}
+
+
+extern u8 D_801B07F0[];
+extern u8 D_801B07F2[];
+extern u8 D_801F8A78[];
+extern void func_801A649C();
+
+void func_801AD294(void) {
+    func_801A649C(D_801F8A78, *(u16 *)D_801B07F0, *(u16 *)D_801B07F2);
+}
+
+
+
+extern u8 D_801B07F0[];
+
+void func_801AD2CC(void) {
+    extern u8 D_801B07F2[];
+    extern u8 D_801F8A78[];
+    Rec8_801A57E8 rect;
+
+    rect.c = 0x10;
+    rect.d = 1;
+    rect.a = *(u16 *)D_801B07F0;
+    rect.b = (*(u16 *)D_801B07F2);
+    func_800599B8(&rect, D_801F8A78);
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD2CC);
 
 INCLUDE_RODATA("asm/md_SC07_004/nonmatchings/md_SC07_004", D_801A021C);
 
@@ -3198,7 +4264,18 @@ void func_801AD4C0(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD4D4);
+void func_801AD4D4(void *a0) {
+    extern void func_801AD55C(void *a0);
+    extern void func_801AD700();
+    extern void func_8002D4C8(s32 a0, s32 a1);
+
+    func_801AD55C(a0);
+    func_801AD700(a0);
+    *(s32 *)((char *)a0 + 0x1c) = 0x10;
+    *(s16 *)((char *)a0 + 0x2) = 0x2;
+    func_8002D4C8(0xBA3, 0);
+}
+
 
 
 
@@ -3209,9 +4286,46 @@ void func_801AD520(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD55C);
+void func_801AD55C(void *a0) {
+    void *a1;
+
+    a1 = *(void **)((char *)a0 + 0x34);
+    if (a1 != NULL) {
+        *(u16 *)((char *)a0 + 0x6) = *(u16 *)((char *)a1 + 0x6) + *(u16 *)((char *)a1 + 0x50);
+        *(u16 *)((char *)a0 + 0xA) = *(u16 *)((char *)a1 + 0xA) + *(u16 *)((char *)a1 + 0x52) - 0x40;
+        *(u16 *)((char *)a0 + 0xE) = *(u16 *)((char *)a1 + 0xE) + *(u16 *)((char *)a1 + 0x54);
+    }
+}
+
+
+#include "common.h"
+
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern s32 rand(void);
+extern u16 D_801B0828[];
+
+void func_801AD5B4(s32 param_1, s32 param_2) {
+    s32 s2;
+    s32 s0;
+    s32 s1;
+    s32 r;
+    s32 b;
+
+    s2 = param_1;
+    s0 = param_2;
+    s1 = func_80132EF4(param_1, 0x2F);
+
+    if (s1 != 0) {
+        r = rand();
+        s0 = s0 & 3;
+        b = D_801B0828[s0] - 0x40;
+        *(u16 *)(s1 + 0x2C) = b + (r & 0x7C);
+        r = rand();
+        *(u16 *)(s1 + 0x2E) = s0 + ((r & 3) << 12);
+        *(s32 *)(s1 + 0x34) = s2;
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD5B4);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD640);
 
@@ -3237,7 +4351,7 @@ typedef struct {
     s16 z;
 } Struct801AD7EC_Local;
 
-extern void func_801AD914(s32 a0, Struct801AD7EC_Local *a1, s32 a2);
+extern void func_801AD914();
 
 void func_801AD7EC(s32 a0) {
     /* register pins reproduce the target's density-priority regalloc order
@@ -3284,7 +4398,45 @@ void func_801AD7EC(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD914);
+#include "common.h"
+
+/* decl_prior: fleet-modal ('void', ('s32',)), n=2449 -- identical to this TU's own
+ * declarations at md_SC07_004.c:993/1107. */
+extern void func_8012B2CC(s32 a0);
+/* atlas tu-authoritative: ('s32', ('s32','s32','s32')) n=1337; same as this TU's
+ * existing decl at md_SC07_004.c:353. */
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+/* atlas fleet: ('s32', ('s32','s32','s32')) n=3554 */
+extern void func_800484EC(s32, s32, s32);
+
+/* 8-byte, 2-byte-aligned struct -> emit_block_move lwl/lwr + swl/swr (cookbook §48-C2,
+ * same idiom as func_801A6AD0 above in this TU). */
+typedef struct { u16 a, b, c, d; } Blk8_801AD914;
+
+/* 12-byte arg-block built at sp+0x10 for the func_800484EC call */
+typedef struct { s32 f10, f14, f18; } S12_801AD914;
+
+void func_801AD914(s32 arg0, void *arg1, s32 arg2) {
+    void *sp0;
+    S12_801AD914 sp10;
+    s32 inner;
+
+    sp0 = (void *)func_8012C658(0x3A1, 1, arg0);
+    if (sp0 != NULL) {
+        *(Blk8_801AD914 *)(*(s32 *)((s32)sp0 + 0x20) + 0x10) = *(Blk8_801AD914 *)arg1;
+        func_8012B2CC((s32)sp0);
+        sp10.f18 = 0;
+        sp10.f10 = 0;
+        sp10.f14 = arg2;
+        ((s32 (*)(s32, s32, s32))func_800484EC)(*(s32 *)((s32)sp0 + 0x20) + 0x34, (s32)&sp10, (s32)sp0 + 0x10);
+        inner = *(s32 *)((s32)sp0 + 0x20);
+        *(u16 *)(inner + 0x1C) = 0x500;
+        *(u16 *)(inner + 0x1A) = 0x500;
+        *(u16 *)(inner + 0x18) = 0x500;
+        *(s32 *)((s32)sp0 + 0x1C) = 0x20;
+    }
+}
+
 
 
 
@@ -3596,7 +4748,35 @@ void func_801AE220(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE324);
+#include "common.h"
+
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8012AD50(void *a0);
+
+extern u8 D_801F2D48[];
+
+void func_801AE324(void *a0) {
+    s32 v0;
+    s32 v1;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+    func_8001C214(v0, (s32)&D_801F2D48);
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(s16 *)(v1 + 0x2C) = *(u16 *)(v1 + 0x2C) | 0x10;
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(s16 *)(v1 + 0x1C) = 1;
+    *(s16 *)(v1 + 0x1A) = 1;
+    *(s16 *)(v1 + 0x18) = 1;
+    func_8012AD50(a0);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE3A4);
 
@@ -3656,9 +4836,65 @@ void func_801AE408(void *a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE520);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE624);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void func_8012AD50(void *a0);
+
+extern u8 D_801F07E0[];
+
+void func_801AE624(void *a0) {
+    register void *s0 __asm__("$16");
+    register s32 v0 __asm__("$2");
+    s32 p;
+    s32 q;
+    s32 r;
+
+    s0 = a0;
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)s0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(s0);
+        return;
+    }
+    func_8001C810(v0, (s32)D_801F07E0);
+
+    p = *(s32 *)((s32)s0 + 0x20);
+    *(s32 *)(p + 4) |= 0x50000000;
+
+    q = *(s32 *)((s32)s0 + 0x20);
+    *(u16 *)(q + 0x2C) |= 0x10;
+
+    r = *(s32 *)((s32)s0 + 0x20);
+    *(s16 *)(r + 0x18) = *(s16 *)(r + 0x1A) = *(s16 *)(r + 0x1C) = 0x300;
+
+    if (*(s32 *)((s32)s0 + 0x1C) == 0) {
+        *(s32 *)((s32)s0 + 0x1C) = 0x18;
+    }
+    func_8012AD50(s0);
+}
+
+
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_8012AD80(s32 a0);
+extern void func_8012B414(s32 a0);
+
+void func_801AE6D4(void *arg0) {
+    if (func_8012BEE8((s32)arg0) != 0) {
+        func_8012C218(arg0);
+    } else {
+        func_8012AD80((s32)arg0);
+        if (*(s16 *)((u8 *)arg0 + 0x70) == 0) {
+            func_8012B414((s32)arg0);
+        }
+    }
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE6D4);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE734);
 
@@ -3666,9 +4902,71 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE82C);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE8B0);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE908);
+extern void func_801ADA10();
+extern void func_801AEAE4();
+extern void func_801292C8(u8 *a0);
+
+void func_801AE908(void *a0) {
+    register s32 p __asm__("$4");
+    u16 t;
+
+    p = *(s32 *)((s32)a0 + 0x34);
+    t = *(u16 *)(p + 0xC) - 0x400;
+    *(u16 *)(p + 0xC) = t;
+    *(u16 *)(p + 0x10) = t;
+    if (*(s16 *)(p + 0xC) > 0) {
+        *(s32 *)((s32)a0 + 0x1C) -= 1;
+        if (*(s32 *)((s32)a0 + 0x1C) & 1) {
+            func_801ADA10(a0);
+        }
+    } else {
+        func_801AEAE4();
+        func_801292C8((u8 *)a0);
+    }
+}
+
+
+extern void func_80016714(void *a0, s32 a1);
+
+typedef struct {
+    u16 a, b, c, d;
+} U16x4;
+
+extern U16x4 D_801F8EA0[];
+extern u16 D_801F8EA2;
+extern u16 D_801F8EA4;
+
+void func_801AE990(void *a0) {
+    U16x4 *dst;
+    s32 i;
+    u8 *p;
+
+    dst = D_801F8EA0;
+
+    if (a0 != NULL) {
+        *dst = *(U16x4 *)a0;
+    } else {
+        D_801F8EA4 = 0;
+        D_801F8EA2 = 0;
+        *(u16 *)dst = 0;
+    }
+
+    *(u16 *)((u8 *)dst + 0xC) = 0x1000;
+    *(u16 *)((u8 *)dst + 0xA) = 0x1000;
+    *(u16 *)((u8 *)dst + 0x8) = 0x1000;
+    *(u16 *)((u8 *)dst + 0x14) = 0;
+    *(u16 *)((u8 *)dst + 0x12) = 0;
+    *(u16 *)((u8 *)dst + 0x10) = 0;
+
+    p = (u8 *)dst + 0x18;
+    i = 0;
+    do {
+        func_80016714(p, 0x24);
+        i++;
+        p += 0x24;
+    } while (i < 0x20);
+}
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AE990);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AEA40);
 
@@ -3687,7 +4985,12 @@ s32 func_801AEAAC(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AEAE4);
+extern void func_80016714(void *a0, s32 a1);
+
+void func_801AEAE4(void *a0) {
+    func_80016714(a0, 0x24);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AEB04);
 
diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c b/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
index cf49fb2c9..50505876e 100644
--- a/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
+++ b/src/ov_SC02_017/ov_SC02_017_jr_8017DF34.c
@@ -3407,7 +3407,33 @@ void func_8017F2F4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8017F330);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8017F3B0);
+extern s32 D_8018E140;
+extern s16 D_8018E19A[];
+extern s32 D_8018E0B8;
+extern s32 func_8017F474(s32 a0);
+
+void func_8017F3B0(s32 param_1) {
+    s16 v0;
+
+    func_80019064(&D_8018E140);
+    func_8017F4AC(param_1);
+    if (func_8017F474(param_1) != 0) {
+        v0 = *(s16 *)(param_1 + 0x210);
+        switch (D_8018E19A[v0 << 2]) {
+        case 0:
+            break;
+        case 1:
+            func_800D1724(&D_8018E0B8);
+            break;
+        case 2:
+            func_80171928(param_1);
+            return;
+        }
+        *(s16 *)(param_1 + 0x210) = *(u16 *)(param_1 + 0x210) + 1;
+        func_8017F474(param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8017F474);
 
@@ -3485,7 +3511,41 @@ void func_8017F644(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8017F66C);
+void func_8017F66C(void) {
+
+    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 u8 D_80126948[];
+    extern s16 D_801274EA;
+    extern s16 D_801EF9F0;
+    extern void func_8017F72C(void *);
+    extern void func_8012A018(s32, s32);
+    extern void func_8012A094(s32);
+
+    D_80126954 = 0x1F4;
+    D_80126950 = 0x1F4;
+    D_8012695C = 0x4B0;
+    D_80126968 = 0x1C7;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x10;
+    D_8012697A = 0;
+    D_801EF9F0 = 0;
+    func_8012A018((s32)func_8017F72C, 0);
+    func_8012A094((s32)D_80126948);
+    func_8017F72C((void *)D_80126948);
+    func_8012A094((s32)D_80126948);
+    D_801EF9F0 = D_801274EA;
+}
+
 
 
 extern void (*D_8018E1CC[])(void);
@@ -3882,15 +3942,98 @@ void func_80180084(s32 p) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180270);
+extern s32 func_801805D4();
+extern s32 func_80180610();
+extern void func_80178CBC(s32 a0, s32 a1);
+extern s32 D_8018E294[];
+extern s32 D_8018E2A4[];
+extern s32 D_8018E2B8;
+extern s32 D_8018E2C0;
+extern s32 D_8018E2CC;
+extern u8 D_8018E2E0[];
+
+void func_80180270(void *arg0) {
+    if (func_801805D4(arg0) != 1) {
+        *(u16 *)((s32)arg0 + 2) = 5;
+        D_8018E2B8 = D_8018E294[*(u16 *)((s32)arg0 + 0x70) & 0xF];
+        D_8018E2C0 = *(s16 *)((s32)arg0 + 0x70);
+        D_8018E2CC = D_8018E2A4[func_80180610()];
+        func_80178CBC((s32)arg0, (s32)D_8018E2E0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180304);
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180398);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180410);
+#include "common.h"
+
+extern void RotTransSV(void *a0, void *a1, void *a2);
+
+/* not declared anywhere in src/ or include/ */
+extern u8 D_8018E27C[];
+
+#define gte_SetRotMatrix(r0) __asm__ volatile (         \
+    "lw $12, 0( %0 );"                                   \
+    "lw $13, 4( %0 );"                                   \
+    "ctc2 $12, $0;"                                      \
+    "ctc2 $13, $1;"                                      \
+    "lw $12, 8( %0 );"                                   \
+    "lw $13, 12( %0 );"                                  \
+    "lw $14, 16( %0 );"                                  \
+    "ctc2 $12, $2;"                                      \
+    "ctc2 $13, $3;"                                      \
+    "ctc2 $14, $4"                                       \
+    :                                                    \
+    : "r"( r0 )                                          \
+    : "$12", "$13", "$14" )
+#define gte_SetTransMatrix(r0) __asm__ volatile (        \
+    "lw $12, 20( %0 );"                                  \
+    "lw $13, 24( %0 );"                                  \
+    "ctc2 $12, $5;"                                      \
+    "lw $14, 28( %0 );"                                  \
+    "ctc2 $13, $6;"                                      \
+    "ctc2 $14, $7"                                       \
+    :                                                    \
+    : "r"( r0 )                                          \
+    : "$12", "$13", "$14" )
+
+void func_80180410(s32 a0, s32 a1, s32 a2)
+{
+    s32 *m;
+    s32 sv[2];      /* sp+0x10 */
+
+    m = (s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x34);
+
+    gte_SetRotMatrix(m);
+    gte_SetTransMatrix(m);
+
+    RotTransSV(D_8018E27C, (void *)a1, sv);
+    RotTransSV(D_8018E27C + 8, (void *)a2, sv);
+}
+
+
+extern void (*D_8018E254[])(void);
+extern s32 func_8012CEB0(s32 a0, s32 a1, s32 a2);
+extern void func_8012B260(u8 *a0);
+
+s32 func_801804A8(s32 a0, s32 a1, s32 a2) {
+    s32 s0;
+
+    s0 = a0;
+    if (func_8012CEB0(a1, a2, 1) & 0x2000) {
+        *(u16 *)(s0 + 0xFE) = 0;
+        *(s32 *)(s0 + 0x58) = (s32)D_8018E254 | 0x40000000 | 0x20000000;
+        *(u16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) + 0x83;
+        func_8012B260((u8 *)s0);
+        *(s32 *)(s0 + 0x1C) = 3;
+        *(s32 *)(s0 + 0xE0) = 0;
+        return 1;
+    }
+    return 0;
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801804A8);
 
 extern s16 func_80174764(void);
 s32 func_80180530(void) {
@@ -4060,7 +4203,21 @@ s32 func_8018096C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801809A8);
+extern s32 D_8018E39C[];
+extern void func_8012C218(void *a0);
+
+void func_801809A8(void *arg0) {
+    typedef void (*FuncPtr)(void);
+    FuncPtr fn;
+
+    fn = (FuncPtr)D_8018E39C[*(u16 *)((char *)arg0 + 2)];
+    fn();
+
+    if (*(s16 *)((char *)arg0 + 0xFC) != *(s16 *)(*(s32 *)((char *)arg0 + 0x64) + 0x36)) {
+        func_8012C218(arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180A10);
 
@@ -4157,9 +4314,57 @@ void func_80180EB0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180EF4);
+extern void func_8012C1B8(void);
+extern void func_8001C214(s32, s32);
+extern s32 func_8012C51C(void *a0, s32 a1);
+extern void func_8012CAE4(void *a0);
+extern void func_8012C218(void *a0);
+extern u8 D_8018E3B0[];
+
+void func_80180EF4(void *arg0) {
+    s32 v0;
+    s32 v1;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)arg0 + 0x20) = v0;
+    if (v0 == 0) goto cae4;
+    func_8001C214(v0, 0);
+    v0 = func_8012C51C(D_8018E3B0, (s32)arg0);
+    *(s32 *)((s32)arg0 + 0xCC) = v0;
+    if (v0 == 0) goto cae4;
+    v1 = func_8012C51C(D_8018E3B0 + 0x14, (s32)arg0);
+    *(s32 *)((s32)arg0 + 0xD0) = v1;
+    if (v1 != 0) goto set;
+    func_8012C218((void *)*(s32 *)((s32)arg0 + 0xCC));
+cae4:
+    func_8012CAE4(arg0);
+    goto end;
+set:
+    *(s16 *)((s32)arg0 + 0x02) = 1;
+end:;
+}
+
+
+extern s32 rand(void);
+
+void func_80180F8C(s32 param_1) {
+    s32 a0 = *(s32 *)(param_1 + 0xCC);
+    s32 v1 = *(s32 *)(param_1 + 0xD0);
+
+    if ((*(s32 *)(a0 + 0xDC) == 0) && (*(s32 *)(v1 + 0xDC) == 0)) {
+        if (*(s16 *)(param_1 + 0xFC) == 0) {
+            *(s32 *)(a0 + 0xDC) = 1;
+            *(u16 *)(param_1 + 0xFC) += 1;
+            *(s16 *)(param_1 + 2) = 2;
+        } else {
+            *(s32 *)(v1 + 0xDC) = 1;
+            *(u16 *)(param_1 + 0xFC) = 0;
+            *(s16 *)(param_1 + 2) = 3;
+        }
+        *(s32 *)(param_1 + 0x1C) = rand() % 5 + 16;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80180F8C);
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018104C);
 
@@ -4502,7 +4707,31 @@ void func_80181974(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801819B0);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012CAE4(void *a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern s32 D_8018E490;
+extern u8 aD8018A800[] __asm__("D_8018A800");
+
+void func_801819B0(s32 s0)
+{
+    if (func_8012C354(s0, (s32)&D_8018E490) == 0) {
+        return;
+    }
+    if (func_8012C588(0xB4, s0) == 0 || func_8012C658(0xB5, *(s16 *)(s0 + 0x70), s0) == 0) {
+        func_8012CAE4((void *)s0);
+        return;
+    }
+    func_8001D0E8(*(s32 *)(s0 + 0x20), 0x1E0, 0x168);
+    func_8012A828(s0, (void *)aD8018A800);
+    *(u8 *)(s0 + 0x75) = 2;
+    *(u16 *)(s0 + 0x2) = 1;
+    *(u16 *)(s0 + 0xA) -= 0x70;
+}
+
 
 void func_80181A54(void) {
 }
@@ -4538,7 +4767,20 @@ void func_80181B80(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80181BBC);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80181C58);
+void func_80181C58(s32 arg0) {
+    typedef struct { u8 b[8]; } Blk8;
+    extern s32 rand(void);
+    s32 v0;
+    s32 v1;
+
+    v0 = *(s32 *)(arg0 + 0x64);
+    v1 = *(s32 *)(arg0 + 0x20);
+    v0 = *(s32 *)(v0 + 0x20);
+    *(Blk8 *)((u8 *)v1 + 0x10) = *(Blk8 *)((u8 *)v0 + 0x10);
+    *(s16 *)(arg0 + 0x2) = 2;
+    *(s32 *)(arg0 + 0x1C) = rand() % 30 + 0x2D;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80181CF0);
 
@@ -4572,7 +4814,24 @@ void func_801822A0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801822DC);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32, s32);
+extern u8 D_8018E574[];
+
+void func_801822DC(s32 arg0) {
+    s32 v0 = ((s32 (*)(s32))func_8012C1B8)(arg0);
+    *(s32*)((u8*)arg0 + 0x20) = v0;
+    if (v0 == 0) {
+        ((void (*)(s32))func_8012CAE4)(arg0);
+    } else {
+        func_8001C214(v0, 0);
+        *(s16*)((u8*)arg0 + 0x2) = 1;
+        *(s16*)((u8*)arg0 + 0x5C) = 0x40;
+        *(s32*)((u8*)arg0 + 0x58) = ((u32)&D_8018E574 + (((*(u16*)((u8*)arg0 + 0x70)) & 0xF) << 4));
+    }
+}
+
 
 void func_80182354(void) {
 }
@@ -4648,7 +4907,37 @@ void func_80182678(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801826C4);
+#include "common.h"
+
+extern void func_8012C1B8(void);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+/* not declared anywhere in this TU -- typed by access width */
+extern u8 D_801EAB44[];
+extern u8 D_8118E5E4[];
+
+void func_801826C4(s32 a0) {
+    register s32 s1 asm("$17") = a0;
+    register s32 s0 asm("$16");
+    u16 v0;
+
+    v0 = *(u16 *)(s1 + 0x72);
+    v0 = v0 | 0x1000;
+    *(u16 *)(s1 + 0x72) = v0;
+
+    s0 = ((s32 (*)(void))func_8012C1B8)();
+
+    *(s32 *)(s1 + 0x20) = s0;
+
+    if (s0 != 0) {
+        func_8001C214(s0, (s32)D_801EAB44);
+        *(s32 *)(s0 + 0x20) = (s32)D_8118E5E4;
+        *(s32 *)(s0 + 0x4) = *(s32 *)(s0 + 0x4) | 0x80000000;
+        func_8012AD50((void *)s1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80182744);
 
@@ -4658,7 +4947,24 @@ extern s32 func_8018287C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801827C4);
+typedef struct { u8 b[8]; } Blk8_801827C4;
+
+extern Blk8_801827C4 D_801EE3F4;
+extern u16 D_800B99DA;
+extern void func_80182938(void *arg0);
+extern void func_801829F4(u8*, u8*);
+
+void func_801827C4(void *arg0) {
+    Blk8_801827C4 buffer;
+
+    buffer = D_801EE3F4;
+    func_80182938(arg0);
+
+    if ((D_800B99DA & 3) == 0) {
+        ((void (*)(void *, void *))func_801829F4)(arg0, &buffer);
+    }
+}
+
 
 
 
@@ -4680,7 +4986,18 @@ INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018287
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80182938);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801829F4);
+void func_801829F4(u8 *a0, u8 *a1) {
+    u16 temp[3];
+
+    temp[0] = *(u16 *)(a0 + 0x6);
+    temp[1] = *(u16 *)(a0 + 0xA);
+    temp[2] = *(u16 *)(a0 + 0xE);
+
+    temp[0] += *(u16 *)(a1 + 0x0);
+    temp[1] += *(u16 *)(a1 + 0x2);
+    temp[2] += *(u16 *)(a1 + 0x4);
+}
+
 
 
 extern void (*D_8018E780[])(void);
@@ -4922,7 +5239,26 @@ void func_801832F4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183330);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018337C);
+extern s32 D_8018EAA0;
+extern void (*D_8018E9E4[])(void);
+extern s32 func_8018347C();
+
+void func_8018337C(s32 arg0)
+{
+    s32 s1;
+
+    s1 = func_80029504();
+    if (((s32 (*)(s32 *, s32, s32))func_8018347C)((s32 *)arg0, 0x190, 0x200) == 0) {
+        return;
+    }
+    if (s1 >= 0x10E) {
+        func_80178B18(arg0, (s32)&D_8018EAA0);
+    } else {
+        func_80178B18(arg0, (s32)D_8018E9E4);
+    }
+    func_8012AD50((void *)arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801833FC);
 
@@ -4954,7 +5290,26 @@ void func_801836F0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018372C);
+#include "common.h"
+
+extern void func_8012E88C(u8 *a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B23C(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+extern void (*D_8018EEB4[])(void);
+
+void func_8018372C(void *a0) {
+    *(u16 *)((s32)a0 + 2) = 2;
+    func_8012E88C((u8 *)a0);
+    func_8012B2CC((s32)a0);
+    func_8012B23C((s32)a0);
+    func_8012B14C((s32)a0, (s32)D_8018EEB4);
+    *(s32 *)((s32)a0 + 0x1C) = 0x16;
+    func_8002D4C8(0x5D8, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183790);
 
@@ -5026,9 +5381,44 @@ int func_80183984(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801839A8);
+extern void func_80029514(s32);
+extern void func_800D0F4C(s32 a0);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_801839A8(void *arg0) {
+    func_8012C658(0x121, 0, (s32)arg0);
+    func_8012C658(0x121, 1, (s32)arg0);
+    func_8012C658(0x121, 2, (s32)arg0);
+    func_8012C658(0x121, 3, (s32)arg0);
+    func_800D0F4C(0x4E);
+    func_800D0F4C(0x50);
+    func_800D0F4C(0x51);
+    func_800D0F4C(0x52);
+    func_80029514(0x50);
+    *(s32 *)((s32)arg0 + 0x1C) = 0x5A;
+}
+
+
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
+
+s32 func_80183A3C(s32 arg0) {
+    if (func_8012BEE8(arg0) != 0) {
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12) = 0x806;
+        return 1;
+    }
+    if ((*(s32 *)(arg0 + 0x1C) & 7) >= 4) {
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) +
+            func_8012B608(*(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12), 0x5E0, 2);
+    } else {
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) +
+            func_8012B608(*(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12), 0x9E0, 2);
+    }
+    return 0;
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183A3C);
 
 extern void func_80029124(s32 arg0, s32 arg1);
     extern void func_801472F0(void *a0);
@@ -5055,7 +5445,7 @@ INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183C3
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183C6C);
 
 extern s32 func_8012BEE8(s32);
-    extern void func_8018372C(s32);
+    extern void func_8018372C();
     void func_80183D30(s32 arg0) {
         if (func_8012BEE8(arg0)) {
             func_8018372C(arg0);
@@ -5063,7 +5453,23 @@ extern s32 func_8012BEE8(s32);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183D68);
+extern u16 D_8018EEC0;     /* lhu */
+extern u16 D_8018EEC2;     /* lhu */
+extern u16 D_8018EEC4;     /* lhu */
+extern void func_80183790(s32 a0);
+extern void func_8012AD80(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_80183D68(s32 param_1) {
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) += D_8018EEC0;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) += D_8018EEC2;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) += D_8018EEC4;
+    func_8012AD80(param_1);
+    if (func_8012BEE8(param_1) != 0) {
+        func_80183790(param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183DFC);
 
@@ -5127,13 +5533,91 @@ void func_80183E70(s32 param_1) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80183FA8);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184084);
+extern void func_8012BD14(s32 a0);
+extern s32 func_80178BF8();
+extern void func_80172710(void);
+
+s32 func_80184084(void *a0)
+{
+    s32 ptr;
+    u16 st;
+
+    ptr = *(s32 *)((s32)a0 + 0x64);
+    st = *(u16 *)((s32)ptr + 0x2);
+    if (st != 1) {
+        return 0;
+    }
+
+    if (((s32 (*)(void))func_8012BD14)() >= 0x5100) {
+        return 0;
+    }
+
+    {
+        s32 p;
+        u16 st2;
+        p = *(s32 *)((s32)a0 + 0x64);
+        st2 = *(u16 *)((s32)p + 0x2);
+        st2++;
+        *(u16 *)((s32)p + 0x2) = st2;
+    }
+    func_80178BF8();
+    return (s32)func_80172710;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801840F8);
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018413C);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018416C);
+#include "common.h"
+
+extern void func_8013CB84(void);
+extern void func_80184208(void);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801EFCAC;
+extern s32 D_801EFCB0;
+
+void func_8018416C(void) {
+    s32 v0;
+    s32 v1;
+
+    func_8013CB84();
+    func_80184208();
+
+    v1 = D_801EFCB0;
+
+    if (v1 == 1) goto L_handle_v0_1;
+
+    if (v1 >= 2) {
+        return;
+    }
+
+    if (v1 != 0) {
+        return;
+    }
+
+    // v1 == 0
+    func_8002D4C8(0x618, 0);
+    v0 = D_801EFCB0;
+    v0++;
+    D_801EFCB0 = v0;
+    return;
+
+L_handle_v0_1:
+    v0 = D_801EFCAC;
+    v0++;
+    D_801EFCAC = v0;
+
+    if (v0 < 0x97) {
+        return;
+    }
+
+    func_8002D4C8(0xD, 0x618);
+    v0 = D_801EFCB0;
+    v0++;
+    D_801EFCB0 = v0;
+}
+
 
 extern s32 D_801EFA00;
 extern u16 D_8018EEF4[];
@@ -5260,7 +5744,39 @@ void func_80184510(void) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184518);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018457C);
+extern void func_8012AD80(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_8018457C(s32 param_1) {
+    s32 v0;
+    s32 p1;
+    s32 v1;
+    u16 a1;
+    u16 a2;
+    s32 a3;
+
+    v0 = *(s32 *)(param_1 + 0x20);
+    *(u16 *)(v0 + 0x10) += 0x40;
+    p1 = *(s32 *)(param_1 + 0x20);
+    if (*(s16 *)(p1 + 0x10) >= 0x401) {
+        *(u16 *)(p1 + 0x10) = 0x400;
+    }
+    func_8012AD80(param_1);
+    if (func_8012BEE8(param_1) != 0) {
+        v1 = *(u16 *)(param_1 + 0x88);
+        a1 = *(u16 *)(param_1 + 0x8A);
+        a2 = *(u16 *)(param_1 + 0x8C);
+        a3 = *(s32 *)(param_1 + 0x20);
+        *(s16 *)(param_1 + 0x2) = 2;
+        *(u16 *)(param_1 + 0x6) = v1;
+        *(u16 *)(param_1 + 0xA) = a1;
+        *(u16 *)(param_1 + 0xE) = a2;
+        *(u16 *)(a3 + 0x10) = 0;
+        func_8012B2CC(param_1);
+    }
+}
+
 
 void func_8018461C(void *a0) {
         *(s16 *)((s32)a0 + 0x2) = 0x5;
@@ -5440,7 +5956,29 @@ void func_80184B18(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184BA4);
+#include "common.h"
+
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8012B2CC(s32 a0);
+extern s32 func_80143970(s32 a0);
+
+extern s32 D_801D0C6C;
+extern s32 D_801D0CA0;
+
+void func_80184BA4(s32 param_1) {
+    if (func_8012C354(param_1, (s32)&D_801D0C6C) != 0) {
+        *(u8 *)(param_1 + 0xC0) = 1;
+        *(s32 *)(param_1 + 0xBC) = (s32)&D_801D0CA0;
+        *(s32 *)(param_1 + 0xB4) = 0xFFFBDFD9;
+        *(s32 *)(param_1 + 0xDC) = 0;
+        *(s16 *)(param_1 + 0x100) = 0x1000;
+        *(s32 *)(param_1 + 0xC4) |= 1;
+        func_80143970(param_1);
+        *(s16 *)(param_1 + 2) = 1;
+        func_8012B2CC(param_1);
+    }
+}
+
 
 
 
@@ -5506,7 +6044,17 @@ void func_80184C58(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184D28);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 rand(void);
+extern u8 D_801D5AD4[];
+
+void func_80184D28(s32 a0) {
+    *(s16 *)(a0 + 2) = 4;
+    func_8012A828(a0, (void *)&(*(u8 *)D_801D5AD4));
+    *(s32 *)(a0 + 0x1C) = rand() % 17 + 0x28;
+    *(u16 *)(a0 + 0x52) = 0;
+}
+
 
 extern s32 func_8012BEE8(s32 arg);
     void func_80184D9C(void *a0) {
@@ -5516,7 +6064,29 @@ extern s32 func_8012BEE8(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184DD0);
+extern void func_8012B23C(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_80078EAE;
+extern u8 D_801D5BC4[];
+
+void func_80184DD0(void *a0) {
+    s32 s0 = (s32)a0;
+    s32 v0;
+
+    func_8012B23C(s0);
+    func_8012B178(s0, 0xFFFE0000);
+    func_8012A828(s0, D_801D5BC4);
+    *(s32 *)(s0 + 0x1C) = 0x96;
+    v0 = D_80078EAE;
+    if (v0 != 0) {
+        v0 = 6;
+    } else {
+        v0 = 7;
+    }
+    *(s16 *)(s0 + 2) = (s16)v0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80184E38);
 
@@ -5668,9 +6238,50 @@ void func_80185320(void *a0)
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80185338);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80185364);
+extern void func_801859C4(s32 a0);
+extern s32 func_80185B5C();
+
+void func_80185364(s32 a0) {
+    if (*(s32 *)(a0 + 0x1C) == *(s32 *)(a0 + 0x1C) / 5 * 5) {
+        func_801859C4(a0);
+    }
+    if (*(s32 *)(a0 + 0x1C) >= 0xB) {
+        ((void (*)(s32))func_80185B5C)(a0);
+    }
+}
+
+
+#include "common.h"
+
+extern void func_8001C924(s32 a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018A428(s32 a0, u16 *a1, s16 a2);
+extern u8 D_801D29A8;
+extern u8 D_801D29B8;
+
+void func_801853DC(s32 param_1) {
+    s32 temp_a0;
+    s32 v1;
+    u16 sp10[3];
+
+    temp_a0 = *(s32 *)(param_1 + 0x20);
+    if (*(s32 *)(temp_a0 + 0x24) == (s32)&D_801D29B8) {
+        func_8001C924(temp_a0, &D_801D29A8);
+    }
+    *(s32 *)(param_1 + 0x1C) = 0x18;
+    *(s32 *)(param_1 + 0xDC) &= ~0x10;
+    v1 = *(u16 *)(param_1 + 0x5E);
+    if (v1 == 0x23) {
+        *(u16 *)(param_1 + 0xFE) = 1;
+        func_8002D4C8(0xAA1, 0);
+    } else if (v1 == 0x24) {
+        sp10[0] = 0;
+        sp10[1] = 0x10;
+        sp10[2] = 0;
+        func_8018A428(param_1, sp10, 0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801853DC);
 
 extern s32 func_80185B5C();
 extern void func_801859C4(s32 a0);
@@ -5834,9 +6445,45 @@ void func_80185680(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80185768);
+extern void func_8001C924(s32 a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+
+extern u8 D_801D4358;
+extern u8 D_801D5FBC;
+
+void func_80185768(s32 param_1) {
+    *(s32 *)(param_1 + 0x1C) = 0x37;
+    func_8001C924(*(s32 *)(param_1 + 0x20), &D_801D4358);
+    func_8012A828(param_1, &D_801D5FBC);
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(u16 *)(param_1 + 0x62);
+}
+
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8002AC00(s32 arg0);
+extern void func_80130D48(s32 arg0);
+extern void func_80185EE4(s32 a0);
+
+void func_801857C4(s32 a0)
+{
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+
+    v0 = *(s32 *)(a0 + 0x1C);
+    if (v0 < 0x11) {
+        v0 = *(s32 *)(a0 + 0x20);
+        v1 = *(s32 *)(v0 + 0x4);
+        v1 = v1 ^ 0x80000000;
+        *(s32 *)(v0 + 0x4) = v1;
+    }
+
+    if (func_8012BEE8(a0) != 0) {
+        func_8002AC00(0xB);
+        func_80130D48(a0);
+        func_80185EE4(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801857C4);
 
 #include "common.h"
 
@@ -6014,7 +6661,23 @@ extern s32 rand(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80185CA4);
+#include "common.h"
+
+extern s32 func_8014CB0C(void);
+extern s32 rand(void);
+
+void func_80185CA4(s32 a0) {
+    if (func_8014CB0C() != 0) {
+        *(s32 *)(a0 + 0xDC) |= 0x20;
+    } else {
+        if ((rand() & 1) != 0) {
+            *(s32 *)(a0 + 0xDC) |= 0x20;
+        } else {
+            *(s32 *)(a0 + 0xDC) &= ~0x20;
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -6142,7 +6805,20 @@ void func_80186168(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018626C);
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern short D_801E154C;
+
+void func_8018626C(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 5;
+    *(s16 *)(a0 + 0x34) = 0;
+    *(u16 *)(a0 + 0x5C) = 0xAA10;
+    func_8012A828(a0, &D_801E154C);
+    func_8012B23C(a0);
+}
+
 
 #include "common.h"
 #include "/home/musashi/bfm-decomp/src/shared/engine_core.h"
@@ -6204,7 +6880,30 @@ extern void func_8012A828(s32, void*);
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80186530);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801866C8);
+extern void func_8012A828(s32 a0, void *a1);
+extern s16 D_801E1AFC;
+extern s16 D_801E11DC;
+extern s16 D_801E1264;
+
+void func_801866C8(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 3;
+    if (*(u16 *)(a0 + 0x86) & 2) {
+        *(s16 *)(a0 + 0x34) = 1;
+        *(s32 *)(a0 + 0x1C) = 0x28;
+        if (*(u16 *)(a0 + 0x70) & 0x200) {
+            func_8012A828(a0, &D_801E1AFC);
+        } else {
+            func_8012A828(a0, &D_801E11DC);
+        }
+        *(u16 *)(a0 + 0xFE) = 0;
+    } else {
+        *(s16 *)(a0 + 0x34) = 0;
+        func_8012A828(a0, &D_801E1264);
+        *(s32 *)(a0 + 0x1C) = 0x19;
+        *(u16 *)(a0 + 0x86) |= 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80186770);
 
@@ -6264,7 +6963,30 @@ void func_80186C38(int param_1, int param_2) {
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80186C64);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80186FA8);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern s16 D_801E1AFC;
+extern char D_801D61C4[];
+
+void func_80186FA8(s32 a0) {
+    u8 *tbl;
+
+    tbl = (u8 *)D_801D61C4;
+    if (!(*(u16 *)(a0 + 0x70) & 0x2000)) {
+        tbl += 0xC;
+    }
+    *(s16 *)(a0 + 0x2) = 7;
+    if (*(u16 *)(a0 + 0x70) & 0x200) {
+        func_8012A828(a0, &D_801E1AFC);
+    } else {
+        func_8012A828(a0, (void *)*(s32 *)tbl);
+    }
+    func_8012B200((u8 *)a0);
+    func_8012B178(a0, *(s32 *)(tbl + 4));
+    *(s32 *)(a0 + 0x1C) = *(s32 *)(tbl + 8);
+}
+
 
 #include "common.h"
 
@@ -6437,9 +7159,44 @@ void func_801874E8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801876AC);
+extern void (*D_801D61E4[])(void);
+extern s32 func_8012C044(s32 a0);
+extern void func_8012C098(void);
+
+void func_801876AC(u16 *s0)
+{
+    s32 v0;
+
+    D_801D61E4[s0[1]]();
+    v0 = func_8012C044((s32)s0);
+    if (v0 != 0) {
+        *(u16 *)((char *)s0 + 0x100) = 1;
+        ((void (*)(s32))func_8012C098)((s32)s0);
+    }
+}
+
+
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+extern void func_80186BF0(s32 a0, s32 a1, s32 a2, s32 a3);
+extern u8 D_801E190C[];
+extern short D_801E0FEC;
+
+void func_80187710(s32 a0) {
+    if (*(u16 *)(a0 + 0x72) & 0x4000) {
+        *(s16 *)(a0 + 0x100) = 3;
+        if (func_8012BD3C(a0, 0x400, 0x40000) != 0) {
+            func_80186BF0(a0, 5, 30, (s32)D_801E190C);
+        } else {
+            *(s16 *)(a0 + 2) = 2;
+            *(s16 *)(a0 + 0x34) = 0;
+            func_8012A828(a0, (void *)&D_801E0FEC);
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80187710);
 
 
 extern void func_8012A828(s32, void*);
@@ -6450,7 +7207,22 @@ extern void func_8012A828(s32, void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801877C0);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+
+void func_801877C0(s32 a0) {
+    s32 state;
+
+    if (*(s16 *)(a0 + 0x100) == 0) {
+        state = 0xB;
+    } else {
+        if (func_8012BD3C(a0, 0x400, 0x40000) == 0) {
+            return;
+        }
+        state = 0xD;
+    }
+    *(s16 *)(a0 + 0x2) = state;
+}
+
 
 
 extern void func_8012A828(s32, void*);
@@ -6504,7 +7276,30 @@ void func_801878A8(s32 param_1)
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80187940);
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801879A4);
+#include "common.h"
+
+extern void func_80186124(void);
+extern void func_8012CBF4(s32 a0);
+extern void func_80131E00();
+extern void func_801862B8(s32 a0);
+
+void func_801879A4(s32 a0) {
+    s32 ret;
+
+    if (*(s16 *)(a0 + 0xA) >= 0x10) {
+        func_80186124();
+    } else {
+        ret = ((s32 (*)(s32))func_8012CBF4)(a0);
+        if ((ret & 0x2000) != 0) {
+            if ((ret & 0x1000) != 0) {
+                ((void (*)(s32, s32))func_80131E00)(a0, 0x12);
+            } else {
+                func_801862B8(a0);
+            }
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80187A24);
 
@@ -6722,7 +7517,20 @@ extern void func_8012C098(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80187F18);
+void func_80187F18(s32 arg0) {
+    s16 sp10[3];
+
+    if (*(u16 *)(arg0 + 0x5E) == 0x23) {
+        *(u16 *)(arg0 + 0xFE) = 1;
+        func_8002D4C8(0xAA1, 0);
+    } else if (*(u16 *)(arg0 + 0x5E) == 0x24) {
+        sp10[0] = 2;
+        sp10[1] = 0xF;
+        sp10[2] = -2;
+        func_8018A428(arg0, (u16 *)sp10, 0xD);
+    }
+}
+
 
 
 /* func_80187F84 — light/colour ramp-up on the entity's attached prim block.
@@ -6810,7 +7618,38 @@ void func_801880F4(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80188104);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80131E00();
+
+void func_80188104(s32 param_1) {
+    register s32 a __asm__("$4");
+    s32 p;
+    s32 q;
+    s32 x;
+    s32 t;
+    u16 h;
+
+    if (func_8012BEE8(param_1) != 0) {
+        p = *(s32 *)(param_1 + 0x20);
+        h = *(u16 *)(param_1 + 0x100);
+        *(s16 *)(p + 0x1C) = h;
+        *(s16 *)(p + 0x18) = h;
+        a = param_1;
+        *(s16 *)(a + 0x5C) |= 1;
+        *(s16 *)(a + 0x60) = 0;
+        q = *(s32 *)(a + 0x20);
+        *(s16 *)(a + 0x62) = *(u16 *)(q + 0x12) + 0x800;
+        *(s16 *)(a + 0x5E) = 1;
+        ((void (*)(s32, s32))func_80131E00)(a, 1);
+    } else {
+        a = *(s32 *)(param_1 + 0x20);
+        x = *(s16 *)(a + 0x18);
+        t = x + (*(s16 *)(param_1 + 0x100) - x) / 4;
+        *(s16 *)(a + 0x1C) = t;
+        *(s16 *)(a + 0x18) = t;
+    }
+}
+
 
 
 // @class: plumbing
@@ -6967,7 +7806,21 @@ void func_801884F8(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_8018855C);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B178(s32 a0, s32 a1);
+
+void func_8018855C(u8 *a0) {
+    u8 *p = *(u8 **)(a0 + 0x20);
+    u16 v = *(u16 *)(a0 + 0xFC);
+    *(s16 *)(a0 + 0x2) = 2;
+    *(s32 *)(a0 + 0x1C) = 0x50;
+    *(s16 *)(p + 0x12) = v;
+    func_8012B2CC((s32)a0);
+    func_8012B200(a0);
+    func_8012B178((s32)a0, 0xFFF20000);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_801885B4);
 
@@ -6984,7 +7837,24 @@ extern s32 func_8012BEE8(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8017DF34", func_80188800);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_80188800(s32 param_1)
+{
+    s32 r, d;
+
+    r = ((s32 (*)(void))func_8012BEE8)();
+    if (r == 1) {
+        __asm__ ("" ::: "memory");
+        d = param_1;
+        if (*(s16 *)(param_1 + 0x70) & 0x8000) {
+            func_80188280(d, 0x40000, 0xC4000);
+        } else {
+            func_80188280(d, 0x9000, 0x24000);
+        }
+    }
+}
+
 
 
 // @class: plumbing
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
index 7c0aeb12b..c71a0aa5d 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
@@ -3437,7 +3437,27 @@ void func_8017ECD8(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017ED60);
+extern void func_80149020(s32 *a0);
+extern void func_8017EDC4(s32 a0);
+extern void func_80159B3C(void *a0);
+extern void func_80165718(s32 a0);
+extern s32 func_80172630(u8 *a0);
+
+void func_8017ED60(s32 *a0)
+{
+    u8 temp;
+    func_80149020(a0);
+    temp = *(u8 *)((char *)a0 + 0xDE);
+    *(u8 *)((char *)a0 + 0xDE) = temp + 0xFF;
+    if (temp == 0) {
+        func_8017EDC4((s32)a0);
+        func_80159B3C(a0);
+        func_80165718((s32)a0);
+    } else {
+        func_80172630((u8 *)a0);
+    }
+}
+
 
 extern u8 D_80062C04[];
 extern void func_80019064(void *a0);
@@ -3579,7 +3599,22 @@ void func_8017F2A8(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017F2C4);
+#include "common.h"
+
+extern void func_80149374(s32 a0, s32 a1);
+
+void func_8017F2C4(s32 *a0)
+{
+    s32 arg;
+
+    a0[1] = a0[4];
+    arg = a0[13];
+    a0[2] = a0[5];
+    a0[3] = a0[6];
+
+    func_80149374(arg, (s32)(a0 + 1));
+}
+
 
 extern void (*D_80193FBC[])(void);
 
@@ -3702,7 +3737,25 @@ void func_8017F340(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017F614);
+#include "common.h"
+
+extern void func_8017F6D8(s32 arg0);
+extern void func_8017F85C(s32*);
+extern s32 func_80146E98(s32 a0);
+extern void func_80146E90(s32 *a0, s32 a1);
+
+void func_8017F614(s32 param_1) {
+    func_8017F6D8(param_1);
+    ((void (*)(s32))func_8017F85C)(param_1);
+    if (func_80146E98(param_1) != 0) {
+        *(s32 *)(param_1 + 0x10) = *(s32 *)(param_1 + 0x10) >> 2;
+        *(s32 *)(param_1 + 0x14) = *(s32 *)(param_1 + 0x14) >> 2;
+        *(s32 *)(param_1 + 0x18) = *(s32 *)(param_1 + 0x18) >> 2;
+        func_80146E90((s32 *)param_1, 0x40);
+        *(u16 *)(param_1 + 2) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017F690);
 
@@ -3716,7 +3769,18 @@ void func_8017F6D8(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017F700);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017F85C);
+void func_8017F85C(s32 *a0) {
+    s32 *p;
+
+    a0[1] += a0[4];
+    a0[2] += a0[5];
+    a0[3] += a0[6];
+    p = (s32 *)a0[8];
+    *(u16 *)((s32)p + 0x10) += (u16)a0[0x13];
+    *(u16 *)((s32)p + 0x12) += (u16)a0[0x14];
+    *(u16 *)((s32)p + 0x14) += (u16)a0[0x15];
+}
+
 
 void func_8017F8D0(s32 *a0) {
         *(s32 *)((s32)a0 + 0x0) = 0x80404080;
@@ -3975,7 +4039,17 @@ void func_8017FD68(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8017FDF0);
+extern s32 func_8012E544(s32 a0);
+extern void func_80171928(void *a0);
+extern u8 D_800AE6BD;
+
+void func_8017FDF0(void *a0) {
+    if (func_8012E544(0x3AF) == 0) {
+        D_800AE6BD = D_800AE6BD + 1;
+        func_80171928(a0);
+    }
+}
+
 
 extern s32 D_801942DC;
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
@@ -4245,7 +4319,27 @@ void func_801803D8(s32 param_1, s16 *param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180570);
+void func_80180570(s32 arg0) {
+
+    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;
+
+    D_80126954 = *(s16 *)((s32)arg0 + 0x0);
+    D_8012695C = *(s16 *)((s32)arg0 + 0x2);
+    D_80126968 = *(u16 *)((s32)arg0 + 0x4);
+    D_8012696A = *(u16 *)((s32)arg0 + 0x6);
+    D_8012696C = *(u16 *)((s32)arg0 + 0x8);
+    D_80126976 = *(u16 *)((s32)arg0 + 0xC);
+    D_80126978 = *(u16 *)((s32)arg0 + 0xE);
+    D_8012697A = *(u16 *)((s32)arg0 + 0x10);
+}
+
 
 
 
@@ -4288,7 +4382,24 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180660);
+extern void func_8012BEE8(u8 *a0);
+extern void func_8013C9C4(void *a0);
+
+s32 func_80180660(void *param)
+{
+    extern u8 D_80190B88[];
+    void *s0 = param;
+
+    if (((s32 (*)(s32))func_8012BEE8)((s32)s0) != 0) {
+        return 1;
+    }
+    if ((*(s32 *)((char *)s0 + 0x1C) & 0xF) != 0) {
+        return 0;
+    }
+    func_8013C9C4(D_80190B88);
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801806B8);
 
@@ -4310,7 +4421,17 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801807C
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801808EC);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180930);
+extern void func_801833D4(int a0, int a1);
+extern s32 func_80183A28(u8 *a0);
+
+s32 func_80180930(u8 *a0) {
+    if (((s32 (*)(int, int))func_801833D4)((int)a0, 0x20) != 0) {
+        return 1;
+    }
+    func_80183A28(a0);
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180970);
 
@@ -4899,7 +5020,7 @@ L_end:
 
 extern void func_80132EC4(s32 a0, s32 a1);
 extern void func_8018637C(s32 arg0, s32 arg1);
-extern void func_80186EBC(s32 a0);
+extern void func_80186EBC();
 extern void func_8012AD44(s32 *a0, s16 a1);
 extern void func_800D0C48(s32 a0);
 extern void func_8002AC00(s32 arg0);
@@ -4967,9 +5088,9 @@ extern s32 D_801EFD18;
 
 /* §183 SIGNATURE-cast-at-call: the TU DEFINES `void func_8018B2F8(s32 *, s32)` (L7882). */
 extern void func_8018B2F8(s32 *a0, s32 a1);
-extern void func_8018B830(void *a0);
+extern void func_8018B830();
 extern void func_80016450(s32 a0, s32 a1);
-extern void func_80189410(void);
+extern void func_80189410();
 extern void func_8018B8C0(void *a0);
 extern s32  func_80143970(s32 a0);
 extern void func_8017CC2C(void);
@@ -5146,7 +5267,22 @@ ret:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183258);
+extern s16 func_80174774(void);
+extern void func_80186EBC();
+
+s32 func_80183258(s32 a0) {
+    s32 v0;
+
+    if (((s32 (*)(void))func_80174774)() != 0) {
+        v0 = *(s32 *)((s32)a0 + 0x20);
+        *(s32 *)(v0 + 4) |= 0x80000000;
+        func_80186EBC(a0);
+        return 1;
+    }
+
+    return 0;
+}
+
 
 extern void func_800D1724(s32 a0);
 extern s32 D_80194270;
@@ -5444,7 +5580,26 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183BD
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183BF0);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183C74);
+extern void func_80185960(s32 target, u16 *cur, s32 step);
+extern s32 func_8012B6D4(s16 *a0, s16 *a1);
+extern u8 D_80126B5C;
+extern s32 D_801EFC48;
+
+void func_80183C74(s32 a0, u16 a1)
+{
+    s32 id;
+    s32 v;
+
+    v = func_8012B6D4((s16 *)(a0 + 4), (s16 *)&D_80126B5C);
+    id = v & 0xFFF;
+    if (id < 0x800) {
+        id = (id < 0x221) ? id : 0x220;
+    } else {
+        if (id < 0xDE0) id = 0xDE0;
+    }
+    func_80185960(id, (u16 *)(*(s32 *)(D_801EFC48 + 0x20) + 0x12), a1);
+}
+
 
 void func_80183CF4(void *a0) {
         *(s16 *)((s32)a0 + 0x108) = 0;
@@ -5815,9 +5970,29 @@ void func_80184728(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184840);
+void func_80184840(void) {
+    extern s32 D_801EFC48;
+    extern s32 D_801EFC4C;
+    extern s32 D_801EFC54;
+    register s32 p __asm__("$4");
+    s32 obj;
+
+    p = D_801EFC4C;
+    *(s16 *)(p + 0x76) = 0x240;
+    *(s16 *)(D_801EFC48 + 0x76) = 0x1000;
+    p = D_801EFC54;
+    obj = *(s32 *)(p + 0x20);
+    *(s16 *)(obj + 0x1C) = 0x1000;
+    *(s16 *)(obj + 0x1A) = 0x1000;
+    *(s16 *)(obj + 0x18) = 0x1000;
+}
+
+
+s32 func_80184884(void) {
+    extern s32 D_801EFC4C;
+    return *(s16 *)(D_801EFC4C + 0x76);
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184884);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018489C);
 
@@ -5933,7 +6108,22 @@ s32 func_80184978(s32 arg0, s32 arg1, s32 arg2)
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184ABC);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184B3C);
+void func_80184B3C(void *a0)
+{
+    s16 *wp = (s16 *)((s32)a0 + 0xE4);
+    s32 i;
+
+    if (*(u8 *)((s32)a0 + 0x10A) != 1) {
+        for (i = 0; i < 4; i++) {
+            *wp++ = *(u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x10);
+            *wp++ = *(u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x12);
+            *wp++ = *(u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x14);
+        }
+        *(u8 *)((s32)a0 + 0x10B) = 0;
+        *(u8 *)((s32)a0 + 0x10A) = 1;
+    }
+}
+
 
 #include "common.h"
 
@@ -6029,9 +6219,37 @@ void func_80184DB8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184F4C);
+extern s16 D_801EFD30[];
+extern u16 D_801EFD3C;
+extern s32 func_80184FC4(s32 arg0);
+
+s32 func_80184F4C(void) {
+    s32 i;
+    s32 ok;
+
+    ok = 1;
+    for (i = 0; i < D_801EFD3C; i++) {
+        ok = ok & func_80184FC4(D_801EFD30[i]);
+    }
+    return ok;
+}
+
+
+extern s32 aFC4C[] __asm__("D_801EFC4C");
+
+s32 func_80184FC4(s32 idx) {
+    s32 obj;
+    s32 sub;
+
+    obj = aFC4C[idx];
+    sub = *(s32 *)(obj + 0x20);
+    if (*(s16 *)(sub + 0x10) != *(s16 *)(obj + 0xE4) ||
+        *(s16 *)(sub + 0x12) != *(s16 *)(obj + 0xE6)) {
+        return 0;
+    }
+    return *(s16 *)(sub + 0x14) == *(s16 *)(obj + 0xE8);
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184FC4);
 
 #include "common.h"
 
@@ -6140,7 +6358,30 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801853D
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185648);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801858DC);
+#include "common.h"
+
+extern u16 D_801EFD40;
+extern void func_80185960(s32 target, u16 *cur, s32 step);
+
+void func_801858DC(void *a0)
+{
+    u16 step;
+    u16 flag;
+
+    flag = D_801EFD40;
+    step = 0x20;
+    if (flag & 0x20) {
+        step = 0x40;
+    }
+
+    func_80185960(*(s16 *)((s32)a0 + 0xE4),
+                  (u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x10), step);
+    func_80185960(*(s16 *)((s32)a0 + 0xE6),
+                  (u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x12), step);
+    func_80185960(*(s16 *)((s32)a0 + 0xE8),
+                  (u16 *)((s32)(*(void **)((s32)a0 + 0x20)) + 0x14), step);
+}
+
 
 
 void func_80185960(s32 target, u16 *cur, s32 step)
@@ -6172,9 +6413,24 @@ void func_80185960(s32 target, u16 *cur, s32 step)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801859E4);
+void func_801859E4(s32 idx, u16 *src) {
+    extern s32 D_801EFC4C[];
+    s32 obj;
+
+    obj = D_801EFC4C[idx];
+    *(u16 *)(obj + 0xE4) = src[0];
+    *(u16 *)(obj + 0xE6) = src[1];
+    *(u16 *)(obj + 0xE8) = src[2];
+}
+
+
+void func_80185A18(s32 idx, s32 val)
+{
+    extern s32 D_801EFC4C[];
+
+    *(s16 *)(D_801EFC4C[idx] + 0xE6) = val;
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185A18);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185A30);
 
@@ -6204,7 +6460,27 @@ void func_80185B5C(u16 id)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185C04);
+#include "common.h"
+
+void func_80185C04(u16 a0, u16 a1)
+{
+    /* [T51] scoped in from file scope, mirroring func_80185B5C/func_80185C5C
+       directly above/below in this TU. */
+    extern s32 D_801EFC48;
+    extern s32 D_801EFC4C[];
+    s32 obj;
+    u16 t;
+
+    obj = D_801EFC4C[*(u8 *)(a0 * 8 + *(s32 *)(D_801EFC48 + 0xCC) + 6)];
+    if (obj != 0) {
+        t = *(u16 *)(obj + 0xE8);
+        *(u16 *)(obj + 0xF4) = 0;
+        *(u16 *)(obj + 0xF6) = 0;
+        *(u16 *)(obj + 0xFA) = a1;
+        *(u16 *)(obj + 0xF8) = t;
+    }
+}
+
 
 
 extern s32 func_8004787C(s32 a0);
@@ -6229,7 +6505,19 @@ void func_80185C5C(u16 id)
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185D04);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185D9C);
+void func_80185D9C(void *a0)
+{
+    u16 n;
+
+    n = *(u16 *)((s32)a0 + 0x70);
+    if ((u32)(n - 6) < 13) {
+        *(u16 *)((s32)a0 + 0x84) = n * 8;
+        *(u16 *)((s32)a0 + 0xFE) = 0x30;
+        *(u16 *)((s32)a0 + 0x100) = 0x40;
+        *(u16 *)((s32)a0 + 0x86) |= 3;
+    }
+}
+
 
 #include "common.h"
 
@@ -6275,13 +6563,56 @@ void func_80185FAC(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185FF4);
+#include "common.h"
+
+void func_80185FF4(void *a0)
+{
+    extern u16 D_801EFD44;
+    extern u16 D_801EFD48;
+    extern u16 D_801EFD4C;
+    s32 obj;
+
+    obj = *(s32 *)((s32)a0 + 0x20);
+    D_801EFD48 = 0;
+    D_801EFD44 = *(u16 *)(obj + 0x10);
+    D_801EFD4C = 0x60;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186020);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186110);
+void func_80186110(s32 arg0)
+{
+    extern s32 D_801EFCA0;
+    s32 var;
+
+    var = func_8012C588(0x214, arg0);
+    if (var != 0) {
+        *(s16 *)(var + 6) = 0x60;
+        *(s16 *)(var + 0xA) = -0x540;
+        *(s16 *)(var + 0xE) = 0x900;
+    }
+    D_801EFCA0 = var;
+}
+
+
+#include "common.h"
+
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern s32 D_801EFCA4;
+extern s32 D_801EFCE8[];
+
+void func_8018615C(s32 arg0)
+{
+    s32 i;
+
+    D_801EFCA4 = func_8012C588(0x255, arg0);
+    for (i = 0x10; i < 0x14; i++) {
+        D_801EFCE8[i - 0x10] = func_8012C658(0x257, i, arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018615C);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801861D4);
 
@@ -6291,7 +6622,18 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018630
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018637C);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801863B4);
+#include "common.h"
+
+extern u16 D_801EFD40;
+
+void func_801863B4(s32 a0) {
+    u16 f;
+
+    f = D_801EFD40;
+    *(s16 *)(a0 + 0x98) = 0;
+    D_801EFD40 = f & 0xFFEF;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801863D4);
 
@@ -6393,7 +6735,19 @@ void func_80186518(void *a0, void *a1, s32 a2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801866C4);
+void func_801866C4(void *a0)
+{
+    if (*(u16 *)((s32)a0 + 0x86) & 8) {
+        *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x78) = 0;
+    }
+    *(s16 *)((s32)a0 + 0x6) = 0;
+    *(s16 *)((s32)a0 + 0xA) = 0;
+    *(s16 *)((s32)a0 + 0xE) = 0;
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) = 0;
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = 0;
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186710);
 
@@ -6401,9 +6755,36 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018679
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018681C);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801868A0);
+void func_801868A0(void *a0, u16 *a1) {
+    u16 *dst;
+    s32 i;
+
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) = a1[0];
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = a1[1];
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) = a1[2];
+
+    dst = (u16 *)((s32)a0 + 0xE4);
+    for (i = 0; i < 4; i++) {
+        *dst = a1[0];
+        dst++;
+        *dst = a1[1];
+        dst++;
+        *dst = a1[2];
+        dst++;
+    }
+}
+
+
+extern s32 D_801EFC4C;
+
+void func_80186908(void) {
+    s32 i;
+
+    for (i = 0; i < 0x15; i++) {
+        *(u16 *)(((s32 *)&D_801EFC4C)[i] + 0x86) &= ~0x10;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186908);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186940);
 
@@ -6411,7 +6792,24 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186A2
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186A68);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186AB8);
+void func_80186AB8(void) {
+    extern s32 D_801EFC4C;
+    extern u8 D_80194348[];
+    s32 i;
+    s32 obj;
+    s32 sub;
+
+    for (i = 0; i < 0x15; i++) {
+        obj = ((s32 *)&D_801EFC4C)[i];
+        if (obj != 0) {
+            sub = *(s32 *)(obj + 0x20);
+            if (sub != 0) {
+                *(s32 *)(sub + 0x80) = (s32)D_80194348;
+            }
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186B08);
 
@@ -6433,7 +6831,14 @@ void func_80186BF8(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186C1C);
+extern s32 D_801EFC4C;
+extern s32 D_801EFC54;
+
+void func_80186C1C(void) {
+    *(s16 *)(D_801EFC4C + 0xAE) = -1;
+    *(s16 *)(D_801EFC54 + 0xAE) = -3;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186C40);
 
@@ -6496,7 +6901,7 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186D5
 
 #include "common.h"
 
-extern s32 func_80186E54(s32, s16*, s16*);
+extern s32 func_80186E54();
 
 s32 func_80186DCC(s32 a0) {
     s16 local_10[3];  /* sp+0x10 */
@@ -6524,13 +6929,96 @@ s32 func_80186DCC(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186E54);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186EBC);
+extern void func_8012F214(s32 a0, s32 a1, s32 a2);
+extern s32  func_80135888(s32 a0, s32 a1, s32 a2, s32 a3);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186EFC);
+s32 func_80186E54(s32 arg0, s32 arg1, s32 arg2)
+{
+    extern s32 *D_80126B78;
+    extern s32 *D_80126B90;
+    struct { u16 x, y, z, w; } a;
+    struct { u16 x, y, z, w; } b;
+
+    func_8012F214(arg0, arg1, &a);
+    func_8012F214(arg0, arg2, &b);
+    func_80135888((s32)D_80126B78, (s32)D_80126B90, (s32)&a, (s32)&b);
+}
+
+
+void func_80186EBC(void *a0)
+{
+    extern void func_80016714(void *a0, s32 a1);
+
+    if (*(void **)((s32)a0 + 0xD0) != NULL) {
+        func_80016714(*(void **)((s32)a0 + 0xD0), 0x38);
+        *(void **)((s32)a0 + 0xD0) = NULL;
+    }
+}
+
+
+extern s32 D_801EFC4C;
+
+void func_80186EFC(s32 arg0) {
+    s32 base;
+
+    base = D_801EFC4C;
+    *(s16 *)((s32)arg0 + 0) = *(s32 *)(*(s32 *)(base + 0x20) + 0x48);
+    *(s16 *)((s32)arg0 + 2) = *(s32 *)(*(s32 *)(base + 0x20) + 0x4C);
+    *(s16 *)((s32)arg0 + 4) = *(s32 *)(*(s32 *)(base + 0x20) + 0x50);
+}
+
+
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern u16 D_801EFD40;
+extern u16 D_801EFD20;
+extern s32 D_801EFC48;
+extern s32 D_801EFD2C;
+extern s32 D_801EFD28;
+extern s32 D_801DEC6C;
+extern void func_80186110();
+extern void func_8018615C(s32 a0);
+extern void func_80189A98();
+extern void func_8018637C(s32 a0, s32 a1);
+extern void func_801862A4(s32 a0);
+extern void func_801805D8(void);
+
+void func_80186F44(void *a0)
+{
+    register void *s0 __asm__("$16") = a0;
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((u8 *)s0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(s0);
+        return;
+    }
+    func_8001C2C4(v0);
+    *(s32 *)&D_801EFC48 = (s32)s0;
+    D_801EFD40 = 8;
+    func_80186110(s0);
+    func_8018615C(s0);
+    func_80189A98();
+    D_801EFD20 = 0;
+    func_8018637C(s0, &D_801DEC6C);
+    func_801862A4(s0);
+    {
+        register void *t __asm__("$4");
+        __asm__ volatile("addu %0, %1, $0" : "=&r"(t) : "r"(s0));
+        *(s16 *)((u8 *)t + 0x76) = 0x40;
+        *(s16 *)((u8 *)t + 0xF6) = 3;
+    }
+    (*(u16 *)&D_801EFD2C) = 0x12C;
+    (*(u16 *)&D_801EFD28) = 0x12C;
+    func_801805D8();
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186F44);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80187008);
 
@@ -7125,7 +7613,7 @@ extern void func_8004914C(void *a0);
 extern void func_800491AC(void *a0);
 extern void RotTransSV(void *a0, void *a1, void *a2);
 extern s32 func_80135004(s32 a0, void *a1, s32 a2);
-extern void func_80188054(void *a0, void *a1);
+extern void func_80188054();
 extern void *D_801EFD70[4];
 extern u8 D_801EFDC0[];
 extern u8 D_801ED998[];
@@ -7217,7 +7705,17 @@ void func_80187D68(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80188054);
+void func_80188054(short *a0, short *a1) {
+    short *dst = a0;
+
+    if (dst != NULL) {
+        dst[4] = a1[0];
+        dst[5] = a1[1];
+        dst[6] = a1[2];
+        *(s32 *)((s32)dst + 4) = *(s32 *)((s32)dst + 4) & 0x7FFFFFFF;
+    }
+}
+
 
 #include "common.h"
 
@@ -7476,7 +7974,23 @@ void func_80188794(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801887D0);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80188818);
+extern void func_8012C218(void *a0);
+
+void func_80188818(void *a0) {
+    if (*(s16 *)((s32)a0 + 0x104) < *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A)) {
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) -= 0x10;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) -= 0x80;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1C) -= 0x10;
+    } else {
+        *(u8 *)((s32)a0 + 0xC1) = 0;
+        *(s16 *)((s32)a0 + 0x5E) = 0;
+    }
+
+    if (*(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) <= 0) {
+        func_8012C218(a0);
+    }
+}
+
 
 #include "common.h"
 
@@ -7525,7 +8039,28 @@ void func_801888B8(u8 *a0)
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80188A30);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80188AC4);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern int func_8018AD3C(s16 *param_1, s32 *param_2, s32 param_3);
+
+void func_80188AC4(s32 *param_1) {
+    s16 sp10[4];
+    s32 *a0;
+
+    a0 = (s32 *)func_80132EF4((s32)param_1, 0x22);
+    if (a0 != NULL) {
+        *(u16 *)((s32)(*(s32 *)((s8 *)a0 + 0x20)) + 0x2C) = 0xC020;
+        *(u16 *)((s8 *)a0 + 0x34) = 0x7001;
+        *(u16 *)((s8 *)a0 + 0xA) -= 0x10;
+    }
+    sp10[0] = *(u16 *)((s8 *)param_1 + 0x6);
+    sp10[1] = *(u16 *)((s8 *)param_1 + 0xA) - 0x10;
+    sp10[2] = *(u16 *)((s8 *)param_1 + 0xE);
+    func_8018AD3C(sp10, 0, 8);
+    func_8018AD3C(sp10, 0, 8);
+    func_8018AD3C(sp10, 0, 8);
+    func_8018AD3C(sp10, 0, 8);
+}
+
 
 #include "common.h"
 
@@ -7747,7 +8282,15 @@ done:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80189108);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80189108(s32 *a0) {
+    a0[4] >>= 1;
+    a0[5] = a0[0x38] >> 1;
+    a0[6] >>= 1;
+    func_8012AD44(a0, 2);
+}
+
 
 
 extern void (*D_80194904[])(void);
@@ -7803,7 +8346,28 @@ void func_80189270(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801893D4);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80189410);
+#include "common.h"
+
+extern void func_8001C924(void *a0, void *a1);
+extern void func_8012C218(void *a0);
+extern u8 D_801E793C[];
+
+void func_80189410(void *a0)
+{
+    if (*(s16 *)((s32)a0 + 0x70) != 0) {
+        return;
+    }
+
+    func_8001C924(*(void **)((s32)a0 + 0x20), (void *)&D_801E793C);
+
+    *(u16 *)((s32)a0 + 0xA) += 2;
+
+    if (*(s32 *)((s32)a0 + 0xCC) != 0) {
+        func_8012C218(*(void **)((s32)a0 + 0xCC));
+        *(s32 *)((s32)a0 + 0xCC) = 0;
+    }
+}
+
 
 #include "common.h"
 
@@ -8133,7 +8697,30 @@ void func_80189EAC(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80189EFC);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80189F6C);
+#include "common.h"
+
+/* Callee decls copied verbatim from the destination TU
+ * (src/ov_SC04_011/ov_SC04_011_jr_8017D494.c):
+ *   func_801290DC : L6521/L7315   rand : L954/L3182/L7316
+ */
+extern u8 *func_801290DC(s32 a0, u8 *a1);
+extern s32 rand(void);
+
+void func_80189F6C(void) {
+    s32 s0;
+
+    /* TU prototype is (s32, u8*) but this site sets up only $a0=0x22 —
+     * §165-15/§17a-1 call-site cast keeps the bare jal. */
+    s0 = (s32)((u8 *(*)(s32))func_801290DC)(0x22);
+    if (s0 == 0) {
+        return;
+    }
+    *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) = 0xC020;
+    *(s32 *)(s0 + 0x34) = 0x4001;
+    *(s32 *)(s0 + 0x10) = ((rand() & 0x7FF0) - 0x4000) << 4;
+    *(s32 *)(s0 + 0x18) = ((rand() & 0x7FF0) - 0x4000) << 4;
+}
+
 
 
 extern void (*D_80194A60[])(void);
@@ -8237,7 +8824,15 @@ void func_8018A3F0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018A42C);
+void func_8018A42C(void *a0, void *a1) {
+    *(u16 *)((s32)a0 + 0x6) = *(u16 *)((s32)a1 + 0x0);
+    *(u16 *)((s32)a0 + 0xA) = *(u16 *)((s32)a1 + 0x2);
+    *(u16 *)((s32)a0 + 0xE) = *(u16 *)((s32)a1 + 0x4);
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) = *(u16 *)((s32)a1 + 0x6);
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)((s32)a1 + 0x8);
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x14) = *(u16 *)((s32)a1 + 0xA);
+}
+
 
 void func_8018A47C(void *a0) {
         *(short *)((char *)a0 + 0xfc) = 1;
@@ -8982,9 +9577,63 @@ void func_8018B5E4(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018B744);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018B830);
+extern s8 D_80194BE4[];
+
+void func_8018B830(s32 *a0) {
+    s32 i;
+    s32 tag;
+    s32 obj;
+    s32 a1;
+    s16 a2;
+    u16 temp;
+
+    i = 0;
+    tag = D_80194BE4[0];
+    while (tag >= 0) {
+        obj = a0[tag];
+        if (obj != 0) {
+            a1 = *(s32 *)(obj + 0xCC);
+            if (a1 != 0) {
+                a2 = *(s16 *)(a1 + 0x18);
+                if (a2 < 0x5000) {
+                    temp = *(u16 *)(a1 + 0x1A);
+                    *(s16 *)(a1 + 0x18) = a2 + 0x100;
+                    *(u16 *)(a1 + 0x1A) = temp + 0x100;
+                }
+            }
+        }
+        i++;
+        tag = D_80194BE4[i];
+    }
+}
+
+
+extern void func_80016714(void *a0, s32 a1);
+extern s8 D_80194BE4[];
+
+void func_8018B8C0(void *a0) {
+    s32 s1;
+    s32 i;
+    s32 tag;
+    s32 ptr;
+    void *p;
+
+    s1 = (s32)a0;
+    i = 0;
+    tag = D_80194BE4[0];
+    while (tag >= 0) {
+        ptr = *(s32 *)(s1 + tag * 4);
+        if (ptr != 0) {
+            p = *(void **)(ptr + 0xCC);
+            if (p != 0) {
+                func_80016714(p, 0x38);
+            }
+        }
+        i++;
+        tag = D_80194BE4[i];
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018B8C0);
 
 #include "common.h"
 
@@ -9029,11 +9678,44 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018B9D
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018BA44);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018BA9C);
+extern u8 D_801EFEA0[];
+extern u8 D_801EFEA1;
+extern u8 D_801EFEA2;
+
+void func_8018BA9C(void) {
+    D_801EFEA0[0] = 0xF0;
+    D_801EFEA1 = 0xF0;
+    D_801EFEA2 = 0x80;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018BAC4);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018BB44);
+void func_8018BB44(void) {
+    extern u8 sBB44_A0 __asm__("D_801EFEA0");
+    extern u8 sBB44_A1 __asm__("D_801EFEA1");
+    extern u8 sBB44_A2 __asm__("D_801EFEA2");
+    extern u8 sBB44_A3 __asm__("D_801EFEA3");
+    u8 *flag;
+
+    flag = &sBB44_A3;
+    if (*flag == 0) {
+        sBB44_A0 -= 3;
+        sBB44_A1 -= 5;
+        sBB44_A2 -= 7;
+        if (sBB44_A2 < 0x61) {
+            *flag = 1;
+        }
+    } else {
+        sBB44_A0 += 3;
+        sBB44_A1 += 5;
+        sBB44_A2 += 7;
+        if (sBB44_A2 >= 0xE0) {
+            *flag = 0;
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -9075,7 +9757,47 @@ void func_8018BC08(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018BD18);
+#include "common.h"
+
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void RotTransSV(void *a0, void *a1, void *a2);
+extern void ApplyRotMatrixLV(void *in, void *out);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+extern u16 D_80194BF4[];
+extern u16 D_80194BFC[];
+
+void func_8018BD18(s32 a0)
+{
+    s32 v0;
+    s32 v1;
+    u16 v[4];
+    u16 out[4];
+
+    if (a0 == 0) {
+        return;
+    }
+
+    v0 = func_80132EF4(a0, 0x22);
+
+    func_8004914C((void *)(*(s32 *)(a0 + 0x20) + 0x34));
+    func_800491AC((void *)(*(s32 *)(a0 + 0x20) + 0x34));
+
+    RotTransSV(&D_80194BF4, v, out);
+
+    *(u16 *)(v0 + 0x6) = v[0];
+    *(u16 *)(v0 + 0xA) = v[1];
+    *(u16 *)(v0 + 0xE) = v[2];
+    v1 = *(s32 *)(v0 + 0x20);
+    *(u16 *)(v1 + 0x2C) = 0xC008;
+    *(u16 *)(v0 + 0x34) = 0x6001;
+
+    ApplyRotMatrixLV(&D_80194BFC, (void *)(v0 + 0x10));
+
+    *(s32 *)(v0 + 0x14) += -0x40000;
+}
+
 
 
 extern void (*D_80194C0C[])(void);
@@ -9170,7 +9892,23 @@ void func_8018BEEC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C024);
+extern void func_8012B414(int a0);
+extern void func_80187D68(void *a0);
+extern void func_8018778C(void *a0);
+extern void func_80187A04(void *a0);
+
+void func_8018C024(void *a0)
+{
+    s32 v1;
+
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    *(s16 *)(v1 + 0x14) = *(u16 *)(v1 + 0x14) + 0x100;
+    func_8012B414((int)a0);
+    func_80187D68(a0);
+    func_8018778C(a0);
+    func_80187A04(a0);
+}
+
 
 #include "common.h"
 struct vec;
@@ -9290,11 +10028,70 @@ void func_8018C14C(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C260);
+#include "common.h"
+
+extern void func_8012AD80(s32 a0);
+extern void func_801888B8(u8 *a0);
+extern s32 func_8018AD3C(s16 *a0, s32 *a1, s32 a2);
+extern void func_801886C4(s32 *a0);
+extern void func_80188A30(s32 a0);
+
+void func_8018C260(s32 a0) {
+    s16 sp10[4];
+    s32 obj;
+    u16 v0;
+
+    obj = *(s32 *)(a0 + 0x20);
+    v0 = *(u16 *)(obj + 0x14);
+    *(u16 *)(obj + 0x14) = v0 + 0x100;
+
+    func_8012AD80(a0);
+    func_801888B8((u8 *)a0);
+
+    sp10[0] = *(u16 *)(a0 + 0x6);
+    sp10[1] = *(u16 *)(a0 + 0xA);
+    sp10[2] = *(s16 *)(a0 + 0xE) + 0x20;
+
+    func_8018AD3C(sp10, NULL, 8);
+    func_8018AD3C(sp10, NULL, 8);
+
+    if (*(s16 *)(a0 + 0xA) >= -0x780) {
+        func_801886C4((s32 *)a0);
+    } else {
+        func_80188A30(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C310);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C378);
+extern void func_8012BEE8(u8 *a0);
+extern void func_8012C218(void *a0);
+extern void func_80133298(s32 *a0);
+extern void func_8018985C(void *a0, void *a1);
+extern s32 D_80194818;
+
+void func_8018C378(void *arg0)
+{
+    if (((s32 (*)(s32))func_8012BEE8)((s32)arg0) != 0) {
+        func_8012C218(arg0);
+        return;
+    }
+    if (*(volatile s32 *)((s32)arg0 + 0x1C) < 0x18) {
+        *(s16 *)((s32)arg0 + 0x5C) = 0;
+        if (*(volatile s32 *)((s32)arg0 + 0x1C) & 1) {
+            *(s32 *)(*(s32 *)((s32)arg0 + 0x20) + 4) |= 0x80000000;
+        } else {
+            *(s32 *)(*(s32 *)((s32)arg0 + 0x20) + 4) &= 0x7FFFFFFF;
+        }
+    } else {
+        if (*(u8 *)((s32)arg0 + 0x74)) {
+            func_80133298((s32 *)arg0);
+            func_8018985C(arg0, &D_80194818);
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -9360,7 +10157,58 @@ void func_8018C4BC(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C58C);
+#include "common.h"
+
+extern void func_8012AD80(s32 a0);
+extern void func_8018A7E8(s32 a0);
+extern void func_80189108();
+extern s32 func_801893D4(s32 a0);
+extern s32 func_80189478(s32 a0);
+
+void func_8018C58C(s32 a0) {
+    s32 s0;
+    s32 ptr;
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+
+    s0 = a0;
+
+    v1 = *(s16 *)(s0 + 0x70);
+    if (v1 < 2) {
+        if (v1 >= 0) {
+            return;
+        }
+    }
+
+    func_8012AD80(a0);
+
+    ptr = *(s32 *)(s0 + 0x20);
+    v1 = *(u16 *)(s0 + 0x106);
+    v0 = *(u16 *)(ptr + 0x10);
+    v0 = v0 + v1;
+    *(u16 *)(ptr + 0x10) = (u16)v0;
+
+    ptr = *(s32 *)(s0 + 0x20);
+    v1 = *(u16 *)(s0 + 0x108);
+    v0 = *(u16 *)(ptr + 0x14);
+    v0 = v0 + v1;
+    *(u16 *)(ptr + 0x14) = (u16)v0;
+
+    if ((*(s32 *)(s0 + 0x1C) & 3) == 0) {
+        func_8018A7E8(a0);
+    }
+
+    v0 = *(s32 *)(s0 + 0x1C);
+    v0 = v0 + 1;
+    *(s32 *)(s0 + 0x1C) = v0;
+
+    if (func_801893D4(a0) != 0) {
+        func_80189108(a0);
+    }
+
+    func_80189478(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C64C);
 
@@ -9404,7 +10252,24 @@ void func_8018C764(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018C838);
+void func_8018C838(s32 arg0) {
+    s16 v;
+    u8 *p;
+
+    p = (u8 *)*(s32 *)(arg0 + 0x34);
+    *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x18) += 0xA0;
+    v = *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18);
+    if (v >= 0x1200) {
+        p[0xB] = 0;
+        func_801292C8((u8 *)arg0);
+    } else {
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) = v;
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x1E) += 0x20;
+        p[5] -= 5;
+        p[6] -= 8;
+    }
+}
+
 
 void func_8018C8CC(void) {
 }
@@ -9495,11 +10360,95 @@ void func_8018CA04(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018CA98);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018CAF0);
+extern u16 D_801E1AF4[];
+
+void func_8018CA98(void *a0)
+{
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(v0, (s32)D_801E1AF4);
+    func_8012AD50(a0);
+}
+
+
+#include "common.h"
+
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018A784(void *a0);
+
+void func_8018CAF0(void *a0) {
+    register s32 s0 __asm__("$16") = (s32)a0;
+    register s32 mask __asm__("$3");
+    u16 v0;
+    s16 h;
+    s32 p;
+
+    v0 = *(u16 *)(s0 + 0x34);
+
+    if (v0 == 0) {
+        h = *(s16 *)(s0 + 0xFC);
+        if (h != 0) {
+            mask = (s32)0x80000000;
+            p = *(s32 *)(s0 + 0x20);
+            *(s32 *)(p + 4) = *(s32 *)(p + 4) | mask;
+
+            func_8018A784((void *)s0);
+
+            v0 = *(u16 *)(s0 + 0x34);
+            v0 = v0 + 1;
+            *(u16 *)(s0 + 0x34) = v0;
+
+            func_8002D4C8(0x7E2, 0);
+        }
+    }
+}
+
+
+extern void func_8012AD80(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_8018A7E8(s32 a0);
+
+void func_8018CB68(s32 arg0) {
+    register s32 a0 __asm__("$4");
+    register s32 a1 __asm__("$5");
+    u16 val;
+
+    a0 = *(s32 *)(arg0 + 0x20);
+    val = *(u16 *)(arg0 + 0x106);
+    *(u16 *)(a0 + 0x10) = *(u16 *)(a0 + 0x10) + val;
+
+    a1 = *(s32 *)(arg0 + 0x20);
+    val = *(u16 *)(arg0 + 0x108);
+    *(u16 *)(a1 + 0x14) = *(u16 *)(a1 + 0x14) + val;
+
+    func_8012AD80(arg0);
+
+    if (*(s16 *)(arg0 + 0x70) < 0x10) {
+        if (*(s32 *)(arg0 + 0x1C) & 1) {
+            func_8018A7E8(arg0);
+        }
+
+        *(s32 *)(arg0 + 0x1C) = *(s32 *)(arg0 + 0x1C) + 1;
+    }
+
+    if (*(s16 *)(arg0 + 0xA) >= -0x3FF) {
+        func_8012C218((void *)arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018CB68);
 
 void func_8018CC1C(void) {
 }
@@ -10064,7 +11013,17 @@ void func_8018D988(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DA18);
+#include "common.h"
+
+extern void func_80015978(s32 a0, s32 *a1);
+
+void func_8018DA18(s32 a0, void *a1) {
+    s32 sp18[2];
+
+    func_80015978(a0 + 4, sp18);
+    func_8018DA64((s8 *)a1 + 0x14, (s8 *)a1 + 0xC, (void *)sp18, (s8 *)a1 + 8, (s8 *)a1 + 0x3C);
+}
+
 
 #include "common.h"
 
@@ -10186,7 +11145,24 @@ void func_8018DBF0(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DC9C);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DD24);
+#include "common.h"
+
+extern u8 D_80194D50[];
+extern void func_8018DFDC(void);
+extern void func_8012BEE8(u8*);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+void func_8018DD24(s32 a0) {
+    s32 s0 = a0;
+
+    func_8018DFDC();
+    if (((s32 (*)(s32))func_8012BEE8)((s32)s0) != 0) {
+        func_8002D4C8(*(u16 *)(D_80194D50 + *(s16 *)(s0 + 0xFC) * 8), 0);
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DD84);
 
@@ -10227,13 +11203,46 @@ void func_8018DE0C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DEB0);
+#include "common.h"
+
+extern s32 func_80016978(s32 arg);
+extern void func_8018DFDC(void);
+extern s32 func_8012AD50(void *a0);
+
+void func_8018DEB0(s32 a0) {
+    register s32 s0 __asm__("$16") = a0;
+    s32 v0;
+
+    func_8018DFDC();
+
+    v0 = func_80016978(0);
+    v0 &= 0xFFFF;
+
+    if (v0 != 0) {
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DEF4);
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DF6C);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018DFDC);
+extern u16 D_800B99DA;
+extern s32 D_801F12C8;
+
+void func_8018DFDC(void) {
+    s32 *ptr;
+
+    ptr = &D_801F12C8;
+
+    if (D_800B99DA & 1) {
+        *ptr = 0xE0E0E0;
+    } else {
+        *ptr = 0xFFFFFF;
+    }
+}
+
 
 void func_8018E010(void) {