diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 014ecb7a52..fde34f4f9b 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -128,7 +128,32 @@ void func_801A0C58(s32 *a0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0CD0);
+extern void func_801A36F0(void *a0);
+extern void func_801A34C4(s32 a0);
+extern void func_801A4328(s32 a0);
+extern s16 func_8017F730(void);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_801EEB70;
+extern s16 D_801F8E98;
+
+void func_801A0CD0(s32 *a0)
+{
+    s32 *s0;
+    u16 v0;
+
+    s0 = a0;
+    func_801A36F0(s0);
+    func_801A34C4((s32)s0);
+    func_801A4328(1);
+    func_8017F730();
+    v0 = *(u16 *)((s32)s0 + 0x5C);
+    *(u16 *)((s32)s0 + 0x5C) = v0 & 0xDFFF;
+    func_8012A828((s32)s0, &D_801EEB70);
+    D_801F8E98 = 0;
+    func_8012AD44(s0, 5);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A0D40);
 
@@ -443,7 +468,24 @@ void func_801A36F0(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A370C);
+#include "common.h"
+
+extern u16 D_801AFE34[8];
+
+void func_801A370C(s32 a0) {
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+
+    v0 = *(u16 *)(a0 + 0x10A);
+    v1 = *(s32 *)(a0 + 0x20);
+    v0 = v0 + 1;
+    *(u16 *)(a0 + 0x10A) = v0;
+    v0 = D_801AFE34[v0 & 7];
+    *(u16 *)(v1 + 0x1C) = v0;
+    *(u16 *)(v1 + 0x1A) = v0;
+    *(u16 *)(v1 + 0x18) = v0;
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3744);
 
@@ -451,7 +493,30 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A3798);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A395C);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A39D0);
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void RotTransSV(s32 a0, s32 a1, void *a2);
+
+typedef struct { s16 vx, vy, vz, pad; } SVec_801A39D0;
+
+void func_801A39D0(s32 param_1)
+{
+    SVec_801A39D0 sv;
+    s32 flag;
+
+    func_8004914C((void *)(*(s32 *)(param_1 + 0x20) + 0x34));
+    func_800491AC((void *)(*(s32 *)(param_1 + 0x20) + 0x34));
+
+    sv.vx = 0;
+    sv.vy = -0x40;
+    sv.vz = 0x30;
+    RotTransSV((s32)&sv, (s32)&sv, &flag);
+
+    *(s16 *)(param_1 + 0x06) = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x48) = sv.vx;
+    *(s16 *)(param_1 + 0x0A) = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x4C) = sv.vy;
+    *(s16 *)(param_1 + 0x0E) = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x50) = sv.vz;
+}
+
 
 extern void func_8004914C(void *a0);
 extern void func_800491AC(void *a0);
@@ -537,7 +602,26 @@ void func_801A417C(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A41CC);
+extern u8 D_801F8744[];
+
+void func_801A41CC(void) {
+    s32 i;
+    u8 *src;
+    s32 n;
+    s32 dst;
+    i = 1;
+    src = D_801F8744;
+    n = 4;
+    dst = 0x40;
+    while (i < 4) {
+        D_801F8744[dst + 0] = (src[0] >> 2) * (n - i);
+        D_801F8744[dst + 1] = (src[1] >> 2) * (n - i);
+        D_801F8744[dst + 2] = (src[2] >> 2) * (n - i);
+        dst += 0x40;
+        i++;
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A4258);
 
@@ -2417,7 +2501,17 @@ void func_801A8404(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8440);
+void func_801A8440(s32 a0) {
+    s32 a1;
+
+    a1 = *(s32 *)(a0 + 0x34);
+    if (a1 != 0) {
+        *(u16 *)(a0 + 0x6) = *(u16 *)(a1 + 0x6) + *(u16 *)(a1 + 0x50);
+        *(u16 *)(a0 + 0xA) = *(u16 *)(a1 + 0xA) + *(u16 *)(a1 + 0x52);
+        *(u16 *)(a0 + 0xE) = *(u16 *)(a1 + 0xE) + *(u16 *)(a1 + 0x54);
+    }
+}
+
 
 typedef struct { s16 x, y, z, pad; } Svec_801A8494;
 
@@ -2465,7 +2559,19 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A861C);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A8670);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A86B4);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+s32 func_801A86B4(s32 a0) {
+    s32 var;
+
+    var = func_80132EF4(a0, 0x30);
+    if (var != 0) {
+        *(u16 *)(var + 0x2E) = 7;
+        *(s32 *)(var + 0x34) = a0;
+    }
+    return var;
+}
+
 
 extern u8 D_801F8978[3];
 extern void func_801A8738();
@@ -2997,7 +3103,13 @@ void func_801A9AAC(void) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9ADC);
+s32 func_801A9ADC(void) {
+    extern s32 func_80128DB4(s32, s32 *);
+    extern s32 D_801F8A50;
+
+    return func_80128DB4(0, &D_801F8A50);
+}
+
 
 
 
@@ -3138,7 +3250,29 @@ void func_801A9CAC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9EB0);
+extern void func_8012AD80(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 func_8017D7D4(void *a0, void *a1, void *a2, s32 a3);
+extern void func_801AA004(void *a0, void *a1);
+extern void func_801AA210(void *a0, void *a1, void *a2);
+extern s32 D_801B077C;
+
+void func_801A9EB0(void *arg0) {
+    void *s2;
+    s8 sp10[0x20];
+    s8 sp30[0x18];
+
+    func_801AA004(arg0, sp10);
+    func_8012AD80((s32)arg0);
+    func_8012AD80((s32)arg0);
+    func_801AA210(arg0, sp10, sp30);
+    s2 = &D_801B077C;
+    *(s32 *)((u8 *)arg0 + 0xCC) = func_8017D7D4(sp30, sp30 + 8, s2, 12);
+    *(s32 *)((u8 *)arg0 + 0xD0) = func_8017D7D4(sp30, sp30 + 0x10, s2, 12);
+    *(s32 *)((u8 *)arg0 + 0x1C) = 0x30;
+    func_8012AD44((s32 *)arg0, 1);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A9F5C);
 
@@ -3175,7 +3309,32 @@ void func_801AA004(void *arg0, void *arg1)
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA0B4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA160);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern void ApplyRotMatrix(void *a0, void *a1);
+extern void ApplyRotMatrixLV(void *a0, void *a1);
+
+extern u8 D_801B0790[];
+extern u8 D_801B07A0[];
+
+void func_801AA160(s32 arg0, s32 arg1)
+{
+    s32 vec[12]; /* sp+0x10 */
+    s32 s1;
+    s32 s0;
+
+    s1 = arg1;
+    s0 = func_80132EF4(arg0, 0x22);
+    if (s0 != 0) {
+        ApplyRotMatrix((void *)(D_801B0790 + (s1 << 3)), vec);
+        *(u16 *)(s0 + 0x6) += vec[0];
+        *(u16 *)(s0 + 0xA) += vec[1];
+        *(u16 *)(s0 + 0xE) += vec[2];
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) = 0xC020;
+        ApplyRotMatrixLV((void *)(D_801B07A0 + (s1 << 4)), (void *)(s0 + 0x10));
+        *(u16 *)(s0 + 0x34) = 0x3400;
+    }
+}
+
 
 typedef struct { s16 vx, vy, vz; } SV_801AA210;
 
@@ -3372,7 +3531,33 @@ void func_801AA7E4(u8 *s2)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA91C);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern s32 rand(void);
+
+void func_801AA91C(s32 param_1, s32 param_2, s32 param_3)
+{
+    register s32 s1 __asm__("$17") = param_1;
+    register s32 s2 __asm__("$18") = param_2;
+    register s32 s3 __asm__("$19") = param_3;
+    register s32 s0 __asm__("$16");
+
+    s0 = func_80132EF4(param_1, 0x71);
+
+    if (s0 != 0) {
+        *(u16 *)(s0 + 0xA) += *(u16 *)(s1 + 0x52);
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x10) = s2;
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) = s3;
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x14) = 0;
+        *(u16 *)(s0 + 0x30) = 5;
+        *(u16 *)(s0 + 0x32) = 0;
+        if (rand() & 1) {
+            *(s32 *)(s0 + 0x34) = 0x180FF80;
+        } else {
+            *(s32 *)(s0 + 0x34) = 0x1FF8080;
+        }
+    }
+}
+
 
 void func_801AA9D4(s32 a0, s32 a1) {
     extern u8 *func_8012913C(s32 a0);
@@ -3397,7 +3582,43 @@ void func_801AA9D4(s32 a0, s32 a1) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AAA6C);
+/* Local mirror of SV4_801AAB28 (that typedef sits below this point in the TU,
+   so this card carries its own identically-laid-out record: 4 x u16, size 8).
+   Kept a distinct name on purpose -- same shape, different spelling site. */
+typedef struct {
+    u16 x;      /* +0x0 */
+    u16 y;      /* +0x2 */
+    u16 num;    /* +0x4 */
+    u16 count;  /* +0x6 */
+} SV4R_801AAA6C;
+
+/* no-proto on purpose: the real definition (with SV4_801AAB28* params) lives
+   further down this TU; a prototyped extern here would be a types conflict */
+extern void func_801AAB28();
+
+void func_801AAA6C(s32 a0)
+{
+    SV4R_801AAA6C r1;   /* sp+0x10 : base point + running offset */
+    SV4R_801AAA6C r2;   /* sp+0x18 : {yOff, seg<<10, 0x24, 5} */
+    s32 j = 0;
+    s16 yOff = -0x200;
+    s32 i;
+
+    r1.x = *(u16 *)(a0 + 0x06) + *(u16 *)(a0 + 0x50);
+    r1.y = *(u16 *)(a0 + 0x0A) + *(u16 *)(a0 + 0x52);
+    r1.num = *(u16 *)(a0 + 0x0E) + *(u16 *)(a0 + 0x54);
+    r2.num = 0x24;
+    r2.count = 5;
+    for (; j < 2; j++) {
+        for (i = 0; i < 4; i++) {
+            r2.x = yOff;
+            r2.y = i * 0x400;
+            func_801AAB28(&r1, &r2, 0x101820);
+        }
+        yOff += 0x400;
+    }
+}
+
 
 #include "common.h"
 
@@ -3664,7 +3885,18 @@ void func_801AADA8(s32 arg0, s32 arg1, s32 arg2)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AAF34);
+extern s32 func_801AAF8C();
+
+void func_801AAF34(s32 a0, s32 a1, s16 a2)
+{
+    s16 sv[3];
+
+    sv[0] = *(u16 *)(a0 + 6) + *(u16 *)(a0 + 0x50);
+    sv[1] = *(u16 *)(a0 + 0xA) + *(u16 *)(a0 + 0x52);
+    sv[2] = *(u16 *)(a0 + 0xE) + *(u16 *)(a0 + 0x54);
+    func_801AAF8C(sv, a1, a2);
+}
+
 
 #include "common.h"
 
@@ -3883,7 +4115,30 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB694);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB748);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB78C);
+extern void func_801292C8(u8 *a0);
+extern u8 D_801F88BA;
+
+void func_801AB78C(void *a0) {
+    register volatile u8 *p __asm__("$5") = &D_801F88BA;
+    register s32 b __asm__("$3");
+    s32 t;
+    if (*p == 0) {
+        func_801292C8((u8 *)a0);
+    } else {
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18) += 0x200;
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) = *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x18);
+        b = *p;
+        t = b - 0x10;
+        if (b != 0) {
+            b = t;
+            if (t < 0) {
+                b = 0;
+            }
+            *p = (u8)b;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AB818);
 
@@ -4353,7 +4608,36 @@ INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC940);
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC9CC);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ACA88);
+void func_801ACA88(void *a0)
+{
+    extern void func_801292C8(u8 *a0);
+    extern void func_8012931C(struct vec *a0);
+    extern void func_8017E5D4(void *a0);
+    extern void func_8017E1E8(void *a0, void *a1, void *a2);
+
+    s16 buf[4];
+    s32 v0;
+
+    v0 = *(s32 *)((s32)a0 + 0x1C);
+    if (v0 == 0) {
+        if (*(void **)((s32)a0 + 0x2C) != NULL) {
+            func_8017E5D4(*(void **)((s32)a0 + 0x2C));
+        }
+        func_801292C8((u8 *)a0);
+    } else {
+        *(s32 *)((s32)a0 + 0x1C) = v0 - 1;
+        func_8012931C((struct vec *)a0);
+
+        buf[0] = *(u16 *)((s32)a0 + 0x6);
+        buf[1] = *(u16 *)((s32)a0 + 0xA);
+        buf[2] = *(u16 *)((s32)a0 + 0xE);
+
+        if (*(void **)((s32)a0 + 0x2C) != NULL) {
+            func_8017E1E8(*(void **)((s32)a0 + 0x2C), &buf[0], NULL);
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -4727,7 +5011,32 @@ void func_801AD5B4(s32 param_1, s32 param_2) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AD640);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern s32 rand(void);
+extern u16 D_801B0828[];
+
+void func_801AD640(s32 param_1, s32 param_2) {
+    s32 s2;
+    s32 s0;
+    s32 s1;
+    s32 r;
+    s32 b;
+    s32 i;
+
+    s2 = param_1;
+    s1 = param_2;
+    s0 = func_80132EF4(param_1, 0x2F);
+
+    if (s0 != 0) {
+        r = rand();
+        i = s1 & 3;
+        b = D_801B0828[i];
+        *(u16 *)(s0 + 0x2E) = i + 0x100;
+        *(s32 *)(s0 + 0x34) = s2;
+        *(u16 *)(s0 + 0x2C) = b - 0x40 + (r & 0x7C);
+    }
+}
+
 
 
 
@@ -4909,7 +5218,26 @@ void func_801ADC40(u8 *a0)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801ADD98);
+void func_801ADD98(u8 *a0, volatile u8 *a1, volatile u8 *a2) {
+    s32 ctr;
+    s32 v1;
+
+    ctr = 0;
+    do {
+        a1[0] = (*(u16 *)a0 >> 8) & 0x7C;
+        ctr++;
+        v1 = (a1[0] << 24) >> 28;
+        a1[1] = (*(u16 *)a0 >> 3) & 0x7C;
+        a1[2] = (*a0 << 2) & 0x7C;
+        a2[0] = v1;
+        a2[1] = (a1[1] << 24) >> 28;
+        a0 += 2;
+        a2[2] = (a1[2] << 24) >> 28;
+        a1 += 3;
+        a2 += 3;
+    } while (ctr < 0x10);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
index abefacdc85..a1cda8db84 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
@@ -4627,7 +4627,28 @@ void func_8017EF1C(u8 *a0)
   ((s32 (*)(s32)) func_80171B44)(p);
 }
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017EF58);
+extern s32 func_80171B4C(s32 a0, s32 a1);
+extern s32 func_800CF854(void);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_8014706C(void *a0);
+extern s32 func_8013767C(s32 a0);
+extern u8 D_800D5A34[];
+
+void func_8017EF58(int param_1)
+{
+    if (func_80171B4C(param_1, 0x1E) != 0) {
+        if (((int (*)(void))func_800CF854)() != 0) {
+            *(char *)(param_1 + 0x214) = 3;
+        } else {
+            ((int (*)(int, int))func_80154274)(param_1, (int)&D_800D5A34);
+            ((int (*)(int))func_8014706C)(param_1);
+            *(int *)(param_1 + 0x198) = func_8013767C(*(int *)(param_1 + 0x198));
+            *(char *)(param_1 + 0x214) = *(char *)(param_1 + 0x214) + 1;
+            *(short *)(param_1 + 0x20c) = 0;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017EFDC);
 
@@ -4655,7 +4676,17 @@ void func_8017F184(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F1C0);
+extern void func_80171B44(s32 *a0);
+extern void func_8017F204(s32 a0);
+
+void func_8017F1C0(s32 a0)
+{
+    *(u8 *)(a0 + 0x214) = *(u8 *)(a0 + 0x214) + 1;
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = 0;
+    func_80171B44((s32 *)a0);
+    func_8017F204(a0);
+}
+
 
 
 // @class: plumbing
@@ -4688,7 +4719,23 @@ void func_8017F268(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F2A4);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F344);
+extern s32 func_80012B04(s32 a0, s32 a1, s32 a2);
+extern s32 func_8013767C(s32 a0);
+extern u8 D_8018A6A8[];
+
+void func_8017F344(void *arg0) {
+    s32 temp_v0;
+    void *temp_a0;
+
+    temp_v0 = func_80012B04(M2C_FIELD(M2C_FIELD(arg0, void **, 0x20), s16 *, 0x12), M2C_FIELD(arg0, s16 *, 0x20C), 4);
+    temp_a0 = M2C_FIELD(arg0, void **, 0x20);
+    M2C_FIELD(temp_a0, s16 *, 0x12) = (s16) (((u16) M2C_FIELD(temp_a0, s16 *, 0x12) + temp_v0) & 0xFFF);
+    if ((temp_v0 << 0x10) == 0) {
+        M2C_FIELD(arg0, s32 *, 0x198) = func_8013767C(&D_8018A6A8);
+        M2C_FIELD(arg0, u8 *, 0x214) = (u8) (M2C_FIELD(arg0, u8 *, 0x214) + 1);
+    }
+}
+
 
 
 extern s32 func_801399F0(s32 a0);
@@ -4743,7 +4790,34 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F53
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F638);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F710);
+#include "common.h"
+
+extern s16 D_80126ADA;
+extern s16 D_80126ADE;
+extern s16 D_80126AE2;
+extern u16 D_800B99DC;
+extern u8 D_80183CB4[];
+extern void func_8013C9C4(void *a0);
+extern void func_8017E448(s32 arg0);
+
+void func_8017F710(s32 arg0) {
+    u16 cnt;
+
+    if (--*(s32 *)(arg0 + 0xE4) == 0) {
+        *(s32 *)(arg0 + 0xE0) = 0x30;
+        *(s32 *)(arg0 + 0xE4) = 0x40;
+        func_8017E448(arg0);
+        cnt = *(u16 *)(arg0 + 6);
+        D_80126ADE = -0x130;
+        D_80126ADA = cnt;
+        D_80126AE2 = *(u16 *)(arg0 + 0xE);
+        (*(u16 *)(arg0 + 2))++;
+    } else if (--*(s32 *)(arg0 + 0xDC) == 0) {
+        func_8013C9C4(&D_80183CB4);
+        *(s32 *)(arg0 + 0xDC) = (D_800B99DC & 7) + 3;
+    }
+}
+
 
 #include "common.h"
 
@@ -4784,7 +4858,27 @@ void func_8017F7D0(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F8C0);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017FB5C);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017FB5C(s32 p)
+{
+    extern int func_8001AAA0(void);
+    switch (*(s16 *)(p + 0xFE)) {
+    case 0:
+        if (((int (*)(s32))func_8001AAA0)(0x11) != 0) {
+            *(u16 *)(p + 0xFE) = 1;
+        }
+        break;
+    case 1:
+        func_8002D4C8(0x102, 0);
+        *(u16 *)(p + 0xFE) += 1;
+        break;
+    case 2:
+        *(u16 *)(p + 2) += 1;
+        break;
+    }
+}
+
 
 
 extern Blk8 D_801C46E8;
@@ -4839,9 +4933,44 @@ void func_80180174(void) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180188);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801802D8);
+void func_801802D8(void *a0) {
+    s32 *p1, *q1;
+    p1 = *(s32 **)((s32)a0 + 0xF4);
+    p1[1] = p1[1] | 0xD0000040;
+    q1 = *(s32 **)((s32)a0 + 0xF8);
+    q1[1] = q1[1] | 0xD0000040;
+    *(s32 *)((s32)a0 + 0xE4) = 0x80;
+    *(u16 *)((s32)a0 + 0x34) = *(u16 *)((s32)a0 + 0x34) + 1;
+}
+
+
+extern s32 D_801270C8;
+extern s32 D_801C7EC0;
+extern u8 D_80189974;
+extern u8 D_80189975;
+extern u8 D_80189976;
+
+void func_80180320(s32 arg0) {
+    s32 t;
+    s32 p2;
+    u16 cnt;
+
+    if (D_801270C8 < 4 && D_801C7EC0 != 0) {
+        t = 0x50000040;
+        *(s32 *)(*(s32 *)(arg0 + 0xF4) + 4) = t;
+        p2 = *(s32 *)(arg0 + 0xF8);
+        D_801C7EC0 = 0;
+        *(s32 *)(p2 + 4) = t;
+        D_80189974 = 0xFF;
+        D_80189975 = 0x10;
+        D_80189976 = 0x10;
+        *(s32 *)(arg0 + 0xE4) = 6;
+        cnt = *(u16 *)(arg0 + 0x34);
+        *(s32 *)(arg0 + 0xE8) = 0xFF;
+        *(u16 *)(arg0 + 0x34) = cnt + 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180320);
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801803AC);
 
@@ -4855,7 +4984,14 @@ void func_80180420(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018045C);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180528);
+void func_80180528(s32 arg0) {
+    s32 *p = (s32 *)(arg0 + 0x64);
+    s32 *t = (s32 *)*p;
+    *(s32 *)(arg0 + 4) = t[1];
+    *(s16 *)(arg0 + 0xA) = *(u16 *)(*p + 0xA) - *(s32 *)(*p + 0xF0);
+    *(s32 *)(arg0 + 0xC) = *(s32 *)(*p + 0xC);
+}
+
 
 extern void (*D_8018A214[])(void);
 
@@ -4866,9 +5002,28 @@ void func_8018055C(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180598);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180654);
+extern s32 D_80127190;
+
+void func_80180654(void *a0) {
+    if (*(u8 *)(*(s32 *)((s32)a0 + 0x64) + 0xFC) != 0) {
+        *(s32 *)((s32)a0 + 0xDC) = 0x60;
+        D_80127190 = *(s16 *)((s32)a0 + 0xA);
+        *(u16 *)((s32)a0 + 0x2) += 1;
+    }
+}
+
+
+extern void func_8012C218(void *a0);
+extern s32 D_80127190;
+
+void func_80180694(void *arg0) {
+    D_80127190 = *(s16 *)((s32)arg0 + 0xA);
+    *(u16 *)((s32)arg0 + 0xA) += 8;
+    if (--*(s32 *)((s32)arg0 + 0xDC) == 0) {
+        func_8012C218(arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180694);
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801806DC);
 
@@ -4932,11 +5087,77 @@ void func_80181598(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801815D4);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801816E4);
+extern s32 D_80127190;
+extern void D_801C5CC0;
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181770);
+void func_801816E4(void *a0)
+{
+    s32 *s0 = (s32 *)a0;
+    s32 *s1;
+    s32 v0;
+    s32 v1;
+
+    *(u16 *)((s8 *)s0 + 0x6) = 0;
+    v0 = D_80127190;
+    s1 = *(s32 **)((s8 *)s0 + 0x20);
+    *(u16 *)((s8 *)s0 + 0xE) = 0;
+    v0 += -0x154;
+    *(u16 *)((s8 *)s0 + 0xA) = v0;
+    func_8001CD50((s32)s1, (s32)&D_801C5CC0);
+
+    v0 = -0x7800;
+    *(u16 *)((s8 *)s1 + 0x1E) = v0;
+    v0 = 0x400;
+    *(u16 *)((s8 *)s1 + 0x10) = v0;
+    v0 = *(s32 *)((s8 *)s1 + 0x4);
+    v1 = 0x50000000;
+    v0 |= v1;
+    *(s32 *)((s8 *)s1 + 0x4) = v0;
+
+    v0 = *(u16 *)((s8 *)s0 + 0x2);
+    v1 = 0x1F;
+    *(u16 *)((s8 *)s0 + 0x2E) = v1;
+    v0 += 1;
+    *(u16 *)((s8 *)s0 + 0x2) = v0;
+}
+
+
+typedef struct { s32 q[16]; } Str_801C5B00;
+extern Str_801C5B00 D_801C5B00[];
+extern void func_801292C8(u8 *arg0);
+
+void func_80181770(u8 *arg0) {
+    u16 sp1E;
+    u8 *sp18;
+
+    sp1E = *(u16 *)(arg0 + 0x2E);
+    sp18 = *(u8 **)(arg0 + 0x20);
+    *(u16 *)(arg0 + 0x2E) = sp1E - 1;
+    if ((s16)sp1E < 0) {
+        func_801292C8(arg0);
+    } else {
+        *(u32 *)(sp18 + 0x20) = (u32)&D_801C5B00[(s16)(sp1E - 1) >> 2];
+    }
+}
+
+
+extern void func_801292C8(u8 *a0);
+extern void func_8012931C(struct vec *a0);
+
+void func_801817CC(s32 *a0) {
+    func_8012931C((struct vec *)a0);
+    if (*(s16 *)((u8 *)a0 + 0x28) != 0) {
+        func_80169A4C((s32)a0, *(s32 *)((u8 *)a0 + 0x34));
+        *(s32 *)((u8 *)a0 + 0x14) += 0xF000;
+    } else {
+        func_801696D8((s32)a0, *(s32 *)((u8 *)a0 + 0x34));
+        *(s32 *)((u8 *)a0 + 0x14) += 0x8000;
+    }
+    if (--*(s32 *)((u8 *)a0 + 0x1C) == -1) {
+        func_801292C8((u8 *)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801817CC);
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181854);
 
@@ -5004,7 +5225,35 @@ void func_801826AC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801826E8);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801827B4);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern void func_8012A828(s32, void*);
+extern void (*D_8018A2E8[])(void *);
+extern u8 D_8018A2C8[];
+extern u8 D_8018A2D8[];
+extern M2C_UNK D_80183884;
+
+void func_801827B4(void *a0) {
+    s32 ret;
+
+    ret = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = ret;
+    if (ret == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+    func_8001C214(ret, (s32)D_8018A2E8[*(s16 *)((s32)a0 + 0x70)]);
+    func_8001D0E8(*(s32 *)((s32)a0 + 0x20), 0xC0, 0x94);
+    *(s32 *)((s32)a0 + 0x58) =
+        (*(s16 *)((s32)a0 + 0x70) == 2 ? (s32)&D_8018A2D8 : (s32)&D_8018A2C8) | 0x40000000;
+    *(s16 *)((s32)a0 + 0x5C) = 0x800;
+    ((void (*)(void *, void *))func_8012A828)(a0, &(*(u8 *)&D_80183884));
+    *(s16 *)((s32)a0 + 2) = 1;
+    *(s32 *)((s32)a0 + 0xDC) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018287C);
 
@@ -5097,16 +5346,49 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018305
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801831A0);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801831E8);
+extern u16 D_800B99DA;
+extern u32 D_801C7594;
+extern u32 D_801C7598;
 
-extern void func_80183278(void);
+void func_801831E8(s32 arg0) {
+    extern void func_8012C098(void *);
+    u32 *ptr = (u32 *) &D_801C7594;
+
+    if (D_800B99DA & 1) {
+        *ptr = 0x80A040;
+    } else {
+        *ptr = 0x709030;
+    }
+    D_801C7598 = 0;
+    if ((*(s32 *)(arg0 + 0x1C) != 0) && (--*(s32 *)(arg0 + 0x1C) == 0)) {
+        func_8012C098((void *) arg0);
+    }
+}
+
+
+extern void func_80183278();
     void func_80183258(s32 *a0) {
         *(s16 *)((s32)a0 + 0xFE) = 0;
         func_80183278();
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80183278);
+extern u16 D_8018A478[][4];
+
+void func_80183278(s32 *a0) {
+    u16 idx;
+    u16 *ent;
+    s32 dst;
+
+    idx = (*(u16 *)((s32)a0 + 0xFE) + 1) & 1;
+    *(u16 *)((s32)a0 + 0xFE) = idx;
+    ent = &D_8018A478[idx][0];
+    dst = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)(dst + 0x28) = ent[0];
+    *(u16 *)(dst + 0x2A) = ent[1];
+    *(u8 *)(dst + 0x27) = (u8)ent[2];
+}
+
 
 extern void (*D_8018A488[])(void);
 
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
index 3669a56811..ef0e60a4d4 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
@@ -3170,7 +3170,33 @@ void func_8017CA80(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017D960);
+void func_8017D960(void) {
+    extern void func_8012A018(s32 a0, s32 a1);
+    extern void func_8012A094(s32 a0);
+    extern void func_8017DD2C(void *a0);
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    extern u8 D_80126948[];
+
+    D_80126954 = 0x1F4;
+    D_8012695C = 0x320;
+    D_80126968 = 0x60;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0x18;
+    D_80126978 = -0x80;
+    D_8012697A = -0x7D;
+    func_8012A018((s32)func_8017DD2C, 0);
+    func_8017DD2C(D_80126948);
+    func_8012A094((s32)D_80126948);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DA00);
 
@@ -3178,7 +3204,22 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DA9
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DAF8);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DB44);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017DD2C(void *a0);
+
+void func_8017DB44(void) {
+    extern u8 D_80126948[];
+    extern s32 D_80126950;
+    extern s32 D_80126954;
+
+    D_80126950 = 0x190;
+    D_80126954 = 0x190;
+    func_8012A018((s32)func_8017DD2C, 3);
+    func_8017DD2C(D_80126948);
+    func_8012A094((s32)D_80126948);
+}
+
 
 extern s8 D_8012694C;
 extern s32 D_8012695C;
@@ -3207,7 +3248,30 @@ extern s32 D_8012695C;
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DC04);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DCAC);
+extern s32 D_80126954;
+extern s32 D_8012695C;
+extern s16 D_80126968;
+extern s16 D_8012696A;
+extern s16 D_8012696C;
+extern s16 D_80126976;
+extern s16 D_80126978;
+extern s16 D_8012697A;
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8017DD2C(void *a0);
+
+void func_8017DCAC(void)
+{
+    D_80126954 = 0x1F4;
+    D_8012695C = 0x320;
+    D_80126968 = 0x60;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0x18;
+    D_80126978 = -0x80;
+    D_8012697A = -0x7D;
+    ((void (*)(void (*fn)(void *), int))func_8012A018)(func_8017DD2C, 0);
+}
+
 
 
 extern void (*D_8018A294[])(void);
@@ -3217,7 +3281,28 @@ void func_8017DD2C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DD68);
+#include "common.h"
+
+extern s32 ratan2(s32 dx, s32 dy);
+extern u16 D_80126B5E;
+extern u16 D_80126B66;
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80047948(s32 a0);
+extern s32 func_8017DECC(s32 param_1, s32 param_2);
+
+void func_8017DD68(s32 param_1) {
+    s32 angle;
+    s32 delta;
+
+    angle = ratan2(*(s16 *)&D_80126B5E, *(s16 *)&D_80126B66) & 0xFFF;
+    delta = angle - 0x400;
+
+    *(s16 *)(param_1 + 0x2e) = func_8004787C(delta) / 32;
+    *(s16 *)(param_1 + 0x32) = func_80047948(delta) / 32;
+
+    func_8017DECC(param_1, angle);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017DDFC);
 
@@ -3401,9 +3486,38 @@ extern void func_80175454(void);
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E598);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E608);
+extern s32 func_80012B04(s32 a0, s32 a1, s32 a2);
+extern s32 func_80146994(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017DB44(void);
+
+void func_8017E608(u8 *a0) {
+    s32 v0;
+    s32 s1;
+    s32 t;
+    v0 = *(s32 *)(a0 + 0x20);
+    s1 = func_80012B04(*(s16 *)(v0 + 0x12), 0xB1C, 4);
+    if ((s16)s1 == 0) {
+        func_80146994(25, (s32)a0, 0x4BB04BC, 0);
+        func_8017DB44();
+        *(u8 *)(a0 + 0x214) += 1;
+        *(u8 *)(a0 + 0x4D) += 1;
+    }
+    t = *(s32 *)(a0 + 0x20);
+    *(u16 *)(t + 0x12) = (*(u16 *)(t + 0x12) + s1) & 0xFFF;
+}
+
+
+extern s32 func_8014C050(s32 a0, s32 a1);
+extern u8 D_800AE6BD;
+
+void func_8017E6A8(s32 a0)
+{
+    if (func_8014C050(a0, 0x19) == 0) {
+        *(u8 *)(a0 + 0x214) += 1;
+        D_800AE6BD += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E6A8);
 
 void func_8017E704(void) {
 }
@@ -3426,13 +3540,38 @@ void func_8017E734(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E770);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E7C0);
+
+void func_8017E7C0(void *a0) {
+    extern Blk8 D_801C60C0;
+    Blk8 buffer;
+
+    buffer = D_801C60C0;
+    if (func_80171D1C(a0, &buffer, 0x80)) {
+        *(s32 *)((s32)a0 + 0x204) = 8;
+        (*(u8 *)((s32)a0 + 0x214))++;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E834);
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E890);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E8E8);
+extern s16 D_801A3288;
+
+void func_8017E8E8(void *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = *(s32 *)((s8 *)arg0 + 0x204) - 1;
+    *(s32 *)((s8 *)arg0 + 0x204) = temp_v0;
+    if (temp_v0 == -1) {
+        *(s32 *)((s8 *)arg0 + 0x198) = func_8013767C((s32)&D_801A3288);
+        *(s32 *)((s8 *)arg0 + 0x204) = 0;
+        *(s16 *)((s8 *)arg0 + 0x20C) = 0x5A;
+        *(u8 *)((s8 *)arg0 + 0x214) = *(u8 *)((s8 *)arg0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017E94C);
 
@@ -3448,7 +3587,20 @@ void func_8017E9F8(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017EA4C);
+extern void func_80175414(s32 _arg0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8017DBDC(void);
+extern void func_8016F0E4(void);
+extern void func_80165770(void);
+
+void func_8017EA4C(s32 param_1) {
+    func_80175414(param_1);
+    func_8002D4C8(0x13, 2);
+    func_8017DBDC();
+    ((void (*)(s32))func_8016F0E4)(param_1);
+    ((void (*)(s32))func_80165770)(param_1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017EA98);
 
@@ -3458,7 +3610,7 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017ED5
 
 /* callees — raw signatures inferred from this TU's own call sites (law 1b/2:
    no prior declaration of any of these exists in this TU) */
-extern void func_8018072C(s32 a0, s32 a1, s16 *a2);
+extern void func_8018072C();
 extern s32 func_8004787C(s32 a0);   /* already declared elsewhere in this TU, same signature */
 extern s32 func_80180720(s32 a0);
 extern void func_8017EEF4(u8 *a0);
@@ -3502,13 +3654,40 @@ void func_8017EDBC(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017EEF4);
+void func_8017EEF4(u8 *a0) {
+    extern s16 D_801C7748;
+    s32 frame_pad[2];
+    u16 temp;
+
+    (void)&frame_pad;
+
+    *(s16 *)(a0 + 2) = 2;
+    temp = *(u16 *)&D_801C7748;
+    *(s32 *)(a0 + 0x1C) = 0;
+    *(s16 *)(a0 + 0x34) = 0;
+    *(s16 *)(a0 + 0xE0) = 0;
+    *(s16 *)(a0 + 0xDC) = temp + 0x600;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017EF28);
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F198);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F218);
+void func_8017F218(void *arg0) {
+    extern void func_8012A828(s32 a0, void *a1);
+    extern void func_80174824(void);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+    extern s32 D_8018A4C8;
+
+    *(s16 *)((u8 *)arg0 + 0x5C) = 0;
+    func_8012A828((s32)arg0, &D_8018A4C8);
+    *(s16 *)((u8 *)arg0 + 0x2) = 2;
+    *(s32 *)((u8 *)arg0 + 0x1C) = 0x3C;
+    func_80174824();
+    func_8002D4C8(0x4BA, 0);
+}
+
 
 extern void func_8017484C(s32 a0);
     void func_8017F26C(s32 *a0) {
@@ -3605,9 +3784,62 @@ extern s32 func_8012BEE8(s32 arg);
 void func_8017F558(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F560);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_8017F560(void *a0) {
+    extern u8 D_801BE5E8[];
+    extern u8 D_8018A778;
+    extern u8 D_8018A788[];
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+    } else {
+        func_8001C214(v0, (s32)D_801BE5E8);
+        *(s32 *)((s32)a0 + 0x58) = (s32)&D_8018A778;
+        *(s16 *)((s32)a0 + 0x5C) = 0x800;
+        func_8012A828((s32)a0, D_8018A788);
+        *(s16 *)((s32)a0 + 2) = 1;
+        *(s32 *)((s32)a0 + 0x1C) = 0x140;
+    }
+}
+
+
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001CA1C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8012AD50(void *a0);
+extern s32 D_801270D8;
+extern s32 D_8018A7A8[];
+extern s32 D_8018A838[];
+
+void func_8017F5E4(s32 param_1)
+{
+    s32 iVar1;
+
+    *(s32 *)(param_1 + 0x20) = iVar1 = ((s32 (*)(void))func_8012C1B8)();
+    if (iVar1 == 0) {
+        ((void (*)(s32))func_8012CAE4)(param_1);
+    } else {
+        ((void (*)(s32, void *))func_8001CA1C)(iVar1, &D_8018A7A8);
+        *(s16 *)(iVar1 + 0x1A) = 0x3000;
+        *(s16 *)(iVar1 + 0x18) = 0x3000;
+        *(s32 *)(iVar1 + 4) |= 0x50000000;
+        *(s16 *)(param_1 + 0xE) = 0;
+        *(s16 *)(param_1 + 6) = 0;
+        *(s16 *)(param_1 + 0xA) = -0x3AA;
+        *(s32 *)(param_1 + 0xDC) = D_801270D8;
+        func_8012A828(param_1, &D_8018A838);
+        func_8012AD50(param_1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F5E4);
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F690);
 
@@ -3619,7 +3851,23 @@ void func_8017F768(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8017F7A4);
+extern s32 D_8018A8A8;
+extern s32 D_8018A8B4;
+
+void func_8017F7A4(s32 arg0) {
+    s32 s0;
+
+    s0 = *(s32 *)(arg0 + 0x20);
+    func_8001CB6C((u8 *)s0, (s32)&D_8018A8A8, 0x2E0, 0);
+    *(u8 *)(s0 + 0x27) = 0x9E;
+    *(u16 *)(s0 + 0x1A) = 0x4000;
+    *(u16 *)(s0 + 0x18) = 0x4000;
+    *(u16 *)(s0 + 0x10) = 0x400;
+    *(u32 *)(s0 + 4) = *(u32 *)(s0 + 4) | 0x50000000;
+    func_80128EA8(s0, arg0 + 0x24, (s32)&D_8018A8B4);
+    *(u16 *)(arg0 + 0x2) += 1;
+}
+
 
 extern s32 func_80128ED8(s32 param_1, s32 *param_2);
 extern void func_801292C8(void);
@@ -4009,7 +4257,30 @@ void func_80180650(s32 a0, s32 out) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80180720);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8018072C);
+extern s32 func_80047948(s32 a0);
+extern s32 func_8004787C(s32 a0);
+
+void func_8018072C(s32 a0, s32 a1, s32 out) {
+    s32 t;
+    s32 x;
+    s32 angle;
+    s32 q1;
+    s32 sinVal;
+    s32 cosVal;
+
+    t = a0;
+    x = -(t * 1536);
+    angle = t & 0xFFF;
+    q1 = x / 12288 - 0x22;
+
+    sinVal = func_80047948(angle) * a1 >> 12;
+    cosVal = func_8004787C(angle) * a1 >> 12;
+
+    *(s16 *)(out + 0) = sinVal;
+    *(s16 *)(out + 2) = q1;
+    *(s16 *)(out + 4) = cosVal;
+}
+
 
 #include "common.h"
 
@@ -4352,7 +4623,16 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80181DE
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80181ED4);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80181F3C);
+extern void func_8012A828(s32 a0, void *a1);
+extern void D_801A1AB8;
+
+void func_80181F3C(s32 a0) {
+    *(u16 *)(a0 + 0x5C) = 0xAA00;
+    func_8012A828(a0, &D_801A1AB8);
+    *(s16 *)(a0 + 2) = 3;
+    *(s16 *)(a0 + 0xFE) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80181F80);
 
@@ -4487,7 +4767,23 @@ void func_80182E14(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80182F90);
+extern u8 D_801A21E0[];
+
+void func_80182F90(s32 a0)
+{
+    s32 v1;
+
+    *(s16 *)(a0 + 0x2) = 0xE;
+    *(u16 *)(a0 + 0x34) = 0;
+    func_8012A828(a0, D_801A21E0);
+    v1 = *(s32 *)(a0 + 0x20);
+    *(u16 *)(a0 + 0x5C) = 0xAA00;
+    *(u16 *)(a0 + 0x5E) = 0;
+    *(u16 *)(v1 + 0x14) = 0;
+    *(u16 *)(v1 + 0x10) = 0;
+    func_8012B23C(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80182FEC);
 
@@ -5191,7 +5487,17 @@ void func_80184460(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801845A0);
+void func_801845A0(void *arg0) {
+    extern void func_8012A828(s32, void*);
+    extern s32 D_801A2750;
+
+    ((void (*)(void *, void *))func_8012A828)(arg0, &D_801A2750);
+    *(s16 *)((u8 *)arg0 + 0x2) = 0x2;
+    *(s32 *)((u8 *)arg0 + 0x1C) = 0x1E;
+    *(s16 *)((u8 *)arg0 + 0x34) = 0;
+    *(s16 *)((u8 *)arg0 + 0xFC) = 1;
+}
+
 
 struct S845EC_in { s16 f00, f02, f04, f06, f08, f0A, f0C, f0E; s32 f10; };
 struct S845EC_out { s16 a, b, c; };
@@ -5348,7 +5654,24 @@ void func_80184AD0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80184B10);
+extern void (*D_8018AA40)(void *);
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+extern void func_80181978(void *a0);
+extern void func_80181920(void *a0);
+
+void func_80184B10(s32 *a0)
+{
+    s32 s1 = (s32)D_8018AA40;
+    if (func_8012BEE8((s32)a0) != 0) {
+        if (func_8012BD3C((s32)a0, 0x400, s1 * s1) != 0) {
+            func_80181978(a0);
+        } else {
+            func_80181920(a0);
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -5422,16 +5745,92 @@ void func_80184C90(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80184CE8);
+extern s32 func_80143B6C(s32 arg0, s32 arg1);
+extern void func_8012CBA4(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B21C(void *a0);
+extern u8 D_801A1820[];
+
+void func_80184CE8(s32 a0) {
+    u16 timer;
+
+    timer = *(u16 *)(a0 + 0xFC) - 1;
+    *(u16 *)(a0 + 0xFC) = timer;
+    if ((s16)timer <= 0) {
+        func_80143B6C(a0, 0);
+        *(u16 *)(a0 + 0xFC) = 8;
+    }
+    if (((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) {
+        *(s32 *)(a0 + 0x14) = 0;
+    }
+    if (func_8012BEE8(a0)) {
+        func_8012A828(a0, D_801A1820);
+        *(u16 *)(a0 + 2) = 1;
+        func_8012B21C((void *)a0);
+        *(s32 *)(a0 + 0x1C) = 0x14;
+    }
+}
+
 
 void func_80184D88(void) {
 }
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80184D90);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80184E28);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_80047D3C(s32 a0);
+extern s32 func_801807D8(s16 *a0);
+extern s32 D_801A1A10;
+
+void func_80184E28(s32 param_1)
+{
+    s16 tmp[3];
+    s32 sq;
+
+    if (func_8012BEE8(param_1) != 0) {
+        *(u8 *)(param_1 + 0xC1) = 0;
+        *(s16 *)(param_1 + 0x2) = 1;
+        *(s16 *)(param_1 + 0x34) = 0;
+        func_8012A828(param_1, &D_801A1A10);
+        *(s32 *)(param_1 + 0x1C) = 0xA;
+        *(u16 *)(param_1 + 0x5C) |= 0x8000;
+        *(u16 *)(param_1 + 0x5E) = 0;
+        *(u16 *)(param_1 + 0xFC) ^= 1;
+        tmp[0] = *(s16 *)(param_1 + 0x6);
+        tmp[1] = *(s16 *)(param_1 + 0xA);
+        tmp[2] = *(s16 *)(param_1 + 0xE);
+        sq = (tmp[0] * tmp[0]) + (tmp[2] * tmp[2]);
+        *(s16 *)(param_1 + 0xDE) = func_80047D3C(sq);
+        *(s16 *)(param_1 + 0xDC) = func_801807D8(tmp);
+    }
+}
+
+
+extern s32 func_8012B8E4(s32 arg0, s32 arg1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_80142414(void *a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80181F3C(s32 a0);
+
+void func_80184EEC(s32 param_1)
+{
+    s32 v;
+    unsigned short *p;
+
+    v = func_8012B8E4(param_1, 4);
+    p = (unsigned short *)(*(s32 *)(param_1 + 0x20) + 0x12);
+    *p = (unsigned short)(*p + v);
+    if (*(s32 *)(param_1 + 0x1C) == 0xF) {
+        func_8002D4C8(0x6A9, 0);
+        func_80142414((void *)param_1, -0x78);
+    }
+    if (func_8012BEE8(param_1) != 0) {
+        func_80181F3C(param_1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80184EEC);
 
 extern void func_8012E364(void);
     void func_80184F6C(void) {
@@ -5473,11 +5872,50 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8018508
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185150);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801851EC);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80130D48(s32 a0);
+extern void func_8012C098(void *a0);
+extern s32 D_801270D4;
+extern s32 D_801270E4;
+
+void func_801851EC(s32 param_1) {
+    register s32 *p __asm__("$2");
+    register s32 mask __asm__("$5");
+
+    mask = 0x80000000;
+    p = *(s32 **)(param_1 + 0x20);
+    p[1] ^= mask;
+    if (((s32 (*)(void))func_8012BEE8)() == 0) {
+        return;
+    }
+    func_80130D48(param_1);
+    if (*(s16 *)(param_1 + 0x70) == 2) {
+        D_801270E4 -= 1;
+    } else {
+        D_801270D4 -= 1;
+    }
+    func_8012C098(param_1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8018528C);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185348);
+#include "common.h"
+
+void func_80185348(s32 param_1) {
+    switch (*(u16 *)(param_1 + 0x34)) {
+    case 0:
+        func_8018392C(param_1);
+        break;
+    case 1:
+        func_80183A7C(param_1);
+        break;
+    case 2:
+        func_80183BD0(param_1);
+        break;
+    }
+}
+
 
 void func_801853C4(void) {
 }
@@ -5486,13 +5924,62 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801853C
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8018544C);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185528);
+extern void func_8012AD80(s32 a0);
+extern void func_80183DA4();
+extern void func_8005C2C8(s32 a0, s32 a1);
+extern void func_8012C098(void *a0);
+extern s32 D_8018ABF4;
+
+void func_80185528(void *arg0)
+{
+    u16 sp10[3];
+
+    func_8012AD80((s32)arg0);
+    sp10[0] = *(u16 *)((s32)arg0 + 0x6);
+    sp10[1] = *(u16 *)((s32)arg0 + 0xA);
+    sp10[2] = *(u16 *)((s32)arg0 + 0xE);
+    *(u16 *)(*(s32 *)((s32)arg0 + 0xCC) + 0x8) = sp10[0];
+    *(u16 *)(*(s32 *)((s32)arg0 + 0xCC) + 0xA) = sp10[1];
+    *(u16 *)(*(s32 *)((s32)arg0 + 0xCC) + 0xC) = sp10[2];
+    *(u16 *)((s32)arg0 + 0x26) = *(u16 *)((s32)arg0 + 0x26) - D_8018ABF4;
+    func_80183DA4((s32)arg0 + 0x24);
+    *(s32 *)((s32)arg0 + 0x1C) += 1;
+    if (*(s32 *)((s32)arg0 + 0x1C) >= 0x28) {
+        func_8005C2C8(*(s32 *)((s32)arg0 + 0xCC), 0x84);
+        func_8012C098(arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801855EC);
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801856D8);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801857BC);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s16 D_8018AC1C;
+
+void func_801857BC(s32 param_1)
+{
+    s32 iVar1;
+    u16 uVar2;
+
+    iVar1 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(param_1 + 0x20) = iVar1;
+    if (iVar1 == 0) {
+        ((void (*)(s32))func_8012CAE4)(param_1);
+        return;
+    }
+    ((void (*)(s32, s32))func_8001C214)(iVar1, 0);
+    uVar2 = *(u16 *)(param_1 + 0x72);
+    *(s32 *)(param_1 + 0x58) = (s32)&D_8018AC1C;
+    *(s16 *)(param_1 + 2) = 1;
+    *(s32 *)(param_1 + 0x1C) = 0x10;
+    *(u16 *)(param_1 + 0xFC) = 0;
+    *(u16 *)(param_1 + 0x72) = uVar2 | 0x1000;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185834);
 
@@ -5638,7 +6125,37 @@ void func_80185AF8(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185B34);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_80185B78);
+#include "common.h"
+
+extern void func_80185C0C(s32 arg0);
+extern void func_8012931C(void *a0, s32 a1);
+extern void func_801292C8(void);
+
+void func_80185B78(void *a0) {
+    register s8 *s0 __asm__("$16");
+    s32 pad[2];
+    s32 cnt;
+    s32 t;
+
+    s0 = (s8 *)a0;
+    cnt = *(s32 *)(s0 + 0x1C);
+
+    if (cnt == 0) {
+        func_80185C0C((s32)s0);
+        *(volatile s32 *)(s0 + 0x10) = *(s32 *)(s0 + 0x10);
+        t = *(s32 *)(s0 + 0x18);
+        *(s32 *)(s0 + 0x18) = t;
+        *(s32 *)(s0 + 0x14) = *(s32 *)(s0 + 0x14) + 0xC000;
+        func_8012931C(s0, t);
+        if (*(s16 *)(s0 + 0x2E) < *(s16 *)(s0 + 0xA)) {
+            *(s16 *)(s0 + 0xA) = *(s16 *)(s0 + 0x2E);
+            ((void (*)(u8 *))func_801292C8)((u8 *)s0);
+        }
+    } else {
+        *(s32 *)(s0 + 0x1C) = cnt - 1;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
index 3aee18f5be..07614e98e7 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
@@ -3910,7 +3910,23 @@ void func_8017F924(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F998);
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_8017E26C(void);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801270C8;
+
+void func_8017F998(s32 param_1)
+{
+    if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(param_1 + 0x198));
+        func_8017E26C();
+        func_8002D4C8(0x510, 0x103F);
+        D_801270C8 = 0xB;
+        *(u8 *)(param_1 + 0x214) = *(u8 *)(param_1 + 0x214) + 1;
+    }
+}
+
 
 extern s32 D_801270C8;
 extern void func_8017FA3C(void);
@@ -3924,7 +3940,28 @@ void func_8017FA0C(void) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FA3C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FA94);
+#include "common.h"
+
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_80175414(s32 _arg0);
+extern void func_8012A100(s8 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+extern s32 D_80197300;
+
+void func_8017FA94(s32 arg0) {
+    s32 s0 = arg0;
+    if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(s0 + 0x198));
+        ((void (*)(void))func_80175414)();
+        func_8012A100(0);
+        func_8002D4C8(0x510, 0x102F);
+        *(s32 *)(s0 + 0x198) = func_8013767C((s32)&D_80197300);
+        *(u8 *)(s0 + 0x214) = *(u8 *)(s0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FB14);
 
@@ -3949,7 +3986,32 @@ void func_8017FC64(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FCFC);
+extern s32 func_80012B04(s32 a0, s32 a1, s32 a2);
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_80147060(u8 * a0);
+extern void func_8017E26C(void);
+extern s32 D_801270C8;
+
+void func_8017FCFC(s32 arg0) {
+    s32 s0 = arg0;
+    s32 r;
+    s32 v1;
+
+    r = func_80012B04(*(s16 *)(*(s32 *)(s0 + 0x20) + 0x12), 0x800, 4);
+    if ((r << 16) == 0) {
+        if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) {
+            func_80147060((u8 *)s0);
+            func_80139914(*(s32 *)(s0 + 0x198));
+            func_8017E26C();
+            D_801270C8 = 0xE;
+            *(u8 *)(s0 + 0x214) += 1;
+        }
+    }
+    v1 = *(s32 *)(s0 + 0x20);
+    *(s16 *)(v1 + 0x12) = (*(u16 *)(v1 + 0x12) + r) & 0xFFF;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FDB4);
 
@@ -3959,9 +4021,38 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FEA
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FF2C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FF8C);
+extern s32 D_8012695C;
+extern s16 D_80126968;
+extern s16 D_80126978;
+extern s32 D_801270C8;
+
+void func_8017FF8C(void *a0) {
+    if (--*(s32 *)((s32)a0 + 0x204) == -1) {
+        *(s32 *)((s32)a0 + 0x204) = 0x40;
+        D_8012695C = 0x190;
+        D_80126968 = -0x155;
+        D_80126978 = 0x20;
+        D_801270C8 = 0x13;
+        *(u8 *)((s32)a0 + 0x214) += 1;
+    }
+}
+
+
+typedef struct { u8 b[8]; } Blk8x;
+
+void func_8017FFF0(s32 arg0) {
+    extern Blk8x D_801E2DE8;
+    extern s32 D_801270C8;
+    Blk8x buffer;
+
+    buffer = D_801E2DE8;
+    if (--*(s32 *)(arg0 + 0x204) == -1) {
+        D_801270C8 = 0x14;
+        *(s32 *)(arg0 + 0x204) = 0x40;
+        *(u8 *)(arg0 + 0x214) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FFF0);
 
 
 #include "common.h"
@@ -4005,7 +4096,20 @@ void func_8018016C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801801DC);
+s32 func_801801DC(void *a0) {
+    extern void func_80190408(void);
+    extern void func_8012A100(s8 a0);
+
+    s32 *p = (s32 *)((u8 *)a0 + 0x204);
+    *p = *p - 1;
+
+    if (*p == -1) {
+        func_80190408();
+        func_8012A100(0);
+        (*(u8 *)((u8 *)a0 + 0x214))++;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180234);
 
@@ -4043,7 +4147,23 @@ void aF801804D4(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180510);
+extern s32 D_801270C8;
+
+void func_80180510(void *a0) {
+    s32 *state = &D_801270C8;
+    if (*state == 0x16) {
+        *state = 0x17;
+        *(s16 *)((s32)a0 + 0x20C) = 0;
+    } else if (*state == 0x17) {
+        *state = 0x18;
+        *(s16 *)((s32)a0 + 0x20C) = 1;
+    } else if (*state >= 0x18) {
+        *state = 0x1E;
+        *(s16 *)((s32)a0 + 0x20C) = 2;
+    }
+    *(u8 *)((s32)a0 + 0x214) += 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180574);
 
@@ -4122,13 +4242,59 @@ void func_80180C64(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180CA0);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180D18);
+void func_80180D18(s32 a0) {
+    s32 s0 = a0;
+    extern s16 D_80194556;
+    extern s16 D_80126960;
+    extern s16 D_80126962;
+    extern s32 D_801270C8;
+    extern s32 D_80126958;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    if (*(s16 *)(func_8014C168((s32 *)s0, 0x3D) + 0xA) - D_80194556 > 0) {
+        D_801270C8 = 0x1F;
+        D_80126958 = 0x708;
+        D_8012695C = 0x708;
+        D_80126960 = 0x31C;
+        D_80126968 = 0x31C;
+        D_80126962 = 0x400;
+        D_8012696A = 0x400;
+        *(s32 *)(s0 + 0x204) = 0x20;
+        *(u8 *)(s0 + 0x214) += 1;
+    }
+}
+
+
+extern void func_800D0C48(s32 a0);
+
+void func_80180DB8(void *a0) {
+    s32 v0;
+    s32 v1 = -1;
+    v0 = *(s32 *)((s32)a0 + 0x204);
+    v0 += -1;
+    *(s32 *)((s32)a0 + 0x204) = v0;
+    if (v0 == v1) {
+        func_800D0C48(2);
+        *(u8 *)((s32)a0 + 0x214) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180DB8);
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180E08);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180F5C);
+extern int func_8001AAA0(void);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80180F5C(int param_1)
+{
+    if (((s32 (*)(s32))func_8001AAA0)(0x15) != 0) {
+        func_8002D4C8(0x10A, 0);
+        *(unsigned char *)(param_1 + 0x214) += 1;
+    }
+    return;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180FA8);
 
@@ -4163,15 +4329,43 @@ void func_80181060(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801810F0);
+void func_801810F0(void *a0)
+{
+    extern s16 D_800B9AAC[];
+    if (--*(s32 *)((s32)a0 + 0x204) == -1) {
+        D_800B9AAC[0] = 0x7FFF;
+        *(u8 *)((s32)a0 + 0x214) += 1;
+        *(s16 *)((s32)a0 + 0xAC) = 0x80;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8018112C);
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8018118C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181238);
+extern s32 D_801270C8;
+extern void func_8016F0E4(void);
+extern void func_801812B4(void);
+
+void func_80181238(void) {
+    if (D_801270C8 == 0x22) {
+        func_8016F0E4();
+        func_801812B4();
+    }
+}
+
+
+extern s16 D_801E4C50;
+extern s16 D_801E4C52;
+extern s16 D_801E4C54;
+void func_80181270(s32 a0) {
+    s32 v0 = func_8014C168(a0, 0x42);
+    D_801E4C50 = *(u16 *)(v0 + 0x6);
+    D_801E4C52 = *(u16 *)(v0 + 0xA);
+    D_801E4C54 = *(u16 *)(v0 + 0xE);
+}
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181270);
 
 extern void func_8016EDEC(s32 a0, s32 a1, s32 a2);
 extern void func_801812DC(void*);
@@ -4194,15 +4388,61 @@ void func_80181318(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181330);
+void func_80181330(void *a0) {
+    s32 v0;
+    v0 = *(s32 *)(a0 + 0x204) - 1;
+    *(s32 *)(a0 + 0x204) = v0;
+    if (v0 == -1) {
+        func_8002D4C8(0x10B, 0);
+        *(s32 *)(a0 + 0x204) = 0x10;
+        *(u8 *)(a0 + 0x214) = *(u8 *)(a0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181388);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801813F0);
+void func_801813F0(void *a0) {
+    s32 v0;
+    s32 v1 = -1;
+    v0 = *(s32 *)((s32)a0 + 0x200);
+    v0 += -1;
+    *(s32 *)((s32)a0 + 0x200) = v0;
+    if (v0 == v1) {
+        *(u8 *)((s32)a0 + 0x214) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8018141C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801814B4);
+extern s32 func_801816CC(s32 a0, s32 a1);
+extern s32 D_800D5904;
+
+void func_801814B4(s32 param_1)
+{
+    s32 temp;
+
+    temp = *(u8 *)((s32)param_1 + 0x20C);
+    *(u8 *)((s32)param_1 + 0x20C) += 0xFF;
+    if (temp == 0) {
+        *(u8 *)((s32)param_1 + 0x20C) = 0x20;
+        if (*(u8 *)((s32)param_1 + 0x20D) & 1) {
+            *(s32 *)((s32)param_1 + 0x204) = 0xFFFF4000;
+        } else {
+            *(s32 *)((s32)param_1 + 0x204) = 0xC000;
+        }
+        (*(u8 *)((s32)param_1 + 0x20D))--;
+    }
+    func_801816CC(param_1, *(s32 *)((s32)param_1 + 0x204));
+    if (*(u8 *)((s32)param_1 + 0x20D) == 0) {
+        func_80154274((s32 *)param_1, (s32)&D_800D5904);
+        func_80154A74(param_1, 2);
+        *(s32 *)((s32)param_1 + 0x208) = 0x160000;
+        (*(u8 *)((s32)param_1 + 0x214))++;
+    }
+}
+
 
 void func_80181570(s32 a0) {
     extern s32 D_800D5C00[];
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
index 93fd0a176a..2ca8464203 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
@@ -3162,7 +3162,22 @@ void func_801824D0(s32 s0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80182740);
+extern void func_80186304(u8*, s32, s32);
+
+void func_80182740(void *arg0) {
+    s32 s0;
+
+    __asm__ __volatile__("" : "=r"(s0) : "0"((s32)arg0));
+    *(u32 *)(s0 + 0x18) = 0;
+    if (*(u32 *)(s0 + 0xE8) & 0x2000) {
+        *(u32 *)(s0 + 0x10) = 0x38000;
+    } else {
+        *(u32 *)(s0 + 0x10) = 0x1C000;
+    }
+    func_80186304((u8 *)s0, 1, 0);
+    *(s16 *)(s0 + 0xE0) = -1;
+}
+
 
 #include "common.h"
 
@@ -3387,7 +3402,19 @@ void func_80183060(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80183074);
+void func_80183074(s32 *a0) {
+    extern s32 D_801270C8;
+    extern s32 D_80196288[];
+    D_801270C8 = 0x20;
+    *(s16 *)((s32)a0 + 0x34) = 0x5;
+    *(s32 *)((s32)a0 + 0x1C) = 0x70;
+    *(s32 *)((s32)a0 + 0xE8) &= ~0x4000;
+    func_8012C588(0x75, (s32)a0);
+    func_80189FA4(a0);
+    func_80019064(&D_80196288);
+    func_8002D4C8(0x50D, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801830F4);
 
@@ -3981,7 +4008,33 @@ void func_8018431C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80184358);
+extern s32 D_801E44E0;
+extern s32 D_801963D0;
+extern s32 *D_801D6D94;
+extern void func_801858C4(void *a0);
+void func_80184358(u8 *arg0) {
+    register u8 *a0 __asm__("$4") = arg0;
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+    v0 = *(u16 *)(a0 + 0x5C);
+    v1 = *(s32 *)(a0 + 0x64);
+    *(u16 *)(a0 + 0x5C) = v0 & 0xFFFE;
+    v0 = *(s32 *)(v1 + 0xE8);
+    if (v0 & 2) {
+        *(u8 *)(a0 + 0xC1) = 1;
+        *(s32 *)(a0 + 0x1C) = 8;
+        func_80185A04(a0, *(s32 *)(a0 + 0x64), *(s16 *)(a0 + 0x60));
+        func_801858C4(a0);
+    } else {
+        *(u8 *)(a0 + 0xC1) = 0;
+        *(s16 *)(a0 + 0xAE) = -1;
+        func_8012AD44((s32 *)a0, 3);
+        func_80132288(&D_801E44E0, &D_801963D0, (s32)D_801D6D94);
+        func_801858C4(a0);
+        func_8002D4C8(0x4F2, 0);
+    }
+}
+
 
 #include "common.h"
 
@@ -4478,7 +4531,34 @@ void func_80184D80(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80184D98);
+#include "common.h"
+
+extern void func_8012B200(u8 *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_80132DC4(s32 a0, s32 a1, s32 a2);
+
+void func_80184D98(void *arg0) {
+    s32 s0 = (s32)arg0;
+    s16 t;
+    struct {
+        s16 x;
+        s16 y;
+        s16 z;
+    } local;
+
+    func_8012B200((u8 *)s0);
+    local.x = *(u16 *)(*(s32 *)(s0 + 0x64) + 6) - 0x40;
+    t = *(u16 *)(*(s32 *)(s0 + 0x64) + 0xA) - 0x80;
+    *(u16 *)(s0 + 0x100) = t;
+    local.y = t;
+    local.z = *(u16 *)(*(s32 *)(s0 + 0x64) + 0xE);
+    func_80132DC4(s0, (s32)&local, 0x500);
+    *(u16 *)(s0 + 0x5C) &= ~1;
+    *(u8 *)(s0 + 0xC1) = 4;
+    *(u8 *)(s0 + 0xC2) = 0;
+    func_8002D4C8(0x505, 0);
+}
+
 
 extern void func_8012CBF4(s32 a0);
 extern void func_8013C9C4(void *a0);
@@ -4722,7 +4802,43 @@ void func_801853CC(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801853EC);
+extern void func_80186A04(s32 arg0);
+extern void func_8016AA50(s32 param_1, s32 param_2);
+extern void func_80185060(s32 a0, s32 a1);
+extern void func_80186B08(s32 param_1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_801853EC(s32 arg0) {
+    register s32 s0 __asm__("$16");
+    register s32 r76 __asm__("$2");
+    register s32 r60 __asm__("$6");
+    register s32 flags __asm__("$3");
+    s32 cnt;
+
+    s0 = arg0;
+    r76 = *(u16 *)(s0 + 0x76);
+    r60 = *(u16 *)(s0 + 0x60);
+    cnt = r76 - r60;
+    flags = *(u16 *)(s0 + 0x5C) & 0xFFFE;
+    *(u16 *)(s0 + 0x76) = cnt;
+    *(u16 *)(s0 + 0x5C) = flags;
+    func_8016AA50(arg0, *(s16 *)(s0 + 0x60));
+
+    if (*(s16 *)(s0 + 0x76) <= 0) {
+        *(u16 *)(s0 + 0x5E) = 0;
+        func_80185060(arg0, 1);
+        func_80186B08(arg0);
+    } else {
+        *(u8 *)(s0 + 0xC1) = 1;
+        *(s32 *)(s0 + 0x1C) = 8;
+        func_80186A04(arg0);
+    }
+
+    if (*(u16 *)(s0 + 0x5E) != 0x1D) {
+        func_8002D4C8(0x4F3, 0);
+    }
+}
+
 
 #include "common.h"
 
@@ -5408,7 +5524,18 @@ void func_80186CA8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80186D00);
+extern s32 D_801E43DC;
+extern s32 D_801E43E0;
+extern s32 D_801E43E4;
+extern s32 D_801E43E8;
+
+void func_80186D00(void) {
+    *(u16 *)(D_801E43DC + 0x5C) &= ~0x800;
+    *(u16 *)(D_801E43E0 + 0x5C) &= ~0x800;
+    *(u16 *)(D_801E43E4 + 0x5C) &= ~0x800;
+    *(u16 *)(D_801E43E8 + 0x5C) &= ~0x800;
+}
+
 
 
 
@@ -5491,7 +5618,17 @@ void func_80186DE8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80186F14);
+extern s32 D_801E43A0;
+
+void func_80186F14(void *a0)
+{
+    if (*(s16*)((s32)a0 + 0xFC) == 0 &&
+        (D_801E43A0 & 0x1540) != 0x1540) {
+        *(s16*)((s32)a0 + 0xFC) = 8;
+        *(s32*)((s32)a0 + 0xE8) &= ~0x40;
+    }
+}
+
 
 void func_80186F58(void *a0) {
         *(s16 *)((s32)a0 + 0xFC) = 0;
@@ -5586,7 +5723,39 @@ void func_801871E4(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80187280);
+extern s32 D_801E43A0;
+extern s32 D_801E4418[];
+extern s32 D_801E4474[];
+extern u16 D_80195B4A[];
+extern u32 D_801BD9D4[];
+extern s32 D_80195CA4[];
+
+void func_80187280(s32 arg0, s32 arg1) {
+    u16 var;
+    u16 i;
+    s32 *p;
+
+    var = arg1;
+    if (var < 14) {
+        if (var != 0) {
+            i = D_80195B4A[var];
+            p = D_801E4418;
+            if (i >= 0x16) {
+                p = D_801E4474;
+                i = i - 0x16;
+            }
+            arg1--;
+            if (i == 5) {
+                p[5] = 0x1000000;
+            } else {
+                p[i] = D_801BD9D4[arg1 & 0xFFFF];
+            }
+            *(s32 *)(arg0 + 0x58) = ((((arg1 & 0xFFFF) << 4) + (u32)D_80195CA4)) | 0x40000000;
+        }
+        D_801E43A0 |= 1 << var;
+    }
+}
+
 
 extern u16 D_80195B4A[];
 extern s32 D_801B82F4;
@@ -5861,7 +6030,28 @@ void func_801877FC(s32 s0) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_801878C0);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018791C);
+void func_8018791C(void *a0) {
+    s32 s0 = (s32)a0;
+
+    if (*(u32 *)(s0 + 0xE8) & 0x60000) {
+        func_80182998();
+        return;
+    }
+
+    func_80182918(s0);
+
+    if (!(*(u32 *)(s0 + 0xE8) & 0x1000)) {
+        if (*(s16 *)(s0 + 0x100) > 0) {
+            *(s16 *)(s0 + 0x100) = *(s16 *)(s0 + 0x100) - 1;
+        }
+    }
+
+    if (func_8018687C((void *)s0) || func_8018675C((void *)s0) || func_8012BEE8(s0)) {
+        *(u32 *)(s0 + 0xE8) = *(u32 *)(s0 + 0xE8) & ~0x1000;
+        func_801838A8((u8 *)s0);
+    }
+}
+
 
 extern void func_80181900(void *a0);
     void func_801879DC(void *a0) {
@@ -6449,7 +6639,25 @@ void func_801889D4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80188A10);
+extern void func_80143994(s32 a0, s32 a1);
+
+void *func_80188A10(void *a0) {
+    void *r;
+    void *v1;
+
+    r = (void *)((s32 (*)(s32, s32))func_80143994)((s32)a0, 0x7FFF);
+    if (r != 0) {
+        v1 = *(void **)((u8 *)r + 0xCC);
+        *(u16 *)((u8 *)r + 0) = 0x69;
+        if (v1 != 0) {
+            *(u8 *)((u8 *)v1 + 0x26) = 0xC8;
+            *(u8 *)((u8 *)v1 + 0x25) = 0xC8;
+            *(u8 *)((u8 *)v1 + 0x24) = 0xC8;
+        }
+    }
+    return r;
+}
+
 
 extern void func_8012AD44(s32 *a0, s16 a1);
     void func_80188A5C(void *arg0) {
@@ -6697,7 +6905,14 @@ void func_80189204(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_80189240);
+extern s32 *D_80126B78;
+
+void func_80189240(s32 a0)
+{
+    *(u16 *)(a0 + 0x5C) &= 0xFFFE;
+    *(u16 *)(a0 + 0x104) = *(u16 *)((s32)D_80126B78 + 0x12);
+}
+
 
 extern s32 *D_80126B78;
 
@@ -7454,7 +7669,28 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018AC1
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018AC48);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018ACB4);
+extern s32 D_801E4A58[];
+
+s32 func_8018ACB4(void *a0) {
+    s32 i;
+    s32 *p;
+    s32 ent;
+
+    for (i = 0, p = D_801E4A58; i < 12; i++, p++) {
+        ent = *p;
+        if (ent == 0) {
+            continue;
+        }
+        if (*(s16 *)(ent + 0xFC) != 0) {
+            continue;
+        }
+        if ((u16)(*(u16 *)(ent + 0xE) - *(u16 *)(a0 + 0xE) - 0x81) < 0x1F) {
+            return i;
+        }
+    }
+    return -1;
+}
+
 
 extern s32 D_801E4A58[];
 
@@ -7864,7 +8100,17 @@ void func_8018B638(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018B6A0);
+extern void func_801292C8(u8 *a0);
+extern void func_801895E0();
+
+void func_8018B6A0(s32 arg0) {
+    if (*(s16 *)(*(s32 *)(arg0 + 0x2C) + 0xFC) != 0) {
+        func_801292C8((u8 *)arg0);
+    } else {
+        func_801895E0(arg0);
+    }
+}
+
 
 #include "common.h"
 
@@ -9106,7 +9352,27 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018D31
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018D43C);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018D488);
+extern s32 D_801270C8;
+extern s32 func_8012C750(s32 a0);
+
+void func_8018D488(void) {
+    struct {
+        u16 f00, f02, f04, f06, f08, f0A, f0C, f0E;
+        u32 f10;
+    } buf;
+
+    D_801270C8 = 0;
+    buf.f06 = 0x52;
+    buf.f04 = 0;
+    buf.f02 = 0;
+    buf.f00 = 0;
+    buf.f08 = 1;
+    buf.f0A = 0;
+    buf.f0E = 0;
+    buf.f10 = 0;
+    func_8012C750((s32)&buf);
+}
+
 
 extern void (*D_80196C64[])(void);
 extern s16 D_80196C44[];
@@ -9463,7 +9729,26 @@ void func_8018DB40(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018DCD8);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018DDFC);
+extern void func_801439C0(u8 *a0);
+extern void func_8012C218(void *a0);
+
+void func_8018DDFC(void *a0) {
+    s32 var;
+    void *p;
+
+    var = *(s32 *)((s32)a0 + 0x1C);
+    var = var - 1;
+    *(s32 *)((s32)a0 + 0x1C) = var;
+    if (var == -1) {
+        p = *(void **)((s32)a0 + 0xD0);
+        if (p != NULL) {
+            *(s16 *)((s32)p + 0) = 0;
+        }
+        func_801439C0((u8 *)*(s32 *)((s32)a0 + 0xCC));
+        func_8012C218((void *)a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018DE5C);
 
@@ -9761,7 +10046,34 @@ void func_8018F1F4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018F230);
+#include "common.h"
+
+extern void func_8012C1B8(void);
+extern void func_8001C2C4(s32 a0);
+extern void func_8018F2C4(s32 a0);
+
+extern s32 D_801270CC;
+extern u8 D_80196C24[];
+
+void func_8018F230(void *param_1)
+{
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)param_1 + 0x20) = v0;
+    if (v0 != 0) {
+        func_8001C2C4(v0);
+        *(s32 *)((s32)param_1 + 0x58) = (s32)D_80196C24 | 0x10000000;
+        *(u16 *)((s32)param_1 + 0x5C) = 0x800;
+        func_8018F2C4((s32)param_1);
+        *(u16 *)((s32)param_1 + 0xDE) = *(u16 *)(*(s32 *)&D_801270CC + 6);
+        *(s16 *)((s32)param_1 + 0xA) = -0x880;
+        __asm__ __volatile__("" ::: "memory");
+        *(u16 *)((s32)param_1 + 0xDC) = *(u16 *)(*(s32 *)&D_801270CC + 0xE);
+        *(u16 *)((s32)param_1 + 2) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018F2C4);
 
diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
index 2aa7b7b753..40d48c16f9 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -5129,7 +5129,18 @@ extern void func_80147060(u8 *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017E4D8);
+extern s32 func_80188168(void);
+extern void func_80171A1C(u8 *a0);
+extern s32 func_80174650(s32 a0);
+
+void func_8017E4D8(s32 a0) {
+    s32 s0 = a0;
+    if (func_80188168() != 0) {
+        func_80171A1C((u8 *)s0);
+        func_80174650(s0);
+    }
+}
+
 
 DEFINE_func_8017E518()  /* dedup: shared engine-core @0x8017E518 (src/shared) */
 
@@ -5151,7 +5162,19 @@ void func_8017E564(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017E5A0);
+void func_8017E5A0(u8 *a0) {
+    s32 frame_pad[10];
+    u16 v1;
+    u16 v0;
+    (void)&frame_pad;
+    v1 = *(u16 *)(a0 + 0x2);
+    v0 = *(u16 *)(a0 + 0xE);
+    v1 += 0x1;
+    v0 += 0x10;
+    *(u16 *)(a0 + 0xE) = v0;
+    *(u16 *)(a0 + 0x2) = v1;
+}
+
 
 extern void func_8017E5F0();
 void func_8017E5C8(void) {
@@ -6307,7 +6330,23 @@ void func_8017FE64(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017FF34);
+typedef struct { s16 m[4]; } S8_FF34;
+
+void func_8017FF34(s16 a0, void *a1, void *a2) {
+    extern s16 D_80126B30;
+    extern s32 D_8012750C;
+    extern s16 D_8011F9C8;
+    extern s16 D_80126B3A;
+    extern void func_80174684(void *);
+    extern void func_8017FF9C(void *);
+
+    *(S8_FF34 *)&D_80126B30 = *(S8_FF34 *)a1;
+    D_80126B3A = a0;
+    D_8012750C = (s32)a2;
+    func_80174684((void *)func_8017FF9C);
+    *(s32 *)&D_8011F9C8 = 0;
+}
+
 
 
 extern void (*D_80194E58[])(void);
@@ -7173,9 +7212,26 @@ void func_80181E40(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80181EF4);
+void func_80181EF4(s32 param_1) {
+    typedef struct { u8 b[8]; } Blk8L;
+    extern Blk8L D_801E9DA0;
+    Blk8L buffer;
+
+    buffer = D_801E9DA0;
+    if (func_80171CC4((void *)param_1, &buffer)) {
+        func_80187838();
+        func_80171928((void *)param_1);
+    }
+    func_80172304((s32 *)param_1);
+}
+
+
+extern s8 D_80195004;
+
+s32 func_80181F6C(s32 param_1) {
+    return func_80171E08(param_1, (s32)&D_80195004 + (*(s16 *)(param_1 + 0x210) << 3), 0xA);
+}
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80181F6C);
 
 #include "common.h"
 
@@ -7238,7 +7294,20 @@ void func_801820B8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801820F4);
+extern s32 func_80171990(u8 *a0);
+extern s32 func_80171D78(s32 a0, s32 a1);
+
+void func_801820F4(s32 a0) {
+    s16 buf[3];
+
+    buf[0] = -0xE0;
+    buf[2] = 0x400;
+    buf[1] = *(u16 *)(a0 + 0xA);
+    if (func_80171D78(a0, (s32)buf) != 0) {
+        func_80171990((u8 *)a0);
+    }
+}
+
 
 void func_80182148(s32 a0) {
     s16 buf[3];
@@ -7434,7 +7503,33 @@ void func_801826D8(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182714);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182A08);
+void func_80182A08(void *a0) {
+    extern s32 ratan2(s32 dx, s32 dy);
+    extern void func_8012A5F8(s32 a0, s32 a1);
+    extern void func_80182B88(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80182564(s32 a0);
+    extern s16 D_80126944;
+    extern s16 D_80126940;
+    extern s16 D_801274E8;
+
+    s16 *base;
+    s32 angle;
+    s16 temp;
+    s32 pad[2];
+
+    base = &D_80126940;
+    angle = ratan2(*base, D_80126944) & 0xFFF;
+
+    temp = *(u16 *)((s32)a0 + 0xA0) - 1;
+    *(u16 *)((s32)a0 + 0xA0) = temp;
+
+    if (temp == -1) {
+        func_8012A5F8((s32)func_80182564, 0x40);
+    } else {
+        func_80182B88((s32)a0, angle, (s32)&D_801274E8, (s32)base);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182A9C);
 
@@ -7490,7 +7585,24 @@ void func_8018312C(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183178);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801834EC);
+extern void func_8012B23C(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_80182380(void);
+extern u8 D_80195114[];
+extern u8 D_801F404C[];
+
+void func_801834EC(void *a0) {
+    s32 s0 = (s32)a0;
+    *(u16 *)(s0 + 2) = 9;
+    func_8012B23C(s0);
+    func_8012B14C(s0, (s32)D_80195114);
+    func_8012A828(s0, (void *)D_801F404C);
+    *(s32 *)(s0 + 0x1C) = 0xA;
+    *(s32 *)(s0 + 0xDC) &= ~1;
+    func_80182380();
+}
+
 
 #include "common.h"
 
@@ -7538,7 +7650,19 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183C2
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801840C0);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184134);
+extern void func_80184738(s32 a0);
+extern void func_80188228(void);
+
+void func_80184134(s32 param_1) {
+    func_801823B8();
+    *(s16 *)(param_1 + 2) = 0xD;
+    *(s16 *)(param_1 + 0x34) = 0;
+    func_80184738(1);
+    func_80178BF8();
+    func_80178CBC(param_1, *(s32 *)(param_1 + 0xCC));
+    func_80188228();
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018418C);
 
@@ -7672,7 +7796,27 @@ void func_80184918(s32 arg0, s32 arg1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184964);
+extern s32 func_80143BDC(u16 *a0);
+
+void func_80184964(s32 a0) {
+    u16 pos[3];
+    s32 hit;
+    u32 ptr;
+
+    pos[0] = *(u16 *)(a0 + 0x6);
+    pos[1] = *(u16 *)(a0 + 0xA);
+    pos[2] = *(u16 *)(a0 + 0xE);
+    pos[1] += 0x28;
+    pos[2] += 0x52;
+    func_80143BDC(pos);
+    hit = func_80143BDC(pos);
+    if (hit != 0) {
+        ptr = *(u32 *)(hit + 0xCC);
+        *(u16 *)(ptr + 0x1A) = 0x6000;
+        *(u16 *)(ptr + 0x18) = 0x6000;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801849D4);
 
@@ -7687,7 +7831,29 @@ extern s32 func_800D0CE0(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184A54);
+extern u8 D_801202A0[];
+extern void func_8012C098(void);
+
+void func_80184A54(void)
+{
+    register int i __asm__("$17");
+    register u8 *p __asm__("$16");
+    register int s2 __asm__("$18");
+
+    i = 0;
+    p = D_801202A0;
+    s2 = 0x6C;
+    do {
+        u16 v = *(u16 *)p;
+        if ((u32)(v - 0x123) < 2 || v == s2) {
+            ((void (*)(u8 *))func_8012C098)(p);
+        }
+        i = i + 1;
+        p = p + 0x10C;
+    } while (i < 0x60);
+    return;
+}
+
 
 
 extern void (*D_801957F8[])(void);
@@ -7715,7 +7881,33 @@ void func_80184C0C(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184C98);
+typedef struct { s16 a, b, c; } SV3_80184C98;
+extern void func_8012B23C(s32 a0);
+extern void func_80185098(s32 a0, s32 a1);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern u8 D_801957EC[];
+
+void func_80184C98(s32 param_1) {
+    SV3_80184C98 pt;
+    u16 v1;
+    s32 v0;
+
+    v1 = *(u16 *)(param_1 + 0x5C);
+    if (v1 & 1) {
+        *(u16 *)(param_1 + 0x5C) = v1 & 0xFFFE;
+        if (*(u16 *)(param_1 + 0x5E) == 9) {
+            func_8012B23C(param_1);
+            pt.a = *(u16 *)(*(s32 *)(param_1 + 0x64) + 6);
+            pt.b = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xA);
+            pt.c = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xE);
+            if (((s32 (*)(s32, s32))func_80185098)(param_1, (s32)&pt) == 1) {
+                func_8012B14C(param_1, (s32)D_801957EC);
+            }
+            *(u16 *)(param_1 + 2) = 5;
+        }
+    }
+}
+
 
 typedef struct { s16 a, b, c; } SV3_80184D50;
 
@@ -7818,7 +8010,22 @@ void func_80184E00(s32 param_1)
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184F48);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80185048);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012C218(void *a0);
+
+void func_80185048(s32 param_1)
+{
+    s32 *temp_v0;
+
+    temp_v0 = *(s32 **)(param_1 + 0x20);
+    temp_v0[1] ^= 0x80000000;
+    if (func_8012BEE8(param_1) != 0) {
+        func_8012C218(param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80185098);
 
@@ -7851,7 +8058,21 @@ void func_80185464(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80185480);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801854DC);
+void func_801854DC(void *a0) {
+    extern s32 func_80185548(s32);
+    extern void func_8018567C(s32, s32);
+
+    if (func_80185548((s32)a0) == 1) {
+        if ((*(s16 *)((s32)a0 + 0x70) & 0x8000) != 0) {
+            *(s16 *)((s32)a0 + 2) = 1;
+        } else {
+            *(s16 *)((s32)a0 + 2) = 3;
+        }
+        func_8018567C((s32)a0, 0x61B);
+        *(u16 *)((s32)a0 + 0x5C) &= ~0x400;
+    }
+}
+
 
 #include "common.h"
 
@@ -8285,9 +8506,44 @@ void func_80186070(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186184);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80186790(void *a0);
+extern u8 D_80195A94;
+
+void func_80186184(s32 a0) {
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x18) = 0x2C00;
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x3800;
+    func_8012A828(a0, &D_80195A94);
+    *(u16 *)(a0 + 0xFC) = 0;
+    *(s32 *)(a0 + 0x1C) = 0x10;
+    func_8012AD44((s32 *)a0, 4);
+    if (*(s32 *)(a0 + 0xD0) != 0) {
+        func_80186790(*(void **)(a0 + 0xD0));
+    }
+}
+
+
+#include "common.h"
+
+extern void func_8012B200(u8 *a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_801867BC(void *a0);
+
+void func_801861FC(void *arg0) {
+    register s32 s0 __asm__("$16") = (s32)arg0;
+    s32 val;
+
+    *(s32 *)(s0 + 0x1C) = 4;
+    func_8012B200((u8 *)s0);
+    func_8012AD44((s32 *)s0, 5);
+
+    val = *(s32 *)(s0 + 0xD0);
+    if (val != 0) {
+        func_801867BC((void *)val);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801861FC);
 
 void func_80186250(s32 arg0) {
     extern void func_80186548(s32 *a0);
@@ -8603,11 +8859,100 @@ s32 func_80186B1C(void *a0, void *a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186BB0);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186C30);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+void func_80186BB0(void *a0) {
+    register s32 v0 __asm__("$2");
+    s32 sp10[3];
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+
+    if (!v0) {
+        func_8012CAE4(a0);
+    } else {
+        func_8001C2C4(v0);
+
+        *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = 0x600;
+        func_8012B2CC((s32)a0);
+
+        sp10[1] = 0;
+        sp10[0] = 0;
+        sp10[2] = 0x240000;
+        func_8012B14C((s32)a0, (s32)sp10);
+
+        func_8012AD50(a0);
+    }
+}
+
+
+void func_80186C30(s32 a0) {
+    register s32 self __asm__("$16") = a0;
+    s32 v0;
+    extern s32 func_80029178(s32);
+    extern void func_8012C1B8(void);
+    extern void func_8001C214(s32, s32);
+    extern s32 func_8012C588(s32, s32);
+    extern void func_8012CAE4(void *);
+    extern void func_80185A8C(void);
+    extern s32 D_801E4D54;
+
+    if ((func_80029178(0x16) & 0xFF) != 0) {
+        goto L88;
+    }
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(self + 0x20) = v0;
+    if (v0 == 0) {
+        goto L88;
+    }
+    func_8001C214(v0, (s32)&D_801E4D54);
+    v0 = func_8012C588(0x110, self);
+    if (v0 != 0) {
+        goto L98;
+    }
+L88:
+    func_8012CAE4((void *)self);
+    goto LCA0;
+L98:
+    ((void (*)(s32))func_80185A8C)(self);
+LCA0:
+    return;
+}
+
+
+void func_80186CB4(s32 a0)
+{
+    extern int func_80178970(void);
+    extern void func_80178D18(void);
+    extern s32 func_8012BEE8(s32 a0);
+    extern void func_80185C20(void);
+
+    s32 s0 = a0;
+    s32 ret = func_80178970();
+
+    switch (*(u16 *)(s0 + 0x34)) {
+    case 0:
+        if (func_8012BEE8(s0) != 0) {
+            *(u16 *)(s0 + 0x34) += 1;
+        }
+        break;
+    case 1:
+        if (ret == 0) {
+            return;
+        }
+        ((void (*)(s32))func_80178D18)(s0);
+        ((void (*)(s32))func_80185C20)(s0);
+        break;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186CB4);
 
 void func_80186D3C(void) {
 }
@@ -8820,7 +9165,19 @@ extern s32 func_80186740(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80187254);
+extern s32 func_80186740(void);
+
+void func_80187254(s32 arg0) {
+    s32 a0 = *(s32 *)(arg0 + 0x20);
+    if (*(s16 *)(a0 + 0x18) < 0x6000) {
+        *(s16 *)(a0 + 0x18) = *(s16 *)(a0 + 0x18) + 0x800;
+    }
+    if (*(s16 *)(a0 + 0x1A) < 0x6000) {
+        *(s16 *)(a0 + 0x1A) = *(s16 *)(a0 + 0x1A) + 0x800;
+    }
+    func_80186740();
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801872B4);
 
@@ -8834,7 +9191,23 @@ void func_801873FC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80187438);
+extern u8 func_8014BF6C(void);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012AD50(void *a0);
+
+void func_80187438(s32 a0) {
+    s32 s1;
+    u8 n;
+
+    s1 = a0;
+    n = func_8014BF6C();
+    while (n != 0) {
+        func_8012C658(0x112, n - 1, s1);
+        n--;
+    }
+    func_8012AD50((void *)s1);
+}
+
 
 void func_801874A0(void) {
 }
@@ -8847,7 +9220,27 @@ void func_801874A8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801874E4);
+extern void func_8012C1B8(void);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_80187654(u8 *a0);
+extern s32 func_8012AD50(void *a0);
+extern s32 D_801DF580;
+extern s32 D_81195D48;
+
+void func_801874E4(s32 a0)
+{
+    s32 s1 = a0;
+    s32 s0;
+
+    if ((*(s32 *)(s1 + 0x20) = s0 = ((s32 (*)(void))func_8012C1B8)()) == 0) goto L_end;
+    func_8001C214(s0, (s32)&D_801DF580);
+    *(s32 *)(s0 + 0x20) = (s32)&D_81195D48;
+    func_80187654((u8 *)s1);
+    func_8012AD50((void *)s1);
+L_end:
+    return;
+}
+
 
 #include "common.h"
 
@@ -9491,7 +9884,28 @@ extern void func_8012A828(s32, void*);
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801887F8);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018898C);
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+
+extern s16 D_801D3D64;
+extern s16 D_801D3DEC;
+
+void func_8018898C(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 3;
+    if (*(u16 *)(a0 + 0x86) & 2) {
+        *(s16 *)(a0 + 0x34) = 1;
+        *(s32 *)(a0 + 0x1C) = 0x28;
+        func_8012A828(a0, &D_801D3D64);
+        *(u16 *)(a0 + 0xFE) = 0;
+    } else {
+        *(s16 *)(a0 + 0x34) = 0;
+        func_8012A828(a0, &D_801D3DEC);
+        *(s32 *)(a0 + 0x1C) = 0x19;
+        *(u16 *)(a0 + 0x86) |= 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188A10);
 
@@ -9532,7 +9946,29 @@ void func_80188DF4(s32 arg0, s32 arg1, s32 arg2, void *arg3) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188E3C);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189050);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern s32 D_801960B4[];
+
+void func_80189050(s32 param_1) {
+    register s32 s0 __asm__("$16") = param_1;
+    s32 *s1;
+
+    __asm__ __volatile__("" : "=r"(s0) : "0"(s0));
+
+    if ((*(u16 *)(s0 + 0x70) & 0x2000) == 0) {
+        s1 = &D_801960B4[3];
+    } else {
+        s1 = &D_801960B4[0];
+    }
+    *(s16 *)(s0 + 2) = 7;
+    func_8012A828(s0, (void *)s1[0]);
+    func_8012B200((u8 *)s0);
+    func_8012B178(s0, s1[1]);
+    *(s32 *)(s0 + 0x1C) = s1[2];
+}
+
 
 #include "common.h"
 #include "/home/musashi/bfm-decomp/src/shared/engine_core.h"
@@ -9703,7 +10139,30 @@ void func_801894E0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018951C);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+extern void func_80188DF4();
+extern void func_8012A828(s32 a0, void *a1);
+
+extern short D_801D3B74;
+extern short D_801D4494;
+
+void func_8018951C(s32 param_1) {
+    register s32 s0 __asm__("$16");
+    s32 v0;
+
+    s0 = param_1;
+    if ((*(u16 *)(s0 + 0x72) & 0x4000) != 0) {
+        *(u16 *)(s0 + 0x100) = 3;
+        if (func_8012BD3C(s0, 0x400, 0x40000) != 0) {
+            func_80188DF4(s0, 4, 0x1E, &D_801D4494);
+        } else {
+            *(u16 *)(s0 + 0x2) = 2;
+            *(u16 *)(s0 + 0x34) = 0;
+            func_8012A828(s0, &D_801D3B74);
+        }
+    }
+}
+
 
 
 extern void func_8012A828(s32, void*);
@@ -9832,7 +10291,19 @@ void func_801897A4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018983C);
+extern void func_8012CBF4(s32);
+extern void func_80188554(s32 a0);
+
+void func_8018983C(s32 a0) {
+    s32 s0;
+
+    s0 = a0;
+    ((void (*)(s32))func_8012CBF4)(a0);
+    if (*(u16 *)(s0 + 0x72) & 0x4000) {
+        func_80188554(s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189880);
 
@@ -9965,7 +10436,18 @@ void func_80189B28(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189B64);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189C20);
+void func_80189C20(s32 arg0) {
+    if (func_8012E778(arg0, 0x8200AA) != 1) {
+        return;
+    }
+    if ((func_8014CB2C() & 0x7FFFFFFF) != 2) {
+        return;
+    }
+    *(u16 *)((s32)arg0 + 0x2) = 2;
+    *(u16 *)((s32)arg0 + 0xFC) = 1;
+    *(s32 *)((s32)arg0 + 0x1C) = 0x3C;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189C90);
 
@@ -10196,7 +10678,23 @@ void func_8018A640(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018A698);
+extern s32 D_80126B58;
+extern s32 func_80172688(s32 *a0);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8018A264(void);
+
+void func_8018A698(s32 *a0) {
+    if (func_80172688(&D_80126B58) == 0) {
+        if (func_8012BEE8((s32)a0) != 0) {
+            func_8018A264();
+            (*(u16 *)((s32)a0 + 2))--;
+        }
+        return;
+    }
+    func_8012BF4C(a0, 0x20);
+}
+
 
 void func_8018A708(void) {
 
@@ -11408,7 +11906,20 @@ extern void func_8012C098(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018BAD8);
+void func_8018BAD8(u8 *a0) {
+    u16 v1 = *(u16 *)(a0 + 0x5E);
+    if (v1 == 0x23) {
+        *(u16 *)(a0 + 0xFE) = 1;
+        func_8002D4C8(0xAA1, 0);
+    } else if (v1 == 0x24) {
+        s16 buf[3];
+        buf[0] = 2;
+        buf[1] = 0xF;
+        buf[2] = -2;
+        func_80190C84((s32)a0, (u16 *)buf, 0xD);
+    }
+}
+
 
 #include "common.h"
 
@@ -11696,7 +12207,17 @@ void func_8018C0B8(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018C11C);
+void func_8018C11C(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_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018C174);
 
@@ -12625,7 +13146,18 @@ L8018D50C:
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018D52C);
+void func_8018D52C(void *a0) {
+    extern short D_801DF69C;
+    s32 v0;
+
+    v0 = *(s32 *)((char *)a0 + 0x20);
+    *(s16 *)((char *)a0 + 0x5C) = 0;
+    *(s16 *)((char *)v0 + 0x10) = 0;
+    *(s16 *)((char *)a0 + 0x34) = 0;
+    func_8012E8A8((u8 *)a0);
+    func_8012A828((s32)a0, (s32)&D_801DF69C);
+}
+
 
 #include "common.h"
 
@@ -13269,7 +13801,20 @@ void func_8018E394(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018E3C8);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8018E420(s32 a0, u8 *a1);
+
+void func_8018E3C8(u8 *arg0) {
+    if (func_8012BEE8((s32)arg0) != 0) {
+        func_8018E420(0, arg0 + 0xFD);
+        func_8018E420(1, arg0 + 0xFE);
+        func_8018E420(2, arg0 + 0xFF);
+        *(s32 *)(arg0 + 0x1C) = 2;
+    }
+}
+
 
 #include "common.h"
 
@@ -14573,7 +15118,21 @@ void func_8018FDC4(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018FE20);
+
+
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_8018FE20(s32 a0)
+{
+    extern Rec8_8018A390_8018FE94 D_801E47C4[];
+
+    s32 i;
+
+    for (i = 0; (s16)D_801E47C4[i].x != 0; i++) {
+        func_8012C658(0x10D, i, a0);
+    }
+}
+
 
 
 /* func_8018FE94 — allocates a GTE-projection slot, seeds a random spread
@@ -14801,7 +15360,21 @@ void func_801902F4(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80190334);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801903F4);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801E38A0[];
+
+void func_801903F4(void *a0) {
+    if (*(s16 *)((s32)a0 + 0x98) == 0) {
+        if (*(s16 *)((s32)a0 + 0xFE) == 2) {
+            func_8002D4C8(0x888, 0);
+            func_8012A828((s32)a0, D_801E38A0);
+        }
+        *(s16 *)((s32)a0 + 0x2) = 5;
+        *(s16 *)((s32)a0 + 0xFE) = 0;
+    }
+}
+
 
 void func_80190460(void *a0) {
         *(short *)(*(int *)((char *)a0 + 0x6c) + 0xfe) = 1;
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c b/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
index 01fb82b4ee..91f12fe242 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_8017D898.c
@@ -3230,7 +3230,20 @@ void func_8017E8DC(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017E91C);
+void func_8017E91C(void)
+{
+
+    extern u8 D_8018F930[];
+    extern u8 D_8018F9BC[];
+    extern u8 *D_801274C8;
+    extern void *D_801274CC;
+    extern s32 D_8012704C;
+    D_801274C8 = D_8018F930;
+    D_801274CC = D_8018F9BC;
+    func_8017FB44(5);
+    D_8012704C = 2;
+}
+
 
 
 extern void (*D_8018F1A4[])(void);
@@ -3441,9 +3454,26 @@ void func_8017EF54(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017EF90);
+extern void func_8017EFD8();
+
+void func_8017EF90(void *a0) {
+    func_80171990((u8 *)a0);
+    func_80146994(0x19, (s32)a0, 0x06900691, 0);
+    func_8017EFD8(a0);
+}
+
+
+extern s32 func_8014C050(s32 a0, s32 a1);
+extern u8 D_800AE6BD;
+extern void func_80171928(void *a0);
+
+void func_8017EFD8(void *a0) {
+    if (!func_8014C050((s32)a0, 0x19)) {
+        D_800AE6BD++;
+        ((void (*)(void *))func_80171928)(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017EFD8);
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017F02C(void) {
@@ -3879,7 +3909,22 @@ void func_8017FF68(void *a0, s32 a1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8017FFC8);
+extern s32 D_8012704C;
+
+s32 func_8017FFC8(void) {
+    switch (D_8012704C) {
+    case 1:
+        if ((func_80029178(0xAE) & 0xFF) != 0) {
+            return 0x39;
+        }
+        return 0x3B;
+    case 0:
+        return 0x39;
+    case 2:
+        return 0x45;
+    }
+}
+
 
 
     typedef struct { u8 b[8]; } Blk8_80180040;
@@ -3981,9 +4026,47 @@ void func_801801C4(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80180214);
+void func_80180214(void *a0)
+{
+    extern u16 D_801A4C1C[];
+    s32 v0;
+    s32 a1;
+    v0 = *(s16 *)((s32)a0 + 0x70);
+    *(u8 *)((s32)a0 + 0xC1) = 0;
+    *(s16 *)((s32)a0 + 0x5E) = 0;
+    *(s16 *)((s32)a0 + 0x5C) = 0;
+    func_80029124(D_801A4C1C[v0], 1);
+    a1 = *(s32 *)((s32)a0 + 0xDC);
+    if (a1 != 0) {
+        a1 = *(s32 *)(a1 + 0x4);
+        if (a1 != 0) {
+            func_8001C924(*(s32 *)((s32)a0 + 0x20), (s32 *)a1);
+        }
+    }
+    func_80180294(a0);
+}
+
+
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_80180294(s32 arg0)
+{
+    extern s32 D_801A4BE4;
+    s32 v1;
+    s32 v0;
+    s32 s2;
+    s32 s0;
+
+    v1 = *(s32 *)(arg0 + 0x20);
+    s2 = *(s32 *)(v1 + 0x20);
+    *(s32 *)(v1 + 0x20) = D_801A4BE4;
+    for (s0 = 0; s0 < 5; s0++) {
+        func_8012C658(0x150, s0, arg0);
+    }
+    v0 = *(s32 *)(arg0 + 0x20);
+    *(s32 *)(v0 + 0x20) = s2;
+}
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80180294);
 
 
 
@@ -4162,7 +4245,13 @@ void func_801806B8(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801806E0);
+s32 func_801806E0(void *arg0)
+{
+    *(s32 *)((char *)arg0 + 0x10) = 0x18000;
+    func_8012AD44(arg0, 2);
+    func_8002D4C8(0x675, 0);
+}
+
 
 extern s32 func_8012DB84(void);
 extern void (*D_8018BBA0)(void *);
@@ -4204,7 +4293,21 @@ void func_8018082C(void *arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80180860);
+extern void func_8013C9C4(void *a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void (*D_8018BBA0)(void*);
+extern s16 D_801A4CC0[];
+
+void func_80180860(void *a0)
+{
+    func_8013C9C4(&(*(u8 *)&D_8018BBA0));
+    *(s32 *)((s32)a0 + 0x1C) = *(s16 *)((s32)D_801A4CC0 + (*(s16 *)((s32)a0 + 0x100)) * 4);
+    func_8012AD44((s32 *)a0, 3);
+    func_8002D4C8(4, 0x684);
+    func_8002D4C8(0x685, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801808D0);
 
@@ -4329,7 +4432,22 @@ void func_80180B4C(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80180BAC);
+
+
+void func_80180BAC(void *a0)
+{
+    extern void func_8012AD44(s32 *a0, s16 a1);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+    extern Stride8_s16_80182868_80180970 D_801A4D12[];
+
+    s32 v;
+
+    v = D_801A4D12[*(s16 *)((s32)a0 + 0x70)].v;
+    *(s32 *)((s32)a0 + 0x44) = (v == 0) ? 0x8000 : -0x8000;
+    func_8012AD44(a0, 2);
+    func_8002D4C8(0x686, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80180C04);
 
@@ -4483,7 +4601,7 @@ void func_80180F54(void *a0)
 
 
 extern s32 func_8012BEE8(s32 a0);
-extern s32 func_801806E0(void *a0);
+extern s32 func_801806E0();
 void func_80181044(int param_1)
 {
     if (((int (*)(void))func_8012BEE8)() != 0) {
@@ -4550,13 +4668,38 @@ void func_801811A4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801811F4);
+extern void func_8012AD80(s32 a0);
+extern void func_8012E138(s32 a0);
+extern void func_80180860();
+
+void func_801811F4(s32 arg0) {
+    func_8012AD80(arg0);
+
+    if (*(s32 *)((s32)arg0 + 0x10) > 0x7FFFF) {
+        *(s32 *)((s32)arg0 + 0x44) = 0;
+    }
+
+    func_8012E138(arg0);
+
+    if (*(s16 *)((s32)arg0 + 6) - *(s16 *)((s32)arg0 + 0xFC) >= 0x3E0) {
+        func_80180860((void *)arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181264);
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801812FC);
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801813B8);
+extern void func_80180E54(u8 *a0, u8 *a1, s32 a2);
+
+extern s32 D_801A4CFC[];
+
+void func_801813B8(s32 param_1)
+{
+    func_80180E54((u8 *)param_1, (u8 *)D_801A4CFC, -1);
+}
+
 
 extern void func_8012AD44(s32 *a0, s16 a1);
     void func_801813E0(s32 *a0) {
@@ -4899,11 +5042,44 @@ INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181CC
 void func_80181D84(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181D8C);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80181AD0(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80181D8C(s32 a0) {
+    s32 *a1;
+
+    if (func_8012BEE8(a0) != 0) {
+        a1 = *(s32 **)(a0 + 0x64);
+        if (*(s16 *)((s32)a1 + 0xFE) == 2) {
+            *(s16 *)((s32)a1 + 0xFE) = 1;
+            func_80181AD0(a0);
+            *(s16 *)((s32)a0 + 0x100) = 0;
+            *(s16 *)((s32)a0 + 0x104) = 0;
+        }
+        func_80181788((s32 *)a0);
+        func_8002D4C8(0x6CA, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181DFC);
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80181E64);
+void func_80181E64(s32 arg0) {
+    s32 s0 = arg0;
+    if (func_800CF8B4() != 0) {
+        func_8012AD80(s0);
+        if (func_8012BEE8(s0) != 0) {
+            *(s32 *)((s32)s0 + 0x1C) = 0x10;
+            func_8012AD44((s32 *)s0, 1);
+            func_8002D4C8(4, 0x6CA);
+            func_8002D4C8(0x6CC, 0);
+        }
+    }
+}
+
 
 void func_80181ED4(void) {
 }
@@ -5038,7 +5214,7 @@ void func_80181EDC(s32 s1)
  * `la $a1,D_801D3100` + three 0($a1) accesses.
  */
 
-extern void func_80182194(void *a0);
+extern void func_80182194();
 extern void func_80182230(void *a0);
 extern void func_801823F4(s32 a0);
 extern s32 func_8012BEE8(s32 a0);
@@ -5114,9 +5290,40 @@ void func_80182060(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182194);
+extern s32 rand(void);
+extern void func_80183AA0(void *a0, void *a1, void *a2);
+
+typedef struct { u8 b[4]; } Blk4_80182194;
+typedef struct { u16 f00, f02, f04, f06; } Args_80182194;
+
+extern Blk4_80182194 D_801D1A94;
+extern Blk4_80182194 D_801D1A98;
+
+void func_80182194(s32 a0) {
+    Blk4_80182194 sp10;
+    Blk4_80182194 sp18;
+    Args_80182194 arg;
+
+    sp10 = D_801D1A94;
+    sp18 = D_801D1A98;
+    *(s8 *)((u8 *)&sp10 + 2) = (rand() & 0x3F) - 0x80;
+    arg.f00 = 0x100;
+    arg.f04 = 0x80;
+    arg.f02 = a0;
+    arg.f06 = 1;
+    func_80183AA0((void *)&arg, (void *)&sp10, (void *)&sp18);
+}
+
+
+extern void func_8012AD44(s32 *a0, s16 a1);
+void func_80182230(void *a0) {
+    s32 a1;
+    a1 = *(s32 *)((s32)a0 + 0x20);
+    *(s32 *)(a1 + 4) = *(s32 *)(a1 + 4) | 0x80000000;
+    *(s16 *)((s32)a0 + 0xFC) = 0;
+    ((void (*)(s32, s32))func_8012AD44)((s32)a0, 0x3);
+}
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182230);
 
 extern void func_8012AD44(s32 *a0, s16 a1);
     void func_8018226C(void *a0) {
@@ -5157,7 +5364,38 @@ void func_801822F0(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182340);
+
+extern u8 D_801D3100;
+extern Blk4_80181EDC D_801D1A8C;
+extern u8 D_801A4E80[];
+extern void func_80183918(void);
+extern void func_801839DC(s32 a0, s32 a1, s32 a2);
+extern void func_8012B2CC(s32 a0);
+extern void func_80183A0C(s32 a0);
+extern void func_80178B18(s32 a0, s32 a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80182340(void *arg0)
+{
+    s32 stack[2];
+    s32 s0 = (s32)arg0;
+
+    *(u8 *)(s0 + 0xC1) = 0;
+    *(s16 *)(s0 + 0x5E) = 0;
+    *(s16 *)(s0 + 0x5C) = 0x800;
+    *(Blk4_80181EDC *)(s32)&D_801D3100 = *(Blk4_80181EDC *)&D_801D1A8C;
+    func_80183918();
+    func_801839DC((s32)stack, 0x1000, 0);
+    func_8012B2CC(s0);
+    func_80183A0C(s0 + 4);
+    *(s16 *)(s0 + 0xFC) = 0;
+    *(s32 *)(s0 + 0x1C) = 0x40;
+    func_80178B18(s0, (s32)&D_801A4E80);
+    func_8012AD44((s32 *)s0, 2);
+    func_8002D4C8(0x700, 0);
+}
+
 
 extern void func_80183A84(s32 arg0);
 extern void func_8012B2CC(s32 a0);
@@ -5172,7 +5410,22 @@ void func_801823F4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182438);
+#include "common.h"
+
+extern void func_801330E0(void *, s16 *, s32);
+
+s32 func_80182438(s32 a0) {
+    s32 v1;
+
+    v1 = *(s32 *)(a0 + 0xCC);
+    if (v1 != 0) {
+        *(u16 *)(v1 + 0x8) = *(u16 *)(a0 + 0x6);
+        *(u16 *)(v1 + 0xA) = *(u16 *)(a0 + 0xA);
+        *(u16 *)(v1 + 0xC) = *(u16 *)(a0 + 0xE);
+        func_801330E0((void *)(v1 + 0x8), (s16 *)(v1 + 0x8), -0x100);
+    }
+}
+
 
 #include "common.h"
 
@@ -5249,7 +5502,26 @@ void func_801825EC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182628);
+extern u8 D_801D3100;
+extern u8 D_801D3101;
+extern u8 D_801D3102;
+
+void func_80182628(void *a0) {
+    s32 t;
+    u8 v;
+
+    t = *(s32 *)((s32)a0 + 0x1C) + 1;
+    *(s32 *)((s32)a0 + 0x1C) = t;
+    if (t & 0x10) {
+        v = ((t & 0xF) >> 1) + 9;
+    } else {
+        v = 0x10 - ((t & 0xF) >> 1);
+    }
+    D_801D3102 = v * 8;
+    D_801D3101 = v * 8;
+    D_801D3100 = v * 8;
+}
+
 
 #include "common.h"
 
@@ -5354,7 +5626,34 @@ INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801828A
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_801828E0);
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_8018292C);
+#include "common.h"
+
+void func_8018292C(void *a0)
+{
+    extern void func_8012C1B8(void);
+    extern void func_8012CAE4(void *a0);
+    extern void func_8001C2C4(s32 a0);
+    extern s32 func_8012AD50(void *a0);
+    extern u8 D_801A4EF0;
+    extern s32 D_801A4EA4;
+
+    register void *s0 __asm__("$16") = a0;
+    s32 v0 = ((s32 (*)(void))func_8012C1B8)();
+
+    *(s32 *)((u8 *)s0 + 0x20) = v0;
+
+    if (!v0) {
+        func_8012CAE4(s0);
+    } else {
+        func_8001C2C4(v0);
+        *(s32 *)((u8 *)s0 + 0x58) = (s32)&D_801A4EF0 | 0x40000000;
+        *(s16 *)((u8 *)s0 + 0x5C) = 0x800;
+        *(u16 *)((u8 *)s0 + 0x72) |= 0x1000;
+        D_801A4EA4 = *(s32 *)((u8 *)s0 + 0xDC);
+        func_8012AD50(s0);
+    }
+}
+
 
 void func_801829B4(void) {
 }
@@ -5516,7 +5815,20 @@ void func_80182CA4(void *a0)
 
 INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182D90);
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8017D898", func_80182E50);
+void func_80182E50(void) {
+
+    extern u8 D_801202A0[];
+    u8 *p;
+    s32 i;
+
+    p = D_801202A0;
+    for (i = 0; i < 0x60; i++, p += 0x10C) {
+        if (*(u16 *)p == 0x1E1) {
+            *(u16 *)(p + 0x70) |= 0x1000;
+        }
+    }
+}
+
 
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern void func_80029124(s32, s32);
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
index c201d2e833..67d5780ac6 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_80184BD8.c
@@ -2727,7 +2727,7 @@ extern void func_80180804(void * arg0);
 extern void (*D_801A4DA4[])(void);
 extern void func_80180E18(void *a0);
 extern s32 func_8012BEE8(s32 a0);
-extern s32 func_801806E0(void *a0);
+extern s32 func_801806E0();
 extern void func_80181044(int param_1);
 extern void func_801810C8(void);
 extern void func_801813E0(s32 *a0);
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_801884D8.c b/src/ov_SC02_028/ov_SC02_028_jr_801884D8.c
index 78efcf76b6..ba09c3cffb 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_801884D8.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_801884D8.c
@@ -2733,7 +2733,7 @@ extern void func_80180804(void * arg0);
 extern void (*D_801A4DA4[])(void);
 extern void func_80180E18(void *a0);
 extern s32 func_8012BEE8(s32 a0);
-extern s32 func_801806E0(void *a0);
+extern s32 func_801806E0();
 extern void func_80181044(int param_1);
 extern void func_801810C8(void);
 extern void func_801813E0(s32 *a0);
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
index 906a0d5512..d1680953c1 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
@@ -6635,7 +6635,35 @@ void func_80181104(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018112C);
+extern void func_8012A018(s32 a0, s32 a1);
+extern void func_8012A094(s32 a0);
+extern void func_801811CC(u8 *param_1);
+
+void func_8018112C(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[];
+    D_80126954 = 0x1F4;
+    D_80126950 = 0x1F4;
+    D_8012695C = 0x4B0;
+    D_80126968 = 0x238;
+    D_8012696A = 0x600;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0;
+    func_8012A018((s32)func_801811CC, 0);
+    func_8012A094((s32)D_80126948);
+    func_801811CC(D_80126948);
+}
+
 
 extern void (*D_80190810[])(void);
 
@@ -6832,7 +6860,43 @@ save:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80181A14);
+extern s32 func_800291B4(s32 arg);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *);
+extern s32 D_80190834;
+
+void func_80181A14(void *a0)
+{
+    register void *s0 __asm__("$16") = a0;
+    s32 v0;
+    s32 sp10[3];
+
+    if (((func_800291B4(0xCD) & 0xFF) != 0) ||
+        (v0 = ((s32 (*)(void))func_8012C1B8)(),
+         (*(s32 *)((u8 *)s0 + 0x20) = v0),
+         v0 == 0))
+    {
+        func_8012CAE4(s0);
+        return;
+    }
+
+    func_8001C2C4(v0);
+    *(s16 *)(*(s32 *)((u8 *)s0 + 0x20) + 0x10) = -0x400;
+    func_8012B2CC((s32)s0);
+    sp10[1] = 0;
+    sp10[0] = 0;
+    sp10[2] = 0x240000;
+    func_8012B14C((s32)s0, (s32)sp10);
+    *(s32 *)((u8 *)s0 + 0x58) = (s32)&D_80190834 | 0x40000000;
+    *(s16 *)((u8 *)s0 + 0x5C) = 0x800;
+    *(s16 *)((u8 *)s0 + 0xFC) = 0;
+    func_8012AD50(s0);
+}
+
 
 extern void (*D_801908B4[])(void);
 
@@ -7383,7 +7447,20 @@ void func_801830D0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183118);
+extern void func_8012E8E0(s32, s32);
+extern void func_8012E8A8(u8 *);
+extern void func_8012A828(s32, void *);
+
+void func_80183118(void *arg0) {
+    extern s32 D_80190D7C;
+    extern s32 D_801F2108;
+    *(short *)((char *)arg0 + 0x2) = 1;
+    *(short *)((char *)arg0 + 0x34) = 0;
+    func_8012E8E0((s32)arg0, (s32)&D_80190D7C);
+    func_8012E8A8((u8 *)arg0);
+    func_8012A828((s32)arg0, (void *)&D_801F2108);
+}
+
 
 
 extern void (*D_80190F70[])(void);
@@ -7468,7 +7545,24 @@ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801837C
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183864);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801838FC);
+extern void (*D_801BFF04[])(void);
+extern s32 func_8012C044(s32 a0);
+extern void func_801846D0(void *a0);
+
+void func_801838FC(void *a0) {
+    D_801BFF04[*(u16 *)((s32)a0 + 0x2)]();
+    if (*(u16 *)((s32)a0 + 0x0) != 0) {
+        void *ptr = *(void **)((s32)a0 + 0x20);
+        *(u16 *)((s32)ptr + 0x2C) |= 0x10;
+        if (!(*(u16 *)((s32)a0 + 0x70) & 0x800)) {
+            if (func_8012C044((s32)a0) == 1) {
+                *(s32 *)((s32)a0 + 0xE4) = 1;
+                func_801846D0(a0);
+            }
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -7502,9 +7596,70 @@ void func_801839A4(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183A70);
+#include "common.h"
+
+extern void func_8012BD14(s32 a0);
+extern s32 func_80143970(s32 a0);
+extern s32 D_801BFE40;
+
+void func_80183A70(s32 a0) {
+    register s32 mask __asm__("$4");
+    s32 p;
+
+    if (((s32 (*)(s32))func_8012BD14)(a0) <= 0x18FFF) {
+        return;
+    }
+
+    mask = 0x7FFFFFFF;
+
+    *(s16 *)(a0 + 0x2) = 2;
+    *(s32 *)(a0 + 0x1C) = 0x10;
+
+    p = *(s32 *)(a0 + 0x20);
+    *(s32 *)(p + 0x4) &= mask;
+
+    p = *(s32 *)(a0 + 0x20);
+    *(u16 *)(p + 0x2C) |= 0x10;
+
+    p = *(s32 *)(a0 + 0x20);
+    *(u16 *)(p + 0x1C) = 1;
+    *(u16 *)(p + 0x1A) = 1;
+    *(u16 *)(p + 0x18) = 1;
+
+    *(s32 *)(a0 + 0xCC) = func_80143970(a0);
+
+    *(u16 *)(a0 + 0x76) = *(u16 *)&D_801BFE40;
+}
+
+
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_80047948(s32 a0);
+extern u16 D_801BFE42;
+
+void func_80183B14(s32 s0) {
+  if (func_8012BEE8(s0) != 0) {
+    s32 p = *(s32 *)(s0 + 0x20);
+    s32 h = *(u16 *)(p + 0x2C);
+    h &= 0xFFEF;
+    *(s16 *)(p + 0x2C) = h;
+    *(s16 *)(s0 + 0x2) = 3;
+    *(s16 *)(s0 + 0x5C) = D_801BFE42;
+  } else {
+    s32 a0;
+    s32 r;
+    s32 q;
+    a0 = *(s32 *)(s0 + 0x1C);
+    a0 = (a0 << 10) >> 4;
+    r = func_80047948(a0);
+    q = *(s32 *)(s0 + 0x20);
+    *(s16 *)(q + 0x1C) = r;
+    *(s16 *)(q + 0x1A) = r;
+    *(s16 *)(q + 0x18) = r;
+  }
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183B14);
 
 
 extern void func_8012A828(s32, void*);
@@ -7729,7 +7884,31 @@ void func_80183FC8(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184034);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80130D48(s32 a0);
+extern void func_801846D0(void *a0);
+
+void func_80184034(s32 a0) {
+    if (*(s32 *)(a0 + 0x1C) < 0xC) {
+        register s32 mask __asm__("a0");
+        register s32 ptr __asm__("v0");
+        register s32 val __asm__("v1");
+
+        mask = 0x80000000;
+        ptr = *(s32 *)(a0 + 0x20);
+        val = *(s32 *)(ptr + 0x4);
+        val ^= mask;
+        *(s32 *)(ptr + 0x4) = val;
+    }
+
+    if (func_8012BEE8(a0) != 0) {
+        func_80130D48(a0);
+        *(s32 *)(a0 + 0x1C) = 0x3C;
+        *(s32 *)(*(s32 *)(a0 + 0x20) + 4) = 0x80000000;
+        func_801846D0(a0);
+    }
+}
+
 
 void func_801840B8(void *a0) {
         *(short *)((char *)a0 + 0x2) = 0x7;
@@ -7742,7 +7921,26 @@ void func_801840B8(void *a0) {
 void func_801840D8(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801840E0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018C090(s32 a0, u16 *a1, s16 a2);
+
+void func_801840E0(void *a0) {
+    s16 sp10[3];
+    u16 id;
+
+    id = *(u16 *)(a0 + 0x5E);
+    if (id == 0x23) {
+        *(u16 *)(a0 + 0xFE) = 1;
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) |= 0x10;
+        func_8002D4C8(0xAA1, 0);
+    } else if (id == 0x24) {
+        sp10[2] = 0;
+        sp10[0] = 0;
+        sp10[1] = -8;
+        func_8018C090((s32)a0, (u16 *)sp10, 0xB);
+    }
+}
+
 
 
 /* func_8018415C — light/colour ramp-up on the entity's attached prim block.
@@ -7848,7 +8046,23 @@ walk:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184300);
+extern s32 func_80184800(s32 a0);
+
+s32 func_80184300(s32 a0) {
+    s32 s0 = a0;
+
+    if (*(s16 *)(s0 + 0xAA) > 0) {
+        func_8018450C(s0, 4);
+        return 0;
+    }
+    if (func_8012BCCC(s0) > 0x24000 || func_80184800(s0) == 0) {
+        func_8018450C(s0, 3);
+        return 0;
+    }
+    func_8018450C(s0, 0);
+    return 1;
+}
+
 
 
 
@@ -10473,7 +10687,14 @@ void func_80187EF0(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018803C);
+extern M2C_UNK D_801C9FFC;
+extern M2C_UNK D_801CA030;
+void func_8018803C(s32 a0) {
+    s32 s0 = a0;
+    func_80188978(a0, (s32)&D_801C9FFC, 0);
+    func_8012A828(s0, (void*)&D_801CA030);
+}
+
 
 extern void func_8013240C(s32);
 void func_80188080(void) {
@@ -10483,7 +10704,31 @@ void func_80188080(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801880A8);
+extern void func_80188978(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern M2C_UNK D_801C9FFC;
+extern u8 D_801CA1A8[];
+extern u8 D_801CA1B4[];
+extern M2C_UNK D_801CA030;
+
+void func_801880A8(s32 param_1) {
+    s32 s0 = param_1;
+
+    *(u8 *)(s0 + 0xC2) = 0;
+    *(u8 *)(s0 + 0xC3) = 0;
+    *(u16 *)(s0 + 0x98) = 0;
+    func_80188978(s0, (s32)&D_801C9FFC, 0);
+
+    if (*(u16 *)(s0 + 0x5E) == 9 || *(u16 *)(s0 + 0x5E) == 0x1C) {
+        func_8012B14C(s0, (s32)D_801CA1A8);
+    } else {
+        func_8012B14C(s0, (s32)D_801CA1B4);
+    }
+
+    func_8012A828(s0, (void *)((u8 *)&D_801CA030));
+}
+
 
 typedef struct { s16 vx, vy, vz, pad; } SVec8_8018E8A0_80184FF0_80188134;          /* 0x08 */
 typedef struct { u8 d[4]; } Blk4_8017CE90_8017F32C_80184FF0_80188134;
@@ -11187,7 +11432,33 @@ void func_80189304(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801893BC);
+#include "common.h"
+
+extern s32 func_8012B8E4(s32 arg0, s32 arg1);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_801893BC(void *a0)
+{
+    s32 s0 = (s32)a0;
+    s32 v0;
+
+    if (*(s32 *)(s0 + 0xDC) & 8) {
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) + 0x44;
+    } else {
+        v0 = func_8012B8E4(s0, 8);
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x12) + v0;
+        if (v0 == 0) {
+            *(s16 *)(s0 + 2) = 5;
+            return;
+        }
+    }
+    if (func_8012BEE8(s0) != 0) {
+        *(s16 *)(s0 + 2) = 5;
+    }
+}
+
 
 extern void func_80189B3C(s32);
     s32 func_8018944C(s32 *a0) {
@@ -12929,7 +13200,16 @@ void func_8018C4F8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018C548);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+
+void func_8018C548(void *a0) {
+    if (*(u16 *)(a0 + 0xB8) == 0x8000) {
+        func_80154150((s32)a0, 0x25);
+        func_80171A1C((u8 *)a0);
+    }
+}
+
 
 void func_8018C58C(void) {
 }
diff --git a/src/ov_SC03_015/ov_SC03_015_jr_801848E4.c b/src/ov_SC03_015/ov_SC03_015_jr_801848E4.c
index 04be9a46ba..d305c6662a 100644
--- a/src/ov_SC03_015/ov_SC03_015_jr_801848E4.c
+++ b/src/ov_SC03_015/ov_SC03_015_jr_801848E4.c
@@ -2752,7 +2752,29 @@ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_8018492
 
 INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80184A08);
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80184D1C);
+extern s32 func_801847EC(void);
+extern s32 func_8001AAA0(s32 arg);
+extern s32 func_8016F0AC();
+
+void func_80184D1C(void *a0) {
+    u16 v1;
+
+    v1 = *(u16 *)((u8 *)a0 + 0x34);
+    switch (v1) {
+    case 0:
+        if (func_801847EC() != 0) {
+            *(u16 *)((u8 *)a0 + 0x34) = *(u16 *)((u8 *)a0 + 0x34) + 1;
+        }
+        /* fallthrough */
+    case 1:
+        if (func_8001AAA0(0x71) != 0) {
+            *(u16 *)((u8 *)a0 + 0x34) = *(u16 *)((u8 *)a0 + 0x34) + 1;
+            func_8016F0AC();
+        }
+        break;
+    }
+}
+
 
 
 extern void func_800183E0(s32 a0);
@@ -2934,7 +2956,29 @@ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801855A
 DEFINE_func_801856B4()  /* dedup: shared engine-core @0x801856B4 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801856C4);
+extern s32 func_80029504(void);
+extern void func_80178CBC(s32 arg0, s32 arg1);
+
+void func_801856C4(void *arg0) {
+
+    extern u16 D_8018FEE0[];
+    extern u16 D_8018FFA0[];
+    extern u16 D_8018FF38[];
+    s32 s0;
+
+    s0 = (s32)arg0;
+    if ((u32)func_80029504() < 0x2BC) {
+        func_80178CBC(s0, (s32)D_8018FEE0);
+    } else {
+        if (*(s16 *)(s0 + 0x10A) != 0) {
+            func_80178CBC(s0, (s32)D_8018FFA0);
+        } else {
+            func_80178CBC(s0, (s32)D_8018FF38);
+        }
+    }
+    *(s16 *)(s0 + 0x2) = 3;
+}
+
 
 
 extern s32 func_8001AAA0(s32 arg);
@@ -2971,9 +3015,47 @@ extern void func_800D0C48(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801857E4);
+extern u16 D_80126B5E;
+extern u16 D_80126B62;
+extern u16 D_80126B66;
+extern u16 D_80126BF0;
+extern u16 D_80126BF4;
+extern void func_80172780(void *a0);
+
+s32 func_801857E4(void) {
+    s16 t[3];
+    if ((s16)D_80126B5E == (s16)D_80126BF0 && (s16)D_80126B66 == (s16)D_80126BF4) {
+        t[2] = D_80126B66;
+        t[0] = D_80126B5E;
+        t[1] = D_80126B62;
+        func_80172780((void *)t);
+        return 1;
+    }
+    return 0;
+}
+
+
+extern s8 D_801903A8[];
+
+void func_80185858(s32 arg0) {
+    s32 *s0 = (s32 *)arg0;
+    u32 t;
+    s32 *obj;
+
+    if (func_8012C354(arg0, (s32)D_801903A8) == 0) {
+        return;
+    }
+
+    t = func_80029504();
+    *(s16 *)((s32)s0 + 2) = (t < 0x2DA) ? 1 : 4;
+
+    *(u8 *)((s32)s0 + 0x75) = 4;
+    func_8012B2CC((s32)s0);
+
+    obj = *(s32 **)((s32)s0 + 0x20);
+    *(u32 *)((s32)obj + 4) |= 0x80000000;
+}
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80185858);
 
 INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801858D4);
 
@@ -3851,7 +3933,30 @@ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80187DB
 
 DEFINE_func_80187E28()  /* dedup: shared engine-core @0x80187E28 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80187E3C);
+
+
+
+extern u16 D_801EAC70;
+extern u16 D_801EAC72;
+extern u16 D_801EAC74;
+extern u16 D_801EAC78;
+extern u16 D_801EAC7A;
+extern u16 D_801EAC7C;
+
+void func_80187E3C(void *a0) {
+    s32 v1;
+
+    *(u16 *)((s32)a0 + 0xFC) = D_801EAC70;
+    v1 = *(u16 *)((s32)a0 + 2);
+    *(u16 *)((s32)a0 + 0xFE) = D_801EAC72;
+    *(u16 *)((s32)a0 + 0x100) = D_801EAC74;
+    *(u16 *)((s32)a0 + 0x104) = D_801EAC78;
+    *(u16 *)((s32)a0 + 0x106) = D_801EAC7A;
+    *(u16 *)((s32)a0 + 0x108) = D_801EAC7C;
+    *(s32 *)((s32)a0 + 0x1C) = 0x10;
+    *(u16 *)((s32)a0 + 2) = v1 + 1;
+}
+
 
 extern void func_80187EE8(s32 a0);
 extern s32 func_8012BEE8(s32 a0);
@@ -3869,25 +3974,148 @@ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80187EE
 DEFINE_func_801880F8()  /* dedup: shared engine-core @0x801880F8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188118);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801E2170[];
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188168);
+void func_80188118(s32 param_1) {
+    *(u16 *)(param_1 + 0x5C) = 0xA800;
+    *(u16 *)(param_1 + 0x2) = 0x1;
+    func_8012A828(param_1, D_801E2170);
+    *(s32 *)(param_1 + 0xB4) &= -2;
+}
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801881CC);
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188290);
+void func_80188168(s32 a0) {
+    extern u8 D_80190468[];
+    *(u8 *)(a0 + 0xC1) = 0;
+    *(u16 *)(a0 + 0x5C) = 0;
+    *(u16 *)(a0 + 0x2) = 0x11;
+    func_8012A828(a0, D_80190468);
+    *(s16 *)(a0 + 0xAE) = -1;
+    func_8002D4C8(0xA87, 0);
+    func_8002A04C(a0);
+    func_80182D5C();
+}
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188350);
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801883AC);
+void func_801881CC(void *a0) {
+    extern void func_80131B14();
+    extern void func_80131E00();
+    extern s32 func_80131A34(s32 a0, s32 a1);
+    extern void func_80182D04(s32 a0, s32 a1, s32 a2);
+    extern u16 D_80190490[];
+    extern s32 rand(void);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+
+    *(u32 *)((s32)a0 + 0xB4) = *(u32 *)((s32)a0 + 0xB4) | 1;
+    *(u8 *)((s32)a0 + 0xC1) = 1;
+    func_80131B14();
+
+    *(s16 *)((s32)a0 + 0xAE) = -1;
+    if (*(s16 *)((s32)a0 + 0x76) <= 0) {
+        func_80131E00(a0, 0xC);
+        *(s16 *)((s32)a0 + 0x76) = 0;
+        func_80182D04((s32)a0 + 0x76, (s32)D_80190490, 0x96);
+    } else {
+        func_80182D04((s32)a0 + 0x76, (s32)D_80190490, 0x96);
+        if (func_80131A34((s32)a0, 4) != 0) {
+            *(u8 *)((s32)a0 + 0xC2) = 0;
+        }
+        func_8002D4C8((rand() & 1) ? 0xA85 : 0xA86, 0);
+    }
+}
+
+
+void func_80188290(s32 arg0) {
+    s32 obj;
+    s32 rnd;
+    s32 i;
+
+    for (i = 0x600; i < 0xB00; i += 0x100) {
+        obj = func_8012C658(0x265, 2, arg0);
+        if (obj != 0) {
+            rnd = rand() & 7;
+            *(s32 *)(obj + 0x10) =
+                -func_8004787C(*(s16 *)(arg0 + 0xFE) + i) * rnd << 4;
+            *(s32 *)(obj + 0x18) =
+                -func_80047948(*(s16 *)(arg0 + 0xFE) + i) * rnd << 4;
+        }
+    }
+    func_8012C218((void *)arg0);
+}
+
+
+extern void func_8012AD80(s32 a0);
+extern void func_8012C218(void *a0);
+extern s32 D_801EAC80;
+
+void func_80188350(s32 a0) {
+    s32 val;
+
+    val = *(s32 *)(a0 + 0x1C) - 1;
+    *(s32 *)(a0 + 0x1C) = val;
+    if (val <= 0) {
+        D_801EAC80--;
+        func_8012C218((void *)a0);
+    } else {
+        func_8012AD80(a0);
+    }
+}
+
+
+extern s32 func_8012CBCC(s32 a0);
+
+void func_801883AC(s32 a0) {
+    func_8012CBCC(a0);
+    *(u16 *)((char *)a0 + 0xFC) -= 1;
+    if (*(s16 *)((char *)a0 + 0xFC) == 0) {
+        *(u16 *)((char *)a0 + 0x2) = 0xA;
+        *(u16 *)((char *)a0 + 0xFC) = 4;
+        *(s16 *)((char *)a0 + 0xAE) = -1;
+    }
+}
+
+
+extern s32 func_8012CBCC(s32 a0);
+extern s32 func_8012BA10(s32 a0, s32 a1);
+
+void func_80188404(s32 a0) {
+    s16 t;
+    func_8012CBCC(a0);
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012BA10(a0, 4);
+    t = *(u16 *)(a0 + 0xFC) - 1;
+    *(u16 *)(a0 + 0xFC) = t;
+    if (t == 0) {
+        *(u16 *)(a0 + 0x2) = 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188404);
 
 DEFINE_func_80188470()  /* dedup: shared engine-core @0x80188470 (src/shared) */
 
 DEFINE_func_80188478()  /* dedup: shared engine-core @0x80188478 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_8018858C);
+extern u16 D_80126B66;
+void func_8018858C(s32 a0) {
+    s32 v0 = *(s16 *)(a0 + 0x84);
+    if (v0 != 0) {
+        v0 = func_80184028();
+        if (v0 == 0x18) {
+            *(s16 *)(a0 + 0x84) = 0;
+        }
+    } else {
+        s32 a1;
+        v0 = func_80184028();
+        if (v0 == 0xF) {
+            *(s16 *)(a0 + 0x84) = 1;
+            a1 = -(s16)D_80126B66 >> 3;
+            if (a1 < 0) a1 = 0;
+            if (a1 > 0x7F) a1 = 0x7F;
+            func_8002D4C8(0xBAB, (u16)(a1 | 0x1000));
+        }
+    }
+}
+
 
 
 extern void (*D_801918B0[])(void);
@@ -3965,7 +4193,19 @@ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188B9
 
 INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188C0C);
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188C60);
+#include "common.h"
+
+void func_80188C60(s32 a0) {
+    extern void func_80188F18(void *a0);
+    extern void func_8012AD44(s32 *a0, s16 a1);
+    extern char D_80191908[];
+    register s32 self __asm__("$16") = a0;       /* $s0 */
+
+    *(s32 *)(self + 0x58) = (s32)D_80191908;
+    func_80188F18((void *)self);
+    func_8012AD44((s32 *)self, 6);
+}
+
 
 
 s32 func_80188CA0(s32 arg0) {
@@ -3973,7 +4213,47 @@ s32 func_80188CA0(s32 arg0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188CB4);
+extern void func_801439C0(u8 *a0);
+extern void func_8012B200(u8 *a0);
+extern void func_801292C8(u8 *a0);
+extern u16 D_80126B5E;
+extern u16 D_80126B66;
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80188CB4(s32 a0)
+{
+    register s32 s0 __asm__("$16") = a0;
+    u8 *ptr;
+    s32 val1;
+    s32 val2;
+    s32 t2;
+
+    func_801439C0(*(u8 **)(s0 + 0xCC));
+    func_8012B200((u8 *)s0);
+
+    *(s32 *)(s0 + 0x14) = 0x80000;
+    *(u16 *)(s0 + 6) = D_80126B5E;
+    *(u16 *)(s0 + 0xE) = D_80126B66;
+
+    ptr = *(u8 **)(s0 + 0x20);
+    val1 = *(u16 *)(ptr + 0x18);
+    *(s16 *)(s0 + 0xDC) = (val1 << 16) >> 19;
+
+    ptr = *(u8 **)(s0 + 0x20);
+    val2 = *(u16 *)(ptr + 0x1A);
+    *(s16 *)(s0 + 0xDE) = (val2 << 16) >> 19;
+
+    func_8012AD44((s32 *)s0, 7);
+
+    t2 = *(s32 *)(s0 + 0xD0);
+    if (t2 != 0) {
+        func_801292C8((u8 *)t2);
+    }
+
+    func_8002D4C8(0x87D, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80188D64);
 
@@ -4151,7 +4431,36 @@ void func_801891E8(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80189238);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern s32 func_80029178(s32 arg);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+extern u8 D_801E3F20;
+extern u8 D_801918A0;
+
+void func_80189238(s32 param_1)
+{
+    s32 v0;
+
+    if ((*(s32 *)(param_1 + 0x20) = v0 = ((s32 (*)(void))func_8012C1B8)()) == 0) {
+        goto fail;
+    }
+    if (((s32)(u8)((s32 (*)(s32))func_80029178)(0x18)) != 0) {
+        goto fail;
+    }
+    func_8001C214(*(s32 *)(param_1 + 0x20), &D_801E3F20);
+    if (((s32 (*)(s32, void *))func_8012C588)(0x2B4, param_1) == 0) {
+fail:
+        ((void (*)(void *))func_8012CAE4)(param_1);
+    } else {
+        *(s32 *)(param_1 + 0x58) = (s32)&D_801918A0 | 0x40000000;
+        *(s16 *)(param_1 + 0x5C) = 0x800;
+        ((s32 (*)(void *))func_8012AD50)(param_1);
+    }
+}
+
 
 DEFINE_func_801892D4()  /* dedup: shared engine-core @0x801892D4 (src/shared) */
 
@@ -4213,7 +4522,26 @@ void func_8018950C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_801895BC);
+extern s32 func_80178970(void);
+extern void func_80178D18(void);
+extern void func_80029514(s32);
+extern s16 D_801EAFC8;
+
+void func_801895BC(void *arg0) {
+    if (*(u16 *)((s32)arg0 + 0x34) != 0) {
+        return;
+    }
+    if (func_80178970() == 0) {
+        return;
+    }
+    if (D_801EAFC8 != 0) {
+        return;
+    }
+    ((void (*)(void *))func_80178D18)(arg0);
+    *(u16 *)((s32)arg0 + 0x34) = *(u16 *)((s32)arg0 + 0x34) + 1;
+    func_80029514(0x2D0);
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern void func_8012C218(void *a0);
@@ -4302,7 +4630,23 @@ void func_801899F4(int param_1)
 
 INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80189A60);
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_801848E4", func_80189AC4);
+extern u8 D_80078EAF;
+s32 func_80189AC4(s32 arg) {
+    if ((func_80029178(0x18) & 0xFF) != 0) {
+        return 0x73;
+    }
+    if ((func_80029178(0xB9) & 0xFF) != 0) {
+        return 0x71;
+    }
+    if (arg >= 0x2C6) {
+        return 0x50;
+    }
+    if (D_80078EAF == 4) {
+        return 0x3C;
+    }
+    return 0xA;
+}
+
 
 
 extern void (*D_801E3298[])(void);
diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
index 654233f5bc..79d1b4b840 100644
--- a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
+++ b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c
@@ -4070,7 +4070,16 @@ s32 func_80181170(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_801811B4);
+extern s32 D_80126B58;
+
+s32 func_801811B4(void) {
+    if ((func_800167F0(0) & 0xFFFF) == 0) {
+        return 0;
+    }
+    func_80171990((u8 *)&D_80126B58);
+    return 1;
+}
+
 
 
 extern void (*D_8018F718[])(void);
@@ -5552,7 +5561,20 @@ void func_80183930(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_8018396C);
+extern void func_8013B7AC(s32 a0);
+
+void func_8018396C(s32 a0) {
+    s32 i;
+    s32 s1 = a0;
+
+    for (i = 0; i < 3; i++) {
+        func_8013B7AC(i);
+    }
+
+    *(u16 *)(s1 + 0x2) += 1;
+    *(u32 *)(s1 + 0xCC) = 0;
+}
+
 
 typedef struct { short vx, vy, vz, pad; } SV_801851A8_801839C4;
 typedef struct { short m[3][3]; long t[3]; } MTX_801851A8_801839C4;
@@ -5685,7 +5707,19 @@ L_E78:
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80183B98);
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80183BF0);
+extern void func_80183C3C(s32 a0, s32 a1);
+extern void func_80183C80(s32 a0, s32 a1, s32 a2);
+
+void func_80183BF0(s32 a0, s32 a1) {
+    u16 type;
+    type = *(u16 *) a0;
+    if (type != 0x178 && type != 0x1E8) {
+        func_80183C3C(a0 + 4, a1);
+    } else {
+        func_80183C80(a0 + 4, a1, 0xC0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80183C3C);
 
@@ -5712,7 +5746,19 @@ void func_80183CCC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80183D48);
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80183E14);
+void func_80183E14(void *a0) {
+    s16 t;
+    s32 r;
+
+    t = rand();
+    *(u16 *)((s32)a0 + 0x104) = *(u16 *)((s32)a0 + 0xFC);
+    func_8012B200(a0);
+    r = rand();
+    *(s32 *)((s32)a0 + 0x1C) = r % 60 + 0x78;
+    *(s16 *)((s32)a0 + 0xFE) = t % 32 + 0xA;
+    *(s16 *)((s32)a0 + 0x2) = 2;
+}
+
 
 #include "common.h"
 
@@ -5796,9 +5842,29 @@ void func_80183EC4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_8018400C);
+extern void func_8012CBF4(s32 a0);
+extern s32 func_80013478(s32 a0, s32 a1);
+
+void func_8018400C(s32 a0) {
+    func_8012CBF4(a0);
+    if (func_80013478(a0 + 4, a0 + 0x88) < 0x101) {
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0;
+        *(u16 *)(a0 + 2) = 4;
+    }
+}
+
+
+void func_80184060(s32 a0)
+{
+    extern void func_8012BE54(s32 a0);
+    extern s32  func_80184A04();
+    extern s16  D_80126CBA;
+
+    if (((s32 (*)(s32))func_8012BE54)(a0) <= 0x40000 && D_80126CBA == 0 && func_80184A04(a0) == 0) {
+        *(s16 *)(a0 + 0x2) = 5;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80184060);
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_801840C0);
 
@@ -6072,11 +6138,67 @@ void func_80184588(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_801846E4);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80184734);
+extern s32  func_8012BEE8(s32 a0);
+extern void func_8012E88C(u8 *a0);
+
+void func_801846E4(s32 a0) {
+    s32 u;
+
+    if (func_8012BEE8(a0) != 0) {
+        *(s16 *)(a0 + 0x2) = 1;
+        func_8012E88C((u8 *)a0);
+        u = *(s32 *)(a0 + 0xCC);
+        if (u != 0) {
+            *(s16 *)(u + 0xFC) = 0;
+        }
+    }
+}
+
+
+#include "common.h"
+
+void func_80184734(s32 arg0) {
+    s32 v = *(s32 *)(arg0 + 0xCC);
+
+    if (v != 0) {
+        *(s16 *)(v + 0xFC) = 1;
+    }
+}
+
+
+extern void func_8002A04C(s32 a0);
+extern void func_8012B200(u8 *a0);
+extern void func_8012E8A8(u8 *a0);
+extern void func_8012C218(void *a0);
+
+void func_80184750(void *arg0) {
+    func_8002A04C((s32)arg0);
+
+    if ((*(s16 *)((char *)arg0 + 0x70) & 0x8000) != 0) {
+        s32 v1 = *(s32 *)((char *)arg0 + 0x20);
+        *(s16 *)((char *)arg0 + 0x2) = 0x7;
+        *(s8 *)((char *)arg0 + 0xC1) = 0;
+        *(s32 *)((char *)arg0 + 0x1C) = 0x40;
+        *(s16 *)((char *)arg0 + 0x5E) = 0;
+        *(s16 *)((char *)arg0 + 0x5C) = 0;
+        *(s16 *)((char *)v1 + 0x12) = 0;
+        *(s16 *)((char *)v1 + 0x10) = 0;
+        *(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x2C) &= 0xFFEF;
+        *(s16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x18) =
+            *(s16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x1A) =
+            *(s16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x1C) = 0x1000;
+        func_8012B200((u8 *)arg0);
+        func_8012E8A8((u8 *)arg0);
+        *(s16 *)((char *)arg0 + 0x6) = *(u16 *)((char *)arg0 + 0x88);
+        *(s16 *)((char *)arg0 + 0xA) = *(u16 *)((char *)arg0 + 0x8A);
+        *(s16 *)((char *)arg0 + 0xE) = *(u16 *)((char *)arg0 + 0x8C);
+    } else {
+        func_8012C218(arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80184750);
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_8018480C);
 
@@ -6234,7 +6356,30 @@ void func_80184C74(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80184D74);
+extern void func_8012E88C(u8 *a0);
+extern void func_80184E20(s32 param_1);
+extern void func_80185178(s32 arg0);
+extern void func_8012B2CC(s32 a0);
+extern void func_80185138(s32 a0);
+
+void func_80184D74(void *a0) {
+    if (*(s16 *)((s32)a0 + 0xFE) != *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x36)) {
+        func_80184E20((s32)a0);
+        return;
+    }
+
+    if (*(s16 *)((s32)a0 + 0xFC) == 0) {
+        *(s16 *)((s32)a0 + 0x2) = 1;
+        func_8012E88C((u8 *)a0);
+        func_80185178(*(s32 *)((s32)a0 + 0xCC));
+        *(s32 *)((s32)a0 + 0x4) = *(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x4);
+        *(s32 *)((s32)a0 + 0x8) = *(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x8);
+        *(s32 *)((s32)a0 + 0xC) = *(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0xC);
+        func_8012B2CC((s32)a0);
+        func_80185138((s32)a0);
+    }
+}
+
 
 
 extern void func_80016714(void *a0, s32 a1);
@@ -6440,7 +6585,17 @@ void func_80184E84(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80185138);
+void func_80185138(s32 a0) {
+    s32 v1;
+
+    v1 = *(s32 *)(a0 + 0xCC);
+    if (v1 != 0) {
+        *(u16 *)(v1 + 0x8) = *(u16 *)(a0 + 0x6);
+        *(u16 *)(v1 + 0xA) = *(u16 *)(a0 + 0xA) - 0x19;
+        *(u16 *)(v1 + 0xC) = *(u16 *)(a0 + 0xE);
+    }
+}
+
 
 void func_80185178(s32 arg0) {
         if (arg0 != 0) {
@@ -6456,7 +6611,35 @@ void func_80185198(s32 arg0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_801851B8);
+void func_801851B8(s32 arg0) {
+    extern u8 D_801A300C[];
+    extern u8 D_801A2FC0;
+    extern u8 D_801A2FC1;
+    extern u8 D_801A2FC2;
+    extern s32 func_8004787C(s32 a0);
+    register u8 *p __asm__("$4");
+    register s32 i __asm__("$5");
+    s32 t;
+
+    t = ((func_8004787C((*(s32 *)(arg0 + 0x1C) << 6) & 0x7C0) * 100) >> 12) + 0x64;
+
+    i = 0;
+    p = D_801A300C;
+    do {
+        i++;
+        p[2] = t;
+        p[1] = t;
+        p[0] = t;
+        p += 0x10;
+    } while (i < 3);
+
+    D_801A2FC2 = t;
+    D_801A2FC1 = t;
+    D_801A2FC0 = t;
+
+    *(s32 *)(arg0 + 0x1C) += 1;
+}
+
 
 
 extern void (*D_801A31A8[])(void);
@@ -6696,7 +6879,24 @@ void func_80185598(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80185934);
+#include "common.h"
+
+extern void func_8012CBCC(s32 a0);
+extern s32  func_8012BEE8(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_80017274(s32 a0, s32 a1);
+
+void func_80185934(s32 param_1) {
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + 0x40;
+
+    if (((s32 (*)(s32))func_8012CBCC)(param_1) != 0 || func_8012BEE8(param_1) != 0) {
+        func_8012C218((void *)param_1);
+    } else {
+        func_80017274(param_1 + 0xDC, *(s32 *)(param_1 + 0x20) + 0x34);
+    }
+}
+
 
 extern void (*D_801A5BC4[])(void);
 extern void func_8012C0EC(void *a0);
@@ -6776,7 +6976,17 @@ void func_80185A34(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80185BA0);
+extern void func_8012B23C(void *a0);
+
+void func_80185BA0(s32 a0) {
+    func_8012B23C((void *)a0);
+    *(s32 *)(a0 + 0x1C) = 0x40;
+    *(s16 *)(a0 + 0x2) = 2;
+    *(s16 *)(a0 + 0x34) = 0;
+    *(s32 *)(a0 + 0xE4) = 0;
+    *(s32 *)(a0 + 0xE8) = 0x40;
+}
+
 
 
 /* func_80185BE4 — ov_SC02_026 / ov_SC02_026_jr_8017C180.c   MATCH (230 ins)
@@ -6993,9 +7203,40 @@ extern s32 func_8012B030(u8 *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80185FA8);
+extern s32 func_8004787C(s32 a0);
+
+void func_80185FA8(s32 a0) {
+    s32 p;
+    s16 t;
+
+    p = *(s32 *)(a0 + 0x20);
+    t = func_8004787C(*(s32 *)(a0 + 0x1C) << 6);
+    *(s16 *)(p + 0x1C) = t;
+    *(s16 *)(p + 0x1A) = t;
+    *(s16 *)(p + 0x18) = t;
+    if (++*(s32 *)(a0 + 0x1C) >= 0x11) {
+        *(s16 *)(a0 + 2) = 1;
+        *(u16 *)(a0 + 0x5C) = *(u16 *)(*(s32 *)(a0 + 0x78) + 2);
+    }
+}
+
+
+extern s32 func_8012BEE8(s32 a0);
+
+void func_80186020(s32 a0) {
+    s32 v1;
+
+    if (func_8012BEE8(a0) != 0) {
+        v1 = *(s32 *)(a0 + 0x20);
+        *(s16 *)(a0 + 0x2) = 6;
+        *(s16 *)(a0 + 0x34) = 0;
+        *(s16 *)(v1 + 0x1C) = 0x400;
+        *(s16 *)(v1 + 0x18) = 0x400;
+        v1 = *(s32 *)(a0 + 0x20);
+        *(s16 *)(v1 + 0x1A) = 0x3000;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80186020);
 
 
 extern void func_8012BE54(s32 a0);
@@ -7399,7 +7640,20 @@ void func_80186D04(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80186D40);
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80186E24);
+extern void func_80187318(s32 a0);
+
+void func_80186E24(s32 arg0) {
+    s32 temp_v0;
+    func_80187318(arg0);
+    if (*(s32 *)(arg0 + 0x30) == 0) {
+        *(s16 *)(arg0 + 2) = 6;
+        *(s32 *)(arg0 + 0x1c) = 0;
+    } else {
+        temp_v0 = *(s32 *)(arg0 + 0x1c) + 1;
+        *(s32 *)(arg0 + 0x1c) = temp_v0;
+    }
+}
+
 
 
 extern s32 func_80187240(s32 a0, s32 a1);
@@ -7460,7 +7714,17 @@ extern void func_801292C8(u8 *a0);
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80186FB8);
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80186FF8);
+extern void func_801292C8(u8 *a0);
+extern void func_80187318(s32 a0);
+
+void func_80186FF8(s32 arg0) {
+    func_80187318(arg0);
+    if (*(u16 *)(*(s32 *)(arg0 + 0x2c)) == 0) {
+        func_801292C8((u8 *)arg0);
+    }
+    *(s32 *)(arg0 + 0x1c) += 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187050);
 
@@ -7511,7 +7775,17 @@ s32 func_801870EC(s32 a0, s32 a1, s32 a2) {
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187240);
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187318);
+void func_80187318(s32 a0)
+{
+    s32 t = func_8004787C((*(s32 *)(a0 + 0x1C) << 7) & 0x780);
+    s32 a = *(s32 *)(a0 + 0x34);
+    s32 *p = *(s32 **)(a0 + 0x20);
+    s32 r = a - ((a >> 2) * t >> 12);
+
+    *(s16 *)((u8 *)p + 0x1A) = r;
+    *(s16 *)((u8 *)p + 0x18) = r;
+}
+
 
 
 extern void (*D_801A5CA8[])(void);
@@ -7596,7 +7870,22 @@ void func_801874BC(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187598);
+extern void func_80187B44(s32 a0, s32 a1);
+
+void func_80187598(s32 a0)
+{
+    u16 v1;
+
+    if (*(s16 *)(a0 + 0x70) & 0x8000) {
+        v1 = *(u16 *)(a0 + 0xFC);
+        *(s16 *)(a0 + 2) = 3;
+        *(u16 *)(a0 + 0xE6) = v1;
+    } else {
+        *(s16 *)(a0 + 2) = 2;
+        func_80187B44(a0, 0);
+    }
+}
+
 
 #include "common.h"
 
@@ -7916,9 +8205,34 @@ void func_801879E4(s32 arg0_)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187AD4);
+void func_80187AD4(s32 a0) {
+    s32 v1;
+    s16 t;
+
+    v1 = *(s32 *)(a0 + 0x78);
+    *(s16 *)(a0 + 2) = 1;
+    t = *(u16 *)(v1 + 2);
+    v1 = *(s32 *)(a0 + 0x20);
+    *(s16 *)(a0 + 0x5C) = t;
+    *(s16 *)(v1 + 0x18) = 0x1800;
+}
+
+
+extern void func_8012C098(void *param_1);
+extern void func_8012E8A8(u8 *a0);
+
+void func_80187AF8(s32 a0) {
+    if (*(s16 *)(a0 + 0xFE) == 0) {
+        func_8012C098((void *)a0);
+        return;
+    }
+    *(u16 *)(a0 + 0x2) = 4;
+    *(u8 *)(a0 + 0xC1) = 0;
+    *(u16 *)(a0 + 0x5E) = 0;
+    *(u16 *)(a0 + 0x5C) = 0;
+    func_8012E8A8((u8 *)a0);
+}
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187AF8);
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187B44);
 
@@ -7936,7 +8250,7 @@ extern s32 rand(void);
 
 /* Not declared anywhere in the TU or in include/ (func_80187FD8 is INCLUDE_ASM'd
    later in the same file, TU:7115).  Raw-word/void* form per wave law 4. */
-extern void *func_80187FD8(void *a0);
+extern void *func_80187FD8();
 extern s32 D_801A907C[];
 
 /* Spawns three scatter particles around a0's position.  Two rotation transforms
@@ -8018,9 +8332,73 @@ void func_80187D70(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187F4C);
+void func_80187F4C(s32 a0)
+{
+    register s32 v0 __asm__("$2");
+    s32 v1;
+    s32 a1;
+
+    v0 = *(s32 *)(a0 + 0xE0);
+    if (v0 == 0) {
+        v0 = 1;
+        goto END;
+    }
+    v0 = v0 - 1;
+    *(s32 *)(a0 + 0xE0) = v0;
+    if (v0 > 0) {
+        goto SET0;
+    }
+
+    v1 = *(s32 *)(a0 + 0xD0);
+    v1 = v1 + 8;
+    a1 = *(s32 *)v1;
+    if ((a1 & 0x40000000) != 0) {
+        v1 = *(s32 *)(a0 + 0xCC);
+    } else if (a1 < 0) {
+        v0 = 1;
+        *(s32 *)(a0 + 0xE0) = 0;
+        goto END;
+    }
+
+    v0 = *(s32 *)v1;
+    *(s32 *)(a0 + 0xD0) = v1;
+    *(s32 *)(a0 + 0xE0) = v0;
+    func_800183E0(*(s32 *)(v1 + 4));
+
+SET0:
+    v0 = 0;
+END:
+    __asm__ volatile("" : : "r"(v0));
+}
+
+
+extern u8 *func_801290DC(s32 a0, u8 *a1);
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+
+void * func_80187FD8(s32 a0)
+{
+
+    extern u8 D_801A908C[];
+    extern s32 D_801A9098[];
+    u8 *obj;
+    s32 sub;
+    s32 arg;
+
+    obj = func_801290DC(0x43, (u8 *)a0);
+    if (obj == 0) {
+        return 0;
+    }
+    arg = (s32)obj + 0x24;
+    sub = *(s32 *)(obj + 0x20);
+    *(s32 *)(sub + 0x20) = (s32)D_801A908C;
+    *(u8 *)(sub + 0x27) = 0x66;
+    *(u16 *)(sub + 0x1A) = 0x2000;
+    *(u16 *)(sub + 0x18) = 0x2000;
+    *(s32 *)(sub + 4) |= 0xD8000000;
+    func_80128EA8(sub, arg, (s32)D_801A9098);
+    return (s32)obj;
+}
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_80187FD8);
 
 INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_8018805C);
 
diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
index a64e56bd01..5df5b1bcf3 100644
--- a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
+++ b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c
@@ -4896,7 +4896,15 @@ int func_8017F1E0(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8017F210);
+void func_8017F210(void *a0) {
+    extern void func_8012B2CC(s32 a0);
+    extern void (*D_8018B8B4[])(void *);
+    if (*(u16 *)((s32)a0 + 0x2) != 0) {
+        func_8012B2CC((s32)a0);
+    }
+    D_8018B8B4[*(u16 *)((s32)a0 + 0x2)](a0);
+}
+
 
 extern s32 func_800D0F8C(s32 arg);
     s32 func_8017F270(void) {
@@ -4952,7 +4960,38 @@ void func_8017F358(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8017F390);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern void func_80029124(s32, s32);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012C218(void *a0);
+
+void func_8017F390(void *arg0) {
+    u16 temp;
+
+    if (func_80178970() != 0) {
+        ((void (*)(s32))func_80178D18)((s32)arg0);
+        temp = *(u16 *)((s32)arg0 + 0x34);
+        *(s16 *)((s32)arg0 + 0x2) = 1;
+        if (temp != 0) {
+            func_80029124(0xDC, 1);
+            func_8002D4C8(4, 0xB1D);
+            func_8012C218(*(void **)((s32)arg0 + 0x6C));
+            ((void (*)(void *))func_8012C218)(arg0);
+            return;
+        }
+    }
+
+    if (*(s16 *)((s32)arg0 + 0x10A) != 0) {
+        *(u16 *)((s32)arg0 + 0xA) -= 2;
+        *(u16 *)((s32)arg0 + 0xE) ^= 2;
+        if (*(s16 *)((s32)arg0 + 0x8A) - *(s16 *)((s32)arg0 + 0xA) >= 0x121) {
+            *(s16 *)((s32)arg0 + 0x10A) = 0;
+            func_8002D4C8(4, 0xB1D);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8017F458);
 
@@ -4969,7 +5008,19 @@ void func_8017F4BC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8017F4F8);
+void func_8017F4F8(s32 a0) {
+    extern void (*D_8018B8D4)(void);
+    extern u8 D_80187E20[];
+    extern void func_8017F5E0(void);
+    s32 s0 = a0;
+    if (func_8012C354(a0, (s32)&D_8018B8D4)) {
+        *(u8 *)(s0 + 0xC0) = 1;
+        *(u16 *)(s0 + 0x2) = 1;
+        func_8012A828(s0, (s32)D_80187E20);
+        *(s32 *)(s0 + 0x6C) = func_801788B8(s0, (s32)func_8017F5E0);
+    }
+}
+
 
 void func_8017F560(void) {
 }
@@ -6003,7 +6054,24 @@ void func_80180780(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018093C);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80029124(s32 a0, s32 a1);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern s32 D_80199AB8[];
+extern s32 D_80199AF4[];
+extern s32 D_80199B0C;
+
+void func_8018093C(s32 *param_1) {
+    *(s16 *)((u8 *)param_1 + 0x10A) = 0;
+    func_8012AD44(param_1, 2);
+    func_80029124(D_80199AB8[*(s16 *)((u8 *)param_1 + 0x108)], 1);
+    {
+        s32 *ptr = &D_80199B0C;
+        *ptr = D_80199AF4[*(s16 *)((u8 *)param_1 + 0x108)];
+        func_80178B18((s32)param_1, (s32)ptr - 0xC);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801809B8);
 
@@ -6026,7 +6094,31 @@ void func_80180BA0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80180BDC);
+extern s32 func_8012C51C(void *a0, s32 a1);
+
+struct Prim_80180BDC { s16 f0, f2, f4, f6, f8, fA, fC, fE; s32 f10; };
+
+void func_80180BDC(void *arg0, s32 a1) {
+    struct Prim_80180BDC sp;
+
+    if (arg0 != 0 && *(u16 *)arg0 != 0) {
+        sp.f0 = *(u16 *)((s32)arg0 + 0x6);
+        sp.f2 = *(u16 *)((s32)arg0 + 0xA);
+        sp.f4 = *(u16 *)((s32)arg0 + 0xE);
+    } else {
+        sp.f4 = 0;
+        sp.f2 = 0;
+        sp.f0 = 0;
+    }
+    sp.f6 = 0x8E;
+    sp.fE = 0;
+    sp.fA = 0;
+    sp.f8 = 0;
+    sp.f10 = *(s32 *)((s32)arg0 + 0xDC);
+    sp.fC = a1;
+    func_8012C51C(&sp, arg0);
+}
+
 
 #include "common.h"
 
@@ -6121,11 +6213,39 @@ s32 func_80180C68(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80180DD8);
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80180E48);
+extern u8 D_801202A0[];
+void func_80180E48(void) {
+    u16 *p = (u16 *)D_801202A0;
+    s32 i = 0;
+    do {
+        switch (*p) {
+        case 0x1DC:
+        case 0x1FC:
+        case 0x210:
+        case 0x219:
+            func_8012C218(p);
+            break;
+        }
+        i += 1;
+        p += 0x86;
+    } while (i < 0x60);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80180EFC);
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80180FF8);
+extern int func_80178970(void);
+extern void func_80178D18();
+
+void func_80180FF8(void *a0) {
+    if (*(u16 *)((s32)a0 + 0x34) == 0) {
+        if (func_80178970() != 0) {
+            ((void (*)(s32))func_80178D18)(a0);
+            *(u16 *)((s32)a0 + 0x34) += 1;
+        }
+    }
+}
+
 
 
 
@@ -6680,7 +6800,23 @@ void func_80181FA0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801820B8);
+extern void (*D_80199CC4[])();
+
+void func_801820B8(s32 arg0)
+{
+    s16 var = *(s16 *)(arg0 + 0x10A);
+
+    if (var != 0) {
+        var = var - 1;
+        *(s16 *)(arg0 + 0x10A) = var;
+        if (var == 0) {
+            *(s32 *)(arg0 + 0xC4) &= ~1;
+        }
+    }
+
+    D_80199CC4[*(u16 *)(arg0 + 2)]();
+}
+
 
 extern u8 D_801A4918[];
 extern u8 D_801A4AD8[];
@@ -6943,7 +7079,22 @@ void func_801828B0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801829C8);
+#include "common.h"
+
+extern void (*D_801A4CBC[])();
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_801659CC(void);
+
+void func_801829C8(s32 a0) {
+    D_801A4CBC[*(u16 *)(a0 + 2)]();
+    if (a0 != 0 && *(s16 *)(a0 + 0x70) == 3) {
+        if (func_801659CC() != 0) {
+            *(s16 *)(a0 + 0x70) = 0;
+            func_8002D4C8(0xB6B, 0);
+        }
+    }
+}
+
 
 extern u8 D_801AD9D8[];
 extern u8 D_801ADAF8[];
@@ -6991,7 +7142,52 @@ void func_80182B10(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80182B7C);
+#include "common.h"
+
+/* Declarations copied VERBATIM from the destination TU / atlas fleet rows (law 2):
+ *   func_8012C354  TU:3425/7683  extern s32 func_8012C354(s32 a0, s32 a1);
+ *   func_8012B23C  TU:7313/7684  extern void func_8012B23C(s32 a0);
+ *   func_8012A828  TU:6748       extern void func_8012A828(s32, s32);
+ *   func_80143970  engine_core.h DEFINE_func_80143970 returns s32 -> extern s32 (s32);
+ *   D_801AD498     TU:6757/6835  extern u8 D_801AD498[];
+ *   D_801A4BF0 / D_801A4C64 / D_801A4C24 appear nowhere else in this TU: declared
+ *   fresh, block scope, u8[], address-only use (array-decay form per TU:3480).
+ */
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8012B23C(s32 a0);
+extern void func_8012A828(s32, s32);
+extern s32 func_80143970(s32 a0);
+
+void func_80182B7C(s32 a0) {
+    extern u8 D_801A4BF0[];
+    extern u8 D_801AD498[];
+    extern u8 D_801A4C64[];
+    extern u8 D_801A4C24[];
+    s16 v1;
+
+    if (func_8012C354(a0, (s32)D_801A4BF0) == 0) {
+        return;
+    }
+
+    *(u8 *)(a0 + 0xC0) = 1;
+    *(s32 *)(a0 + 0xB4) = -1;
+    func_80143970(a0);
+    func_8012A828(a0, (s32)&D_801AD498);
+    *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1;
+    func_8012B23C(a0);
+
+    v1 = *(s16 *)(a0 + 0x70);
+    switch (v1) {
+    case 3:
+        *(s32 *)(a0 + 0xBC) = (s32)D_801A4C64;
+        *(u16 *)(a0 + 0x76) = 0x280;
+        break;
+    default:
+        *(s32 *)(a0 + 0xBC) = (s32)D_801A4C24;
+        break;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80182C20);
 
@@ -7252,7 +7448,31 @@ INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801831F
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80183228);
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018323C);
+#include "common.h"
+
+void func_8018323C(s32 a0) {
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern s32 func_80143994(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, s32 a1);
+    extern void func_8012B200(u8 *a0);
+    extern u8 D_801ADC00[];
+    extern u8 D_801B0434[];
+    extern u8 D_801ADC34[];
+
+    if (func_8012C354(a0, (s32)D_801ADC00) != 0) {
+        *(u8 *)(a0 + 0xC0) = 1;
+        *(s32 *)(a0 + 0xB4) = -0x4012;
+        *(s32 *)(a0 + 0xC4) = 1;
+        *(s32 *)(a0 + 0x6C) = func_80143994(a0, 0x4000);
+        func_8012A828(a0, (s32)D_801B0434);
+        *(u16 *)(a0 + 0x2) = *(u16 *)(a0 + 0x2) + 1;
+        func_8012B200((u8 *)a0);
+        *(s32 *)(a0 + 0xBC) = (s32)D_801ADC34;
+        *(s16 *)(a0 + 0xAE) = -1;
+        *(u8 *)(a0 + 0x75) = 2;
+    }
+}
+
 
 void func_801832D8(s32 *a0) {
     *(s16*)((s32)a0 + 0x2) = 0x2;
@@ -7265,7 +7485,22 @@ INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018334
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801833BC);
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801834E4);
+extern s32 func_8012B744(void *a0, void *a1);
+extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
+
+void func_801834E4(s32 a0)
+{
+    u32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),
+                          func_8012B744((void *)(a0 + 4), (void *)(a0 + 0x88)), 8);
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) & 0xFFF;
+    if (d + 0x1F < 0x3F) {
+        *(s16 *)(a0 + 0x2) = 8;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80183564);
 
@@ -7994,7 +8229,34 @@ void func_801844F8(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80184634);
+void func_80184634(s32 a0) {
+    extern u8 D_801B598C[];
+    extern u8 D_801B5AA8[];
+    extern u8 D_801BE3DC[];
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern void func_8012A828(s32, s32);
+    extern void func_80143994(s32 a0, s32 a1);
+    extern void func_8012B2CC(s32 a0);
+    extern s32 rand(void);
+    s32 r1;
+    s32 r2;
+
+    if (func_8012C354(a0, (s32)D_801B598C) != 0) {
+        *(u8 *)(a0 + 0xC0) = 1;
+        *(s32 *)(a0 + 0xBC) = (s32)D_801B5AA8;
+        *(s32 *)(a0 + 0xB4) = -1;
+        func_8012A828(a0, (s32)D_801BE3DC);
+        func_80143994(a0, 0x2000);
+        *(s16 *)(a0 + 0x2) = 3;
+        r1 = rand();
+        *(s32 *)(a0 + 0xEC) = r1;
+        r2 = rand();
+        *(s32 *)(a0 + 0xF0) = (r2 % 0x20) + 0x10;
+        *(s32 *)(a0 + 0xF4) = 2;
+        func_8012B2CC(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801846E4);
 
@@ -8291,7 +8553,16 @@ tail_short:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80184E38);
+extern void func_8012B23C(s32 a0);
+extern void func_8012A828(s32, s32);
+extern u8 D_801BEBAC[];
+
+void func_80184E38(s32 a0) {
+    func_8012B23C(a0);
+    func_8012A828(a0, (s32)&D_801BEBAC);
+    *(s16 *)(a0 + 0x2) = 0xA;
+}
+
 
 extern void func_8012CBCC(s32 a0);
     void func_80184E78(s32 arg0) {
@@ -8361,7 +8632,34 @@ void func_80184F70(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80184FA8);
+void func_80184FA8(s32 a0)
+{
+    extern s32 func_80029DB4(void);
+    extern s32 func_801855A0(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+    extern void func_8012A828(s32, s32);
+    extern void func_8012B23C(s32 a0);
+    extern s32 func_80185914(s32 a0);
+    extern u8 D_801B59D0[];
+    extern s16 D_801BE3DC;
+    extern s32 D_8011F730;
+
+    func_801855A0(a0, D_801B59D0, 7, func_80029DB4());
+    if (*(s32 *)(a0 + 0x94) < 9) {
+        func_8012C658(0x1EB, 0, a0);
+    }
+    if (D_8011F730 == 3) {
+        *(u16 *)(a0 + 2) = 0xD;
+    } else {
+        if (*(u16 *)(a0 + 0x72) & 0x4000) {
+            func_8012A828(a0, &D_801BE3DC);
+            *(u16 *)(a0 + 2) = 2;
+            func_8012B23C(a0);
+            func_80185914(a0);
+        }
+    }
+}
+
 
 
 extern void func_8012A828(s32 arg0, s32 arg1);
@@ -8373,7 +8671,35 @@ void func_80185060(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80185098);
+extern void func_8012A828(s32, s32);
+extern s32 func_80029E30(void);
+extern s32 func_801855A0(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012B23C(s32 a0);
+extern s32 func_80185914(s32 a0);
+
+void func_80185098(s32 a0) {
+    extern s32 D_8011F730;
+    extern u8 D_801B59F0[];
+    extern u8 D_801BE3DC[];
+
+    s32 v0;
+
+    v0 = func_80029E30();
+    func_801855A0(a0, (s32)D_801B59F0, 6, v0);
+    if ((u32)(*(s32 *)(a0 + 0x94) - 4) < 10u) {
+        func_8012C658(0x1EB, 1, a0);
+    }
+    if (*(u16 *)(a0 + 0x72) & 0x4000) {
+        if (D_8011F730 != 4) {
+            ((void (*)(s32, void *))func_8012A828)(a0, D_801BE3DC);
+            *(s16 *)(a0 + 0x2) = 2;
+            func_8012B23C(a0);
+            func_80185914(a0);
+        }
+    }
+}
+
 
 
 extern void func_8012A828(s32 a0, s32 a1);
@@ -8461,7 +8787,16 @@ void func_80185178(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80185368);
+extern void func_8012A828(s32, s32);
+extern void func_8012B23C(s32 a0);
+extern s32 D_801BED14;
+
+void func_80185368(s32 a0) {
+    *(s16 *)(a0 + 2) = 0x14;
+    func_8012A828(a0, (s32)&D_801BED14);
+    func_8012B23C(a0);
+}
+
 
 extern s32 D_801BE3DC;
 extern s32 func_80185914(s32 a0);
@@ -8480,7 +8815,7 @@ void func_801853A8(s32 a0) {
 }
 
 
-extern void func_80185448(s32 *a0);
+extern void func_80185448();
 extern void func_8012A828(s32, s32);
 extern M2C_UNK D_801BE3DC;
 
@@ -8491,9 +8826,32 @@ void func_8018540C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_80185448);
+extern u8 D_801B80B0[];
+void func_80185448(s32 a0) {
+    if (*(s32 *)(a0 + 0xE0) & 1) {
+        func_8001C924(*(s32 *)(a0 + 0x20), D_801B80B0);
+        if (*(s32 *)(a0 + 0xCC) != 0) {
+            func_8012C218(*(void **)(a0 + 0xCC));
+            *(s32 *)(a0 + 0xCC) = 0;
+        }
+        *(s32 *)(a0 + 0xE0) &= ~3;
+    }
+    func_8018552C(a0);
+}
+
+
+void func_801854C8(void *arg0) {
+    u16 sp18;
+    if (*(s32 *)((u8 *)arg0 + 0xC4) & 4) {
+        *(s16 *)((u8 *)arg0 + 2) = 0x13;
+    } else {
+        *(s16 *)((u8 *)arg0 + 2) = 1;
+    }
+    sp18 = *(u16 *)(*(s32 *)((u8 *)arg0 + 0x78) + 2);
+    *(s32 *)((u8 *)arg0 + 0xE0) = 0;
+    *(s16 *)((u8 *)arg0 + 0x5C) = sp18;
+}
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801854C8);
 
 extern void func_8002A04C(s32 a0);
     extern void func_8012C098(void);
@@ -8503,7 +8861,22 @@ extern void func_8002A04C(s32 a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018552C);
+void func_8018552C(s32 a0) {
+    extern u8 D_801B59D0[];
+    extern u8 D_801B59F0[];
+    extern void func_8018676C(s32 a0, void *a1, s32 a2);
+    extern void func_801869D4(s32 a0, s32 a1, s32 a2);
+
+    if (*(s32 *)(a0 + 0xF4) != 0) {
+        *(s32 *)(a0 + 0xF4) = *(s32 *)(a0 + 0xF4) - 1;
+    } else {
+        if (!(*(s32 *)(a0 + 0xE0) & 1)) {
+            func_8018676C(a0, D_801B59D0, 7);
+        }
+        func_801869D4(a0, (s32)D_801B59F0, 6);
+    }
+}
+
 
 
 /* Local twin used as the shape reference: func_801862F0 (this very TU, already MATCHED,
@@ -9642,7 +10015,23 @@ INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018725
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801872E0);
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801873C4);
+s32 func_801873C4(s16 *a0, s16 *a1, s32 a2) {
+    s32 d;
+
+    d = a1[1] - a0[3];
+    if (d < 0) {
+        d = -d;
+    }
+    if ((u16)a2 < d) {
+        return 0;
+    }
+    d = a1[5] - a0[7];
+    if (d < 0) {
+        d = -d;
+    }
+    return (u16)a2 >= d;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_8018741C);
 
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 2ab59bc509..18b3cfb6d3 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
@@ -4529,11 +4529,54 @@ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180AB
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180B24);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180E80);
+extern void func_80183564(s32 a0, s16 *a1);
+extern s32 func_80186710(void);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern u16 D_801EFD20;
+extern u16 D_801EFD40;
+extern s32 aFC4C[] __asm__("D_801EFC4C");
+extern u8 D_80194490[];
+
+void func_80180E80(u8 *self) {
+    s32 obj;
+    s32 vp1;
+    s32 vp2;
+
+    obj = aFC4C[D_801EFD20];
+    vp1 = *(s32 *)(obj + 0x20);
+    *(s16 *)(obj + 6) = 0x640;
+    *(s16 *)(obj + 0xA) = -0x980;
+    *(s16 *)(obj + 0xE) = 0x240;
+    *(s16 *)(vp1 + 0x12) = 0x600;
+    vp2 = *(s32 *)(obj + 0x20);
+    *(s16 *)(vp2 + 0x10) = 0;
+    *(s16 *)(self + 0xFE) = 0;
+    func_80186710();
+    *(s16 *)(self + 0xF4) = 0;
+    *(s16 *)(self + 0xF2) = 0;
+    func_80183564((s32)self, (s16 *)D_80194490);
+    D_801EFD40 = D_801EFD40 & 0xFDFF;
+    func_8012AD44((s32 *)self, 4);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80180F30);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801811D0);
+void func_801811D0(s32 *arg0) {
+    extern s16 D_801944A8[];
+    extern void func_8018332C(s32 a0, s32 a1);
+    extern void func_80183BD0(u8 *a0);
+    extern void func_80186BD8(void);
+    extern void func_8012AD44(s32 *a0, s16 a1);
+
+    *(s16 *)((s32)arg0 + 0xF4) = 0;
+    func_8018332C((s32)arg0, (s32)&D_801944A8);
+    func_80183BD0((u8 *)arg0);
+    *(u16 *)((s32)arg0 + 0xF2) = 0;
+    func_80186BD8();
+    func_8012AD44(arg0, 5);
+}
+
 
 #include "common.h"
 
@@ -5640,7 +5683,39 @@ default_case:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_801837C4);
+void func_801837C4(s32 a0, s32 a1) {
+    extern u16 D_801EFD40;
+    extern s32 aFC4C[] __asm__("D_801EFC4C");
+    extern u16 D_801EFD20;
+    extern void func_801863D4(void);
+    extern void func_801863B4(s32 a0);
+    extern void func_80184ABC(u16 a0);
+    s32 v0;
+    s32 s1;
+
+    v0 = D_801EFD40;
+    s1 = aFC4C[0];
+    D_801EFD20 = 0;
+    v0 |= 0x4;
+    D_801EFD40 = (u16)v0;
+
+    if (v0 & 0x10) {
+        func_801863D4();
+        func_801863B4(a0);
+    }
+
+    func_80184ABC(D_801EFD20);
+
+    v0 = *(u16 *)(*(s32 *)(s1 + 0x20) + 0x10);
+    *(u16 *)(a0 + 0x102) = 0;
+    *(u16 *)(a0 + 0x104) = 0;
+    *(u16 *)(a0 + 0xFE) = (u16)v0;
+
+    v0 = *(u16 *)(*(s32 *)(s1 + 0x20) + 0x12);
+    *(u16 *)(*(s32 *)(s1 + 0x20) + 0x12) = v0 & 0xFFF;
+    *(u16 *)(a0 + 0x106) = *(u16 *)(*(s32 *)(s1 + 0x20) + 0x12);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183880);
 
@@ -5695,7 +5770,14 @@ s32 func_80183A28(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80183BAC);
+extern u16 D_801EFD40;
+
+void func_80183BAC(u8 *a0) {
+    u16 v = D_801EFD40;
+    *(s16 *)(a0 + 0x104) = -0x20;
+    D_801EFD40 = v | 0x40;
+}
+
 
 extern u16 D_801EFD40;
 
@@ -5981,7 +6063,33 @@ clear_bit:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80184504);
+extern s32 D_801EFC54;
+extern void func_80186940(void *a0, s32 a1, s32 a2);
+
+void func_80184504(void *arg0)
+{
+    s32 tbl;
+    s16 diff;
+
+    tbl = D_801EFC54;
+    *(u8 *)((s32)arg0 + 0xC1) = 1;
+    *(s32 *)((s32)arg0 + 0x1C) = 4;
+    *(u16 *)((s32)arg0 + 0x5C) &= ~1;
+    diff = *(s16 *)((s32)arg0 + 0x76);
+    if (diff != 0) {
+        diff = diff - *(u16 *)((s32)arg0 + 0x60);
+        *(s16 *)((s32)arg0 + 0x76) = diff;
+        if (diff < 0) {
+            *(s16 *)((s32)arg0 + 0x76) = 0;
+        }
+        *(s16 *)(*(s32 *)(tbl + 0x20) + 0x18) =
+        *(s16 *)(*(s32 *)(tbl + 0x20) + 0x1A) =
+        *(s16 *)(*(s32 *)(tbl + 0x20) + 0x1C) =
+            0x1000 - (0x240 - *(s16 *)((s32)arg0 + 0x76)) * 3;
+    }
+    func_80186940(arg0, *(s16 *)((s32)arg0 + 0x60), 1);
+}
+
 
 #include "common.h"
 
@@ -6749,7 +6857,32 @@ void func_80185DDC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80185F1C);
+extern s32 D_801EFC64[];
+
+void func_80185F1C(void) {
+    s32 i = 6;
+    s32 h = 0x1000;
+    s32 c = 0xC;
+    s32 w = 0x10;
+    s32 x = 0x80;
+    s32 *p = D_801EFC64;
+
+    for (; i < 21; i++, p++) {
+        s32 *rec = (s32 *)*p;
+        *(s16 *)((s8 *)*(s32 *)((s8 *)rec + 0x20) + 0x18) = h;
+        *(s16 *)((s8 *)*(s32 *)((s8 *)rec + 0x20) + 0x1A) = h;
+        if (i < 13) {
+            u16 f = *(u16 *)((s8 *)rec + 0x86);
+            *(s16 *)((s8 *)rec + 0x84) = (c - i) * 4;
+            *(s16 *)((s8 *)rec + 0xFE) = w;
+            *(s16 *)((s8 *)rec + 0x100) = x;
+            *(u16 *)((s8 *)rec + 0x86) = f | 3;
+        } else {
+            *(u16 *)((s8 *)rec + 0x86) &= ~1;
+        }
+    }
+}
+
 
 extern u8 D_80194724[];
 extern s32 D_801EFC4C;
@@ -6975,7 +7108,29 @@ void func_801866C4(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186710);
+#include "common.h"
+
+extern u16 D_801EFD20;
+/* §183: the TU spells D_801EFC4C as a scalar elsewhere; reach the array view
+   through an __asm__ label alias -- the TU's own established idiom. */
+extern s32 aFC4C[] __asm__("D_801EFC4C");
+extern void func_80186798(s32 a0, void *a1);
+extern void func_8018681C(s32 a0, void *a1);
+
+s32 func_80186710(void) {
+    u16 buf[3];
+    register s32 s0 __asm__("$16");
+    s32 obj;
+
+    s0 = D_801EFD20;
+    obj = aFC4C[s0];
+    buf[0] = *(u16 *)(*(s32 *)(obj + 0x20) + 0x10);
+    buf[1] = *(u16 *)(*(s32 *)(obj + 0x20) + 0x12);
+    buf[2] = *(u16 *)(*(s32 *)(obj + 0x20) + 0x14);
+    func_80186798(s0, buf);
+    func_8018681C(s0, buf);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186798);
 
@@ -7266,7 +7421,23 @@ void func_80186F44(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80187008);
+extern u16 D_801EFD20;
+extern u16 D_801EFD40;
+extern void func_801805F8(s32 arg0);
+extern void func_801852BC(s32 a0);
+extern void func_801853D0(s32 a0);
+extern void func_80185648(s32 a0);
+
+void func_80187008(s32 arg0) {
+    s32 g = D_801EFD20;
+    func_801805F8(arg0);
+    if (D_801EFD40 & 4) {
+        func_801852BC(g);
+        func_801853D0(g);
+        func_80185648(g);
+    }
+}
+
 
 #include "common.h"
 
@@ -8295,7 +8466,31 @@ void func_801888B8(u8 *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80188A30);
+void func_80188A30(s32 a0) {
+    extern u16 D_80194814;
+    extern u16 D_80194816;
+    extern u16 D_801F161E;
+    extern s16 D_80126B98;
+    s16 in[3];
+    s16 out[3];
+
+    in[1] = 0;
+    in[0] = 0;
+    out[1] = 0;
+    out[0] = 0;
+    in[2] = D_80194814;
+    out[2] = D_80194816;
+    if (func_8012DEB8((s32)a0, (s32)in, (s32)out) != 0) {
+        __asm__("" ::: "memory");
+        D_80126B98 = 0x18;
+        if (*(s16 *)((s32)a0 + 0x106) == 0) {
+            u16 cnt = D_801F161E;
+            *(s16 *)((s32)a0 + 0x106) = 1;
+            D_801F161E = cnt + 1;
+        }
+    }
+}
+
 
 extern s32 func_80132EF4(s32 a0, s32 a1);
 extern int func_8018AD3C(s16 *param_1, s32 *param_2, s32 param_3);
@@ -9022,7 +9217,22 @@ void func_80189FDC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018A018);
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018A074);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8018A0E0(s32 arg0);
+
+void func_8018A074(s32 arg0) {
+    s32 i;
+    s32 var;
+
+    for (i = 0; i < 4; i++) {
+        var = func_8012C658(0x256, i, arg0);
+        if (var != 0) {
+            func_8012C658(0x256, i + 4, var);
+        }
+    }
+    func_8018A0E0(arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018A0E0);
 
@@ -11331,7 +11541,22 @@ void func_8018D5D8(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018D66C);
+#include "common.h"
+
+extern u8 D_80194D4C[];
+extern void func_8012BEE8(u8*);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+void func_8018D66C(s32 a0) {
+    s32 s0 = a0;
+
+    if (((s32 (*)(s32))func_8012BEE8)((s32)s0) != 0) {
+        func_8002D4C8(*(u16 *)(D_80194D4C + *(s16 *)(s0 + 0xFC) * 8), 0);
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_8018D6C4);
 
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c b/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
index 6d545aab5b..b009ab43c1 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
@@ -4824,9 +4824,35 @@ extern void func_80178CBC(s32 a0, s32 a1);
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017E8A4);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017E8FC);
+extern s32 func_80029504(void);
+
+void func_8017E8FC(void) {
+    extern s16 D_80191110[];
+    extern s32 D_80191270;
+    extern s32 D_801E7AAC;
+
+    if (func_80029504() < 0x2BC) {
+        *(s32 *)(D_801E7AAC + 4) = (s32)D_80191110;
+    } else {
+        *(s32 *)(D_801E7AAC + 4) = (s32)&D_80191270;
+    }
+}
+
+
+extern s32 func_8012E544(s32 a0);
+extern s32 func_80029504(void);
+extern void func_80029514(s32);
+
+void func_8017E950(void) {
+    s32 v1 = func_8012E544(0x22B);
+    if (v1 != 0) {
+        *(s16 *)(v1 + 0x34) = 1;
+    }
+    if (func_80029504() < 0x2BC) {
+        func_80029514(0x2BC);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017E950);
 
 extern void func_8012C588(s32, s32);
 void func_8017E99C(void) {
@@ -4850,7 +4876,28 @@ void func_8017E9C0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017EA0C);
+extern s32 func_80184BAC(s32 arg0, s32 arg1);
+extern s32 func_80184BD0(u8 a0, u8 a1, u8 a2, u8 a3);
+extern void func_80184CB8(s32*, s32);
+extern void func_8017E5CC(void *arg0);
+
+void func_8017EA0C(void *arg0) {
+    extern short D_80191074;
+    s32 v1;
+
+    v1 = *(s32 *)((char *)arg0 + 0xCC);
+    *(s32 *)((char *)v1 + 0xB0) = 2;
+    if (func_80184BAC(8, 0x14) == 0) {
+        *(short *)((char *)arg0 + 0x2) = 1;
+        func_80184CB8((s32 *)arg0, (s32)&D_80191074);
+    }
+    if (func_80184BD0(10, 0, 10, 30) == 0 && func_80184BD0(15, 0, 15, 30) == 0) {
+        return;
+    }
+    *(u8 *)((char *)arg0 + 0x105) = *(u16 *)((char *)arg0 + 0x2);
+    func_8017E5CC(arg0);
+}
+
 
 
 extern int func_80178970(void);
@@ -4868,7 +4915,35 @@ void func_8017EAAC(void * arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017EAFC);
+extern s32 func_80029504(void);
+extern void func_8012CAE4(void *a0);
+extern s32 func_801847BC(void *a0, void *a1);
+extern s32 func_80184BAC(s32 arg0, s32 arg1);
+extern void func_80184CB8(s32*, s32);
+extern s32 func_801788B8(s32 arg0, s32 arg1);
+extern s16 D_8019107C;
+extern s16 D_80191074;
+extern void func_8017EDA4(void);
+
+void func_8017EAFC(void *a0) {
+    s32 v0;
+    void *v1;
+
+    if (func_80029504() < 0x2A8) {
+        func_8012CAE4(a0);
+    } else {
+        v0 = func_801847BC(a0, &D_8019107C);
+        if (v0 != 0) {
+            v0 = func_80184BAC(8, 0x14);
+            *(s16 *)((char *)a0 + 0x2) = (v0 != 0) ? 2 : 1;
+            func_80184CB8((s32 *)a0, (s32)&D_80191074);
+            v1 = *(void **)((char *)a0 + 0x68);
+            *(s16 *)((char *)v1 + 0xC) = 0x7FFF;
+            *(s32 *)((char *)a0 + 0xD4) = func_801788B8((s32)a0, (s32)&func_8017EDA4);
+        }
+    }
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern s32 func_8012BEE8(s32 a0);
@@ -4930,7 +5005,11 @@ s32 func_8017F0C0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F0D8);
+void func_8017F0D8(void) {
+    func_80029124(0x10C, 1);
+    func_80029124(0x10D, 0);
+}
+
 
 extern void func_80029124(s32 arg0, s32 arg1);
     void func_8017F108(void) {
@@ -4939,7 +5018,18 @@ extern void func_80029124(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F138);
+extern s32 D_801E7AAC;
+
+void func_8017F138(void) {
+    extern s32 D_801E79A0;
+
+    if (D_801E79A0 == 1) {
+        *(s32 *)(D_801E7AAC + 4) = D_801E7AAC + 8;
+    } else {
+        *(s32 *)(D_801E7AAC + 4) = D_801E7AAC + 0x18;
+    }
+}
+
 
 DEFINE_func_8017F174()  /* dedup: shared engine-core @0x8017F174 (src/shared) */
 
@@ -4969,7 +5059,31 @@ void func_8017F28C(void * arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F2DC);
+extern s32 func_801847BC(void *a0, void *a1);
+extern s32 func_80184BAC(s32 arg0, s32 arg1);
+extern void func_80184CB8(s32*, s32);
+extern s32 func_801788B8(s32 arg0, s32 arg1);
+extern void (*D_801912E0)(void *);
+extern short D_801912D8;
+extern void func_8017F35C(void *);
+
+void func_8017F2DC(void *a0) {
+    s32 v0;
+    void *v1;
+
+    if (func_801847BC(a0, &D_801912E0) != 0) {
+        if (func_80184BAC(8, 0x14) != 0) {
+            *(s16 *)((char *)a0 + 0x2) = 2;
+        } else {
+            *(s16 *)((char *)a0 + 0x2) = 1;
+        }
+        func_80184CB8((s32 *)a0, (s32)&D_801912D8);
+        v1 = *(void **)((char *)a0 + 0x68);
+        *(s16 *)((char *)v1 + 0xC) = 0x7FFF;
+        *(s32 *)((char *)a0 + 0xD4) = func_801788B8((s32)a0, (s32)&func_8017F35C);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F35C);
 
@@ -4977,7 +5091,17 @@ INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F41
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F500);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F564);
+void func_8017F564(void *a0) {
+    extern short D_80191578;
+    extern short D_801B9950;
+    s32 s0 = (s32)a0;
+    *(u16 *)((s32)a0 + 2) = 8;
+    func_8012E8E0((s32)a0, (s32)&D_80191578);
+    func_8012E88C((s32)a0);
+    func_80184C90((s32)a0);
+    func_8012A828((s32 *)a0, (s32)&D_801B9950);
+}
+
 
 
 extern void (*D_801916E4[])(void);
@@ -5190,7 +5314,7 @@ DEFINE_func_8017FAAC()  /* dedup: shared engine-core @0x8017FAAC (src/shared) */
 extern s32 func_80184FA4(void);
 extern s32 func_80185BE0(s32 arg0);
 extern u8 D_801E3978[];
-extern void func_8017F564(s32 a0);
+extern void func_8017F564();
 extern void func_80184ED4(s32, s32, s32, s32);
 
 void func_8017FB0C(void *a0)
@@ -5262,7 +5386,27 @@ void func_8017FBB0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017FC58);
+extern s32 func_80184BD0(u8 a0, u8 a1, u8 a2, u8 a3);
+extern void func_8012E88C(s32);
+extern void func_8012A828(s32 *a0, s32 a1);
+extern void func_80184C90(s32);
+extern void func_80184ED4(s32, s32, s32, s32);
+extern u8 D_801E3978[];
+
+void func_8017FC58(void *arg0) {
+
+    extern short D_801B99A8;
+    if (func_80184BD0(0xB, 0, 0xE, 0xF) != 0) {
+        return;
+    }
+    *(short *)((char *)arg0 + 0x2) = 0xB;
+    *(short *)((char *)arg0 + 0x34) = 0;
+    func_8012E88C((s32)arg0);
+    func_8012A828((s32 *)arg0, (s32)&D_801B99A8);
+    func_80184C90((s32)arg0);
+    func_80184ED4((s32)arg0, (s32)D_801E3978, 1, 0x60);
+}
+
 
 
 extern int func_80178970(void);
@@ -5296,10 +5440,81 @@ void func_8017FF34(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017FF70);
+extern s32 D_80126B9C;
+extern s32 D_80191744;
+extern s32 D_8019171C;
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern void func_80029514(s32);
+extern void func_80184CB8(s32*, s32);
+
+void func_8017FF70(void *a0) {
+    u16 v1;
+
+    v1 = *(u16 *)((s32)a0 + 0x34);
+    switch (v1) {
+        case 0:
+            if ((D_80126B9C & 0x8000000) != 0) {
+                *(u16 *)((s32)a0 + 0x34) = 1;
+                func_80178B18((s32)a0, (s32)&D_80191744);
+            }
+            break;
+        case 1:
+            if (((s32 (*)(s32))func_80178970)((s32)a0) != 0) {
+                ((void (*)(s32))func_80178D18)((s32)a0);
+                func_80029514(0x2B2);
+                *(u16 *)((s32)a0 + 0x34) = 2;
+                ((void (*)(s32, s32))func_80184CB8)((s32)a0, (s32)&D_8019171C);
+            }
+            break;
+        case 2:
+            break;
+    }
+}
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8018001C);
+
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern void func_8012E88C(s32 a0);
+extern void func_8012A828(s32 *a0, s32 a1);
+extern void func_80184C90(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012CAE4(void *a0);
+extern void func_8012C1B8(void);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_80029504(void);
+
+void func_8018001C(void *arg0) {
+    extern short D_801C7A90;
+    extern s32 D_8019171C;
+    extern short D_801B9B50;
+    s32 t;
+    s32 v;
+    s32 v1;
+
+    t = func_80029504();
+    if ((u32)(t - 0x2A8) >= 10) {
+        func_8012CAE4(arg0);
+        return;
+    }
+    v = ((s32 (*)())func_8012C1B8)();
+    *(s32 *)((s32)arg0 + 0x20) = v;
+    if (v == 0) {
+        func_8012CAE4(arg0);
+    }
+    func_8001C214(*(s32 *)((s32)arg0 + 0x20), (s32)&D_801C7A90);
+    func_80184C90((s32)arg0);
+    v1 = *(s32 *)((s32)arg0 + 0x68);
+    *(short *)((s32)arg0 + 0x2) = 1;
+    *(short *)((s32)arg0 + 0x34) = 0;
+    *(short *)(v1 + 0xC) = 0x7FFF;
+    func_8012E8E0((s32)arg0, (s32)&(*(short *)&D_8019171C));
+    func_8012B2CC((s32)arg0);
+    func_8012E88C((s32)arg0);
+    func_8012A828((s32 *)arg0, (s32)&D_801B9B50);
+}
+
 
 DEFINE_func_801800E0()  /* dedup: shared engine-core @0x801800E0 (src/shared) */
 
@@ -5424,11 +5639,46 @@ void func_80180580(void *arg0) {
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801805C0);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80180618);
+void func_80180618(void *arg0) {
+    extern short D_801B65C8;
+    extern s32 func_80184FA4(void);
+    extern s32 func_80184BAC(s32 arg0, s32 arg1);
+    extern void func_8018042C(s32 a0);
+    extern void func_80184ED4(s32, s32, s32, s32);
+
+    if (func_80184FA4() != 0) {
+        if (func_80184BAC(9, 0x11) == 0) {
+            func_8018042C(arg0);
+        } else {
+            func_80184ED4((s32)arg0, (s32)&D_801B65C8, 0, 0x40);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8018067C);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801806CC);
+extern void func_80185F54(void *, s32, s32);
+extern s32 func_80185BE0(s32);
+extern s32 func_80184FA4(void);
+extern void func_80184CB8(s32 *, s32);
+extern void func_80185FB8(s32, s32, s32);
+
+void func_801806CC(void *arg0) {
+    extern short D_801918F4;
+
+    func_80185F54(arg0, 0xC, 1);
+    if (func_80185BE0(0xC) == 0) {
+        return;
+    }
+    if (((s32 (*)(s32))func_80184FA4)((s32)arg0) == 0) {
+        return;
+    }
+    *(u16 *)((char *)arg0 + 2) = 1;
+    func_80184CB8((s32 *)arg0, (s32)&D_801918F4);
+    func_80185FB8((s32)arg0, 0xC, 1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80180740);
 
@@ -5673,7 +5923,25 @@ void func_80181020(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80181090);
+void func_80181090(void *arg0) {
+    extern short D_801B6614;
+    extern s32 func_80184FA4(void);
+    extern void func_80184ED4(s32, s32, s32, s32);
+    extern s32 func_80185BE0(s32);
+    extern void func_801809DC(short*);
+    if (*(u16 *)((s32)arg0 + 0x34) == 0) {
+        if (((s32 (*)(void))func_80184FA4)() != 0) {
+            func_80184ED4((s32)arg0, (s32)&D_801B6614, 1, 0x40);
+            *(s16 *)((s32)arg0 + 0x34) = 1;
+            *(s32 *)((s32)arg0 + 0x1C) = 0x20;
+        }
+    } else if (func_80185BE0(6) != 0) {
+        if (((s32 (*)(s32))func_80184FA4)((s32)arg0) != 0) {
+            ((void (*)(void *))func_801809DC)(arg0);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80181124);
 
@@ -5782,7 +6050,22 @@ DEFINE_func_801815DC()  /* dedup: shared engine-core @0x801815DC (src/shared) */
 
 DEFINE_func_80181648()  /* dedup: shared engine-core @0x80181648 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801816A8);
+extern void func_8012E88C(s32);
+extern void func_8012A828(s32 *a0, s32 a1);
+extern void func_80184C90(s32);
+extern void func_80184ED4(s32, s32, s32, s32);
+
+void func_801816A8(void *arg0) {
+    extern short D_801B99A8;
+    extern u8 D_801B6638[];
+    *(short *)((char *)arg0 + 0x2) = 6;
+    func_8012E88C((s32)arg0);
+    func_8012A828((s32 *)arg0, (s32)&D_801B99A8);
+    func_80184C90((s32)arg0);
+    *(short *)((char *)arg0 + 0x34) = 0;
+    func_80184ED4((s32)arg0, (s32)&D_801B6638, 1, 0x80);
+}
+
 
 
 extern void func_80184CB8(s32*, s32);
@@ -6076,7 +6359,29 @@ extern void func_80178CBC(s32 a0, s32 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801824BC);
+extern s32 func_80184DD0(s32 a0);
+extern s32 func_80029504(void);
+extern s32 D_80191C2C[];
+extern s32 D_801E24BC[];
+extern s32 D_801E2428[];
+
+void func_801824BC(s32 a0) {
+    s32 s1;
+    s32 v1;
+
+    s1 = func_80184DD0(a0);
+    v1 = func_80029504();
+    if (s1 == 2) {
+        if (v1 < 0x276) {
+            *(s32 *)(a0 + 0xE4) = (s32)D_801E24BC;
+        } else {
+            *(s32 *)(a0 + 0xE4) = (s32)D_801E2428;
+        }
+    } else {
+        *(s32 *)(a0 + 0xE4) = D_80191C2C[s1];
+    }
+}
+
 
 
 extern void func_80172710(void);
@@ -6491,7 +6796,50 @@ void func_80182F88(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80183024);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801830F4);
+extern s32 func_8012BD14(s32 a0);
+extern s32 func_8012E544(s32 a0);
+extern s32 func_80178BF8();
+extern void func_80172710(void);
+
+s32 func_801830F4(void *a0)
+{
+    s32 ptr;
+    u16 st;
+    s32 cur;
+    s32 other;
+
+    ptr = *(s32 *)((s32)a0 + 0x64);
+    st = *(u16 *)((s32)ptr + 0x2);
+    if (st != 3) {
+        return 0;
+    }
+
+    cur = func_8012BD14(ptr);
+    if (cur >= 0x4001) {
+        return 0;
+    }
+
+    other = func_8012E544(0x227);
+    if (other != 0) {
+        if (*(u16 *)((s32)other + 0x2) == 8) {
+            if (func_8012BD14(other) < cur) {
+                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;
+}
+
 
 extern void func_80184CB8(s32 *a0, s32 a1);
     extern short D_80192030;
@@ -6803,7 +7151,43 @@ void func_80183C78(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80183CBC);
+extern s32 func_801847BC(void *a0, void *a1);
+extern s32 func_80184BAC(s32 arg0, s32 arg1);
+extern void func_8012E88C(s32 a0);
+extern void func_8012A828(s32 *a0, s32 a1);
+extern void func_80184C90(s32 a0);
+extern void func_80184ED4(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_80184CB8(s32 *a0, s32 a1);
+extern s32 func_80183D80(void *a0);
+extern s32 func_801788B8(s32 arg0, s32 arg1);
+
+void func_80183CBC(void *arg0) {
+
+    extern s32 D_80192160;
+    extern s32 D_801B9C50;
+    extern s32 D_801B67DC;
+    extern s16 D_80192150;
+    void *s0 = arg0;
+    void *v1;
+
+    if (func_801847BC(arg0, &D_80192160) != 0) {
+        if (func_80184BAC(9, 0x11) != 0) {
+            *(short *)((char *)s0 + 0x2) = 3;
+            func_8012E88C((s32)s0);
+            func_8012A828((s32 *)s0, (s32)&D_801B9C50);
+            func_80184C90((s32)s0);
+            func_80184ED4((s32)s0, (s32)&D_801B67DC, 0, 0x40);
+        } else {
+            *(short *)((char *)s0 + 0x2) = 1;
+            func_80184CB8((s32 *)s0, (s32)&D_80192150);
+        }
+
+        v1 = *(void **)((char *)s0 + 0x68);
+        *(short *)((char *)v1 + 0xC) = 0x7FFF;
+        *(s32 *)((char *)s0 + 0xD4) = func_801788B8((s32)s0, (s32)&func_80183D80);
+    }
+}
+
 
 
 extern s32 func_8012BD14(s32 a0);
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c b/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
index 6b28980d1b..145b3c4bae 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
@@ -2802,7 +2802,7 @@ extern void func_8017FAAC(void *a0);
 extern s32 func_80184FA4(void);
 extern s32 func_80185BE0(s32 arg0);
 extern u8 D_801E3978[];
-extern void func_8017F564(s32 a0);
+extern void func_8017F564();
 extern void func_80184ED4(s32, s32, s32, s32);
 extern void func_8017FB0C(void *a0);
 extern void func_8017FCD8(void * arg0);
diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
index e9b48b772c..8dce8f0b3e 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
@@ -3246,7 +3246,16 @@ s32 func_8017E810(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017E818);
+extern s32 D_80126B9C;
+
+s32 func_8017E818(void *a0)
+{
+    D_80126B9C |= 0x4000000;
+    *(s32 *)((s32)a0 + 0x28) = 0xA;
+    *(u8 *)((s32)a0 + 0x15) += 1;
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017E84C);
 
@@ -3354,9 +3363,54 @@ void func_8017EB48(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EB84);
+extern void func_8017FED0(void);
+extern void func_8014706C(void *arg0);
+extern void func_8014708C(void *arg0);
+extern s32 func_801472C8(struct S *a0);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017EB84(void *a0) {
+    func_8017FED0();
+    func_8014706C(a0);
+    func_8014708C(a0);
+    func_801472C8(a0);
+    *(s32 *)((u8 *)a0 + 0x200) = 100;
+    *(s16 *)((u8 *)a0 + 0x20C) = 1;
+    *(s16 *)((u8 *)a0 + 0x20E) = 0;
+    func_8017F818(a0, *(s16 *)((u8 *)a0 + 0x20C), *(s32 *)((u8 *)a0 + 0x200), 0);
+    *(s32 *)((u8 *)a0 + 0x204) = 60;
+    func_80171990((u8 *)a0);
+}
+
+
+extern s32 D_801151D4;
+extern s32 func_80171990(u8 *);
+
+void func_8017EBFC(void *a0) {
+    s32 ptr;
+    s16 val;
+    s32 cnt;
+    ptr = D_801151D4;
+    val = *(u16 *)(ptr + 0x22) + 4;
+    *(s16 *)(ptr + 0x22) = val;
+    *(s16 *)(ptr + 0x1A) = val;
+    cnt = *(s32 *)((u8 *)a0 + 0x204) - 1;
+    *(s32 *)((u8 *)a0 + 0x204) = cnt;
+    if (cnt == -1) {
+        *(s32 *)((u8 *)a0 + 0x204) = 0x3C;
+        *(s16 *)(ptr + 0x22) = 0x600;
+        *(s16 *)(ptr + 0x1A) = 0x600;
+        *(s32 *)(ptr + 0x14) = 0x384;
+        *(s32 *)(ptr + 0x10) = 0x384;
+        *(s16 *)(ptr + 0x2E) = 0x40;
+        *(s16 *)(ptr + 0x28) = 0x40;
+        *(s16 *)(ptr + 0x30) = -0x100;
+        *(s16 *)(ptr + 0x2A) = -0x100;
+        ((void (*)(void *))func_80171990)(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EBFC);
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EC80);
 
@@ -3388,7 +3442,12 @@ void func_8017F038(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F060);
+extern s32 D_801151D4;
+
+void func_8017F060(void) {
+    (*(s32 *)((s32)D_801151D4 + 0x14)) -= 8;
+}
+
 
 
 extern void (*D_8018A8C0[])(void);
@@ -3402,7 +3461,32 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F0B
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F120);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F188);
+extern void func_8017F818(void *, s32, s32, s32);
+extern void func_8017F990(s32, s32);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_80171990(u8*);
+
+void func_8017F188(s32 a0)
+{
+    s32 temp;
+
+    func_8017F818((void *)a0, *(s16 *)((u8 *)a0 + 0x20C), *(s32 *)((u8 *)a0 + 0x200), 0);
+    func_8017F990(a0, 0);
+
+    temp = *(s32 *)((u8 *)a0 + 0x204) - 0x4000;
+    *(s32 *)((u8 *)a0 + 0x204) = temp;
+    if (temp <= 0xFFFF) {
+        *(s32 *)((u8 *)a0 + 0x204) = 0x10000;
+    }
+
+    *(s32 *)((u8 *)a0 + 0x200) += *(s16 *)((u8 *)a0 + 0x206);
+    if (*(s32 *)((u8 *)a0 + 0x200) >= 0x316) {
+        func_8002D4C8(0xBE5, 0);
+        *(s32 *)((u8 *)a0 + 0x200) = 0x1E;
+        func_80171990((u8 *)a0);
+    }
+}
+
 
 extern s32 func_80171990(u8*);
 void func_8017F220(void *a0) {
@@ -3414,7 +3498,20 @@ void func_8017F220(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F254);
+void func_8017F254(s32 a0) {
+    extern void func_8017F2BC(void *a0);
+    extern u8 D_8018A8D4[];
+    extern void func_8017FB8C(void);
+    s32 s0 = a0;
+    func_8017F2BC(a0);
+    func_80147060((u8 *)s0);
+    func_80147084((s32 *)s0);
+    func_801472B4((void *)s0);
+    func_80172310(D_8018A8D4);
+    func_8012A568(func_8017FB8C);
+    func_80171928((void *)s0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F2BC);
 
@@ -3438,11 +3535,53 @@ void func_8017F3A8(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F3E8);
+extern s32 func_801399F0(s32);
+extern void func_80139914(s32 a0);
+extern void func_80142454(s32 a0);
+extern void func_80171A80(s32 *a0, s32 a1);
+extern s32 func_80171990(u8 *a0);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F448);
+void func_8017F3E8(void *a0) {
+    if (func_801399F0(*(s32 *)((u8 *)a0 + 0x198)) != 0) {
+        func_80139914(*(s32 *)((u8 *)a0 + 0x198));
+        ((void (*)(s32))func_80142454)(-0x80);
+        ((void (*)(void *, s32))func_80171A80)(a0, 0x1E);
+        ((void (*)(void *))func_80171990)(a0);
+    }
+    return;
+}
+
+
+extern void func_80154274(s32 *a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+extern s32 func_80171990(u8 *a0);
+extern u8 D_800D599C[];
+extern s32 func_80171A88(s32 a0);
+extern void func_8014706C(void *arg0);
+extern u8 D_801E3224;
+
+void func_8017F448(s32 a0) {
+    if (func_80171A88(a0) != 0) {
+        func_8014706C((void *)a0);
+        func_80154274((s32 *)a0, D_800D599C);
+        *(s32 *)(a0 + 0x198) = func_8013767C(&D_801E3224);
+        func_80171990((u8 *)a0);
+    }
+}
+
+
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_80171928(void *a0);
+
+void func_8017F4AC(s32 a0) {
+    s32 s0 = a0;
+    if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(s0 + 0x198));
+        func_80171928((void *)s0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F4AC);
 
 extern void func_80181A0C(void);
     extern void func_80171928(void *a0);
@@ -3476,11 +3615,38 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F60
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F648);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F6C8);
+extern s32 func_80171990(u8*);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F990();
+
+void func_8017F6C8(void *a0) {
+    s32 v0;
+
+    v0 = *(s32 *)((u8 *)a0 + 0x204) + 0x4000;
+    *(s32 *)((u8 *)a0 + 0x204) = v0;
+    if (v0 > 0xA0000) {
+        *(s32 *)((u8 *)a0 + 0x204) = 0xA0000;
+    }
+    *(s32 *)((u8 *)a0 + 0x200) -= *(s16 *)((u8 *)a0 + 0x206);
+    v0 = *(s32 *)((u8 *)a0 + 0x200);
+    if (v0 < 0x259) {
+        ((void (*)(void *))func_80171990)(a0);
+    }
+    func_8017F818(a0, *(s16 *)((u8 *)a0 + 0x20C), *(s32 *)((u8 *)a0 + 0x200), 0);
+    func_8017F990(a0, 0x800);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F754);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017F7BC);
+extern u8 D_800AE6BD;
+extern void func_80171928(void *);
+
+void func_8017F7BC(void) {
+    D_800AE6BD++;
+    ((void (*)(void))func_80171928)();
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 extern M2C_UNK D_8018A8F0;
@@ -3573,7 +3739,37 @@ void func_8017FA20(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017FAE4);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017FF9C(u8*);
+
+void func_8017FAE4(void) {
+
+    extern u8  D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+
+    D_80126954 = 0x12C;
+    D_8012695C = 0x384;
+    D_80126968 = 0x38;
+    D_8012696A = 0x900;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017FF9C, 1);
+    func_8012A094((s32)D_80126948);
+    ((void (*)(void *))func_8017FF9C)(D_80126948);
+    func_8012A094((s32)D_80126948);
+    ((void (*)(void *))func_8017FF9C)(D_80126948);
+}
+
 
 extern void func_8012A018(s32 a, s32 b);
 extern void func_8012A094(s32 a0);
@@ -3620,7 +3816,33 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017FC7
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017FD94);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017FE44);
+void func_8017FE44(void)
+{
+    extern void func_80129FF4(void);
+    extern s32 D_80126950;
+    extern s32 D_80126984;
+    extern s32 D_80126988;
+    extern s32 D_8012698C;
+    extern s32 D_80126990;
+    extern s32 D_80126994;
+    extern s32 D_80126998;
+    extern s16 D_8018A938;
+    extern s16 D_8018A93A;
+    extern s16 D_8018A93C;
+    extern s16 D_8018A940;
+    extern s16 D_8018A942;
+    extern s16 D_8018A944;
+
+    D_80126950 = 0x12C;
+    D_80126984 = D_8018A938;
+    D_80126988 = D_8018A93A;
+    D_8012698C = D_8018A93C;
+    D_80126990 = D_8018A940;
+    D_80126994 = D_8018A942;
+    D_80126998 = D_8018A944;
+    func_80129FF4();
+}
+
 
 extern void func_8012A018(s32 a, s32 b);
 extern void func_8012A094(s32 a0);
@@ -3666,12 +3888,31 @@ void func_8017FF9C(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017FFD8);
+extern void func_801800E0(void *a0, u8 *a1);
+extern void func_80180220(s32 arg0, s32 arg1);
+extern s16 D_80126940;
+
+void func_8017FFD8(void *arg0) {
+    func_801800E0(arg0, (u8 *) ((s32) arg0 + 0xA0));
+    func_80180220((s32) arg0, (s32) &D_80126940);
+}
+
 
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80180014);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018003C);
+
+
+void func_8018003C(void *a0) {
+    extern s16 D_80126940;
+    extern s32 D_801274E8;
+    if (*(s16 *)((s32)a0 + 0x9E) != 0) {
+        (*(Blk8 *)&D_801274E8) = (*(Blk8 *)&D_80126940);
+        *(s16 *)((s32)a0 + 0x9E) = *(u16 *)((s32)a0 + 0x9E) - 1;
+    }
+    func_80180220((s32)a0, (s32)&(*(Blk8 *)&D_801274E8));
+}
+
 
 extern void func_80180220(s32 arg0, s32 arg1);
 extern s32 D_801274E8;
@@ -3796,15 +4037,56 @@ void func_80180220(s32 arg0, s32 arg1)
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80180408);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801805E0);
+extern s32 func_8012E544(s32 arg);
+extern void func_80029514(s32);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern int func_800D0CA0(int);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_801805E0(void)
+{
+    s32 v1;
+
+    v1 = func_8012E544(0x2C6);
+    if (v1 != 0) {
+        *(u16 *)(v1 + 0x34) += 1;
+        *(s32 *)(v1 + 0x1C) = 0;
+        func_80029514(0x492);
+        func_8012C658(0x3BE, 0, 0);
+        func_800D0CA0(1);
+        func_8002D4C8(0xBDF, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80180644);
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018069C);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801807E8);
+void func_801807E8(void *arg0) {
+    extern void (*D_8018A97C[])(void);
+    extern unsigned short D_801E6508;
+    D_8018A97C[*(u16 *)((s32)arg0 + 0x2)]();
+    D_801E6508++;
+}
+
+
+extern void (*D_8018A98C)(void);
+extern u8 D_8018A994;
+extern void *D_8018A99C;
+extern void func_80180ACC(s32, s32, s32, s32);
+extern s32 func_800133E4(s16 *, s16 *);
+extern u8 D_80126B5C;
+extern void func_8012F568(s32, s32, s32, s32, void *, u8 *);
+
+void func_8018083C(s32 a0) {
+    s32 r;
+    func_80180ACC(a0, 1, &D_8018A98C, &r);
+    if (func_800133E4((s16 *)&r, (s16 *)&D_80126B5C) < 0x4000) {
+        func_8012F568(1, 0x4001, 0, 0x1E, &D_8018A99C, &D_8018A994);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018083C);
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801808AC);
 
@@ -3867,7 +4149,17 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801810B
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181204);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018124C);
+void func_8018124C(void) {
+    u16 buf[4];
+    extern s32 D_801E660C;
+    extern void func_800599B8(u16 *);
+    buf[0] = 0x160;
+    buf[1] = 0x140;
+    buf[2] = 0x10;
+    buf[3] = 0x1;
+    ((void (*)(u16 *, u16 *))func_800599B8)(buf, (u16 *)&D_801E660C);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181294);
 
@@ -3884,7 +4176,33 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018132
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801813E8);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181474);
+void func_80181474(s32 *a0) {
+    extern void func_801808AC(void *a0);
+    extern void func_8018083C(s32);
+    extern void func_801812FC(void);
+    extern void func_8012E8E0(s32 a0, s32 a1);
+    extern u16 D_8018A960[];
+    extern s32 D_801BBAB8[];
+    extern s32 D_801C29C4[];
+    u16 v;
+
+    *(s32 *)((s32)a0 + 0x1C) = *(s32 *)((s32)a0 + 0x1C) + 1;
+    func_801808AC(a0);
+    ((void (*)(void *))func_8018083C)(a0);
+    if (*(u16 *)((s32)a0 + 0x72) & 0x4000) {
+        *(u16 *)((s32)a0 + 0x2) = 1;
+        func_8012E8E0((s32)a0, (s32)D_8018A960);
+        v = *(u16 *)((s32)a0 + 0xFC) ^ 1;
+        *(u16 *)((s32)a0 + 0xFC) = v;
+        if (v != 0) {
+            ((void (*)(s32, s32))func_801812FC)((s32)a0, (s32)D_801BBAB8);
+        } else {
+            ((void (*)(s32, s32))func_801812FC)((s32)a0, (s32)D_801C29C4);
+        }
+        *(s32 *)((s32)a0 + 0x1C) = 0;
+    }
+}
+
 
 void func_80181518(void) {
 }
@@ -4055,13 +4373,75 @@ s32 func_80181B80(void *a0)
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181BF4);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181CC4);
+void func_80181CC4(void *arg0) {
+    extern void func_80178CBC(s32, s32);
+    extern s32 func_80178970();
+    extern void func_80178D18();
+    extern void func_8012E8E0(s32, s32);
+    extern void func_8012E88C(s32);
+    extern void func_8012A828();
+    extern void func_80184674(s32);
+    extern short D_8018AC14;
+    extern short D_8018AB38;
+    extern short D_801CC330;
+
+    switch (*(u16 *)((s32)arg0 + 0x34)) {
+    case 0:
+        break;
+    case 1:
+        func_80178CBC((s32)arg0, (s32)&D_8018AC14);
+        *(u16 *)((s32)arg0 + 0x34) = *(u16 *)((s32)arg0 + 0x34) + 1;
+        break;
+    case 2:
+        if (((s32 (*)(s32))func_80178970)((s32)arg0) != 0) {
+            ((void (*)(s32))func_80178D18)((s32)arg0);
+            *(short *)((char *)arg0 + 0x2) = 2;
+            *(short *)((char *)arg0 + 0x34) = 0;
+            ((void (*)(s32, s32))func_8012E8E0)((s32)arg0, (s32)&D_8018AB38);
+            func_8012E88C((s32)arg0);
+            ((void (*)(s32 *, s32))func_8012A828)((s32 *)arg0, (s32)&D_801CC330);
+            func_80184674((s32)arg0);
+        }
+        break;
+    }
+}
+
+
+extern s32 D_801E6748;
+extern s32 func_800D0CE0(void);
+
+s32 func_80181D88(void)
+{
+    if (D_801E6748 != 0 && func_800D0CE0() == 1) {
+        return 1;
+    }
+    return 0;
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181D88);
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181DCC);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181E78);
+extern s32 func_80029504(void);
+extern u8 D_80078EAE;
+
+s32 func_80181E78(void) {
+    s32 v1 = func_80029504();
+
+    if ((u32)(v1 - 0x460) < 0x32) {
+        return 0x89;
+    }
+    if ((u32)(v1 - 0x384) < 0x6E) {
+        return 0x65;
+    }
+    if ((u32)(v1 - 0x64) < 0x1E) {
+        return 0x28;
+    }
+    if (D_80078EAE == 1) {
+        return 0xF;
+    }
+    return 0x10;
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80181EEC);
 
@@ -4105,7 +4485,19 @@ void func_80182290(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801822CC);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80182304);
+extern void func_80184590(s32, s32);
+
+void func_80182304(void *arg0) {
+    *(s32 *)(*(s32 *)((s32)arg0 + 0xCC) + 0xB0) = 2;
+    if (func_80184828() != 1) {
+        if (func_801845B4(5, 0, 5, 0x1E) != 0) {
+            func_8018208C(arg0);
+        } else if (((s32 (*)(s32, s32))func_80184590)(7, 0x15) != 0) {
+            func_80182048(arg0);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80182384);
 
@@ -4126,7 +4518,29 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801825C
 void func_80182694(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018269C);
+extern s32 func_800291B4(s32 arg);
+extern void func_800291A0(s32 a0, s32 a1);
+extern void func_80178CBC(s32 a0, s32 a1);
+extern s16 D_8018B00C[];
+extern u8 D_8018AFC0[];
+extern u8 D_8018B084[];
+
+void func_8018269C(void *a0) {
+    void *tbl;
+    if ((func_800291B4(0x40) & 0xFF) == 1) {
+        func_800291A0(0x40, 2);
+    }
+    if (*(s16 *)((char *)a0 + 0x10A) == 0) {
+        *(s16 *)((char *)a0 + 0x10A) = 1;
+        tbl = D_8018B00C;
+        *(s32 *)((char *)a0 + 0x58) = (u32)D_8018AFC0 | 0x40000000;
+    } else {
+        tbl = D_8018B084;
+    }
+    func_80178CBC((s32)a0, (s32)tbl);
+    *(u16 *)((char *)a0 + 2) += 1;
+}
+
 
 
 extern int func_80178970(void);
@@ -4157,7 +4571,30 @@ extern s32 func_8012AD50(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80182844);
+typedef struct { u8 b[8]; } Blk8_80182844;
+
+extern Blk8_80182844 D_801E4F60;
+extern Blk8_80182844 D_801E4F68;
+extern void func_80015978(s32 a0, s32 *a1);
+extern void func_8018290C();
+
+void func_80182844(void *a0)
+{
+    Blk8_80182844 blk1;
+    Blk8_80182844 blk2;
+    Blk8_80182844 out;
+
+    blk1 = D_801E4F60;
+    blk2 = D_801E4F68;
+    if (*(s16 *)((s32)a0 + 0xFC) == 0) {
+        func_8018290C(&blk1, &blk2);
+    } else {
+        func_80015978((s32)a0 + 4, (s32 *)&out);
+        func_8018290C(&blk1, &out);
+        func_8018290C(&out, &blk2);
+    }
+}
+
 
 
 /* identical layout to SVECTOR_8016E7C8 (src/shared/engine_types.h) */
@@ -4271,7 +4708,24 @@ void func_80182E74(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80182F04);
+struct vec;
+
+void func_80182F04(s32 *a0)
+{
+    extern void func_801292C8(u8 *a0);
+    extern void func_8012931C(struct vec *a0);
+    s32 p;
+
+    p = *(s32 *)((s32)a0 + 0x20);
+    if (--*(s16 *)((s32)a0 + 0x2C) == -1) {
+        func_801292C8((u8 *)a0);
+        return;
+    }
+    func_8012931C((struct vec *)a0);
+    *(u8 *)((s32)p + 0x24) = *(u8 *)((s32)p + 0x25) = *(u8 *)((s32)p + 0x26) =
+        *(u8 *)((s32)p + 0x26) - 2;
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80182F78);
 
@@ -4715,9 +5169,43 @@ void func_8018399C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801839D8);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32, s32);
+extern void func_8012E8E0(s32 a0, s32 a1);
+
+void func_801839D8(s32 a0) {
+
+    extern s32 D_801A1060;
+    extern s32 D_801A1070;
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+    } else {
+        func_8001C214(v0, 0);
+        func_8012E8E0(a0, (s32)&D_801A1060);
+        *(s32 *)(a0 + 0x58) = (s32)&D_801A1070 | 0x40000000;
+        *(s16 *)(a0 + 0x5C) = 0xC00;
+        *(s8 *)(a0 + 0x75) = 8;
+        *(u16 *)(a0 + 2) += 1;
+    }
+}
+
+
+extern s32 func_80029504(void);
+extern void func_8012C218(void *arg0);
+extern u16 D_801A1080[];
+
+void func_80183A64(s32 a0) {
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = D_801A1080[*(s16 *)(a0 + 0x70)];
+    if (!((u32)func_80029504() < 0x492)) {
+        func_8012C218((void *)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80183A64);
 
 
 extern s32 func_80029504(void);
@@ -4731,7 +5219,42 @@ void func_80183ABC(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80183AF8);
+extern s32 func_80029504(void);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32, s32);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_80183AF8(void *a0) {
+
+    extern s32 D_801A13E0;
+    extern s32 D_801A1060;
+
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((char *)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(v0, (s32)&D_801A13E0);
+    func_8012E8E0((s32)a0, (s32)&D_801A1060);
+    func_80183ABC();
+
+    if (!((u32)func_80029504() < 0x492)) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8012C658(0x3BF, 0, (s32)a0);
+    *(s16 *)((char *)a0 + 0x2) = 1;
+    *(s16 *)((char *)a0 + 0x34) = 0;
+    *(s32 *)((char *)a0 + 0x1C) = 0;
+}
+
 
 extern s32 D_801A10E4;
 extern s32 D_801A1164;
@@ -4849,7 +5372,32 @@ void func_80183DF0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80183E2C);
+extern s32 D_801A0DBC;
+extern s32 D_801A0E38;
+extern s32 D_801A0ED8;
+
+void func_80183E2C(s32 a0)
+{
+    s32 s0;
+
+    s0 = (u8)func_800291B4(0xDC);
+    func_80029124(0xDE, 1);
+    if (s0 == 0) {
+        *(s32 *)(a0 + 0xE4) = (s32)&D_801A0DBC;
+    } else {
+        if (s0 & 1) {
+            *(s32 *)(a0 + 0xE4) = (s32)&D_801A0E38;
+        } else {
+            *(s32 *)(a0 + 0xE4) = (s32)&D_801A0ED8;
+        }
+    }
+    s0 = s0 + 1;
+    if ((s0 & 0xFF) == 0) {
+        s0 = 2;
+    }
+    func_800291A0(0xDC, s0 & 0xFF);
+}
+
 
 
 
@@ -4914,7 +5462,21 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8018401
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_801840A0);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_80184118);
+void func_80184118(void *a0) {
+
+    extern s32 D_801A10D4;
+    extern s32 D_801A10B0;
+
+    if (func_80184988(a0) != 0) {
+        *(short *)((char *)a0 + 0x2) = 1;
+        *(short *)((char *)a0 + 0x98) = 0;
+        func_8012E8A8((u8 *)a0);
+        func_8012E8E0((s32)a0, (s32)&D_801A10B0);
+        *(s32 *)((char *)a0 + 0x58) = (s32)&D_801A10D4 | 0x40000000;
+        *(short *)((char *)a0 + 0x5C) = 0;
+    }
+}
+
 
 
 void func_80184180(void *a0) {
diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c b/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
index fe3ec569e2..33efcf931c 100644
--- a/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
+++ b/src/ov_SC06_006/ov_SC06_006_jr_8017BEBC.c
@@ -3204,7 +3204,24 @@ void func_8017CE40(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017CE7C);
+extern s32 D_80126B58;
+extern void func_8014706C(void *arg0);
+extern void func_8014708C(void *arg0);
+extern s32 func_801472C8();
+
+s32 func_8017CE7C(void *a0) {
+    s32 *base = &D_80126B58;
+    register s32 b __asm__("$2");
+    func_8014706C(base);
+    func_8014708C(base);
+    func_801472C8((void *)base);
+    b = *(u8 *)((s32)a0 + 0x15);
+    b += 1;
+    *(u8 *)((s32)a0 + 0x15) = b;
+    *(s32 *)((s32)a0 + 0x28) = 10;
+    return 0;
+}
+
 
 
 extern void func_8002D4C8(s32 a0, s32 a1);
@@ -3236,7 +3253,21 @@ void func_8017CF7C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017CFB8);
+extern s32 D_801F8070;
+extern void func_8014706C(void *arg0);
+extern void func_8014708C(void *arg0);
+extern s32 func_801472C8(struct S *a0);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017CFB8(void *arg0)
+{
+    D_801F8070 = 0;
+    func_8014706C(arg0);
+    func_8014708C(arg0);
+    func_801472C8(arg0);
+    func_80171990(arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D000);
 
@@ -3412,13 +3443,31 @@ extern void func_801800B8(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D600);
+extern void func_801800B8(void *a0);
+extern void func_8017D04C(s32 a0);
+extern s16 D_80185BEC;
+extern s16 D_801F8094;
+
+void func_8017D600(u8 *a0) {
+    *(s16 *)(a0 + 0x2) = 0xA;
+    func_801800B8(&D_80185BEC);
+    D_801F8094 = D_801F8094 + 1;
+    func_8017D04C(1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D650);
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D688);
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D6D0);
+extern void func_801800B8(void *a0);
+extern s16 D_80185C98;
+
+void func_8017D6D0(s16 *a0) {
+    *(s16 *)((char *)a0 + 0x2) = 0xD;
+    func_801800B8(&D_80185C98);
+}
+
 
 extern void func_801800B8(void *a0);
     extern s16 D_80185CE4;
@@ -3516,7 +3565,16 @@ extern void func_801800B8(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017D974);
+extern u8 D_80185DE8[];
+extern void func_801800B8(void *a0);
+extern void func_8017F2A0(void);
+
+void func_8017D974(u8 *a0) {
+    *(s16 *)(a0 + 0x2) = 0x11;
+    func_801800B8(&D_80185DE8);
+    func_8017F2A0();
+}
+
 
 extern s32 D_80185E14;
 extern void func_801800B8(void*);
@@ -3635,7 +3693,10 @@ void func_8017DD64(void *obj) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017DFA4);
+s32 func_8017DFA4(s32 arg0, s32 arg1, s32 arg2, s32 arg3) {
+    return (arg1 - arg0) * arg3 / arg2 + arg0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017DFEC);
 
@@ -3713,7 +3774,7 @@ extern Pose_8017E330 D_801F8428[];
 
 extern void func_8012E88C(u8 *a0);
 extern void func_8012E8A8(u8 *a0);
-extern void func_8017F824(void *a0, s32 a1);
+extern void func_8017F824();
 
 void func_8017E330(Actor_8017E330 *a0) {
     Work_8017E330 v;            /* sp+0x10 */
@@ -4148,7 +4209,23 @@ void func_8017F074(void *arg0)
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F258);
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F2A0);
+void func_8017F2A0(void) {
+    extern u8 D_801F85EC[];
+    s32 i;
+    u8 *p;
+
+    i = 0;
+    p = D_801F85EC;
+    do {
+        if (*(void **)(p + 8) != NULL) {
+            func_80016714(*(void **)(p + 8), 0x38);
+        }
+        func_80016714(p, 0x54);
+        i++;
+        p += 0x54;
+    } while (i < 12);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F308);
 
@@ -4223,11 +4300,54 @@ void func_8017F5D0(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F7C4);
+extern void func_80015D4C();
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F824);
+void func_8017F7C4(s32 arg0) {
+    func_80015D4C(
+        *(s16 *)(arg0 + 0),
+        *(s16 *)(arg0 + 2),
+        *(s16 *)(arg0 + 4),
+        *(s16 *)(arg0 + 6),
+        *(u8 *)(arg0 + 8),
+        *(u8 *)(arg0 + 9),
+        *(u8 *)(arg0 + 0xA),
+        *(u16 *)(arg0 + 0xC),
+        4);
+}
+
+
+extern u8 D_800AF648;
+void func_8017F824(s32 a0, s32 a1) {
+    s16 arr[3];
+    func_8012F14C((s32)&D_800AF648, a0, (s32)arr);
+    arr[0] = (s16)((arr[0] * a1) >> 12);
+    arr[1] = (s16)((arr[1] * a1) >> 12);
+    arr[2] = (s16)((arr[2] * a1) >> 12);
+    func_8012F038((s32)&D_800AF648, arr, a0);
+}
+
+
+extern void *D_801F8118;
+extern s16 D_800B9AAC[];
+extern s16 D_800B9B00;
+extern s16 D_800B9AB8[];
+extern void (*D_80186368)(void);
+
+void func_8017F8CC(void) {
+    s16 t;
+
+    if (*(u16 *)((u8 *)D_801F8118 + 2) == 0x11) {
+        D_800B9AAC[0] = 0x7FFF;
+        t = 0xFFE;
+    } else {
+        D_800B9AAC[0] = 0xFFE;
+        t = 0x7FFF;
+    }
+    D_800B9B00 = t;
+    __asm__ __volatile__("");
+    *(u16 *)D_800B9AB8 += (s32)D_80186368;
+}
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F8CC);
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017F934);
 
@@ -4266,7 +4386,18 @@ void func_8017FD4C(s32 param_1, s16 *param_2, s16 *param_3, void *param_4) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017FECC);
+extern s32 D_801F8084;
+extern s32 D_801863A8;
+extern u16 D_801863A4;
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017FECC(s32 a0)
+{
+    if (D_801F8084 == *(s32 *)(&D_801863A8 + a0 * 5)) {
+        func_8002D4C8(*(u16 *)(&D_801863A4 + a0 * 10), 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8017FF24);
 
@@ -4372,11 +4503,38 @@ void func_801800B8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_801802A0);
+void func_801802A0(s32 arg0, s32 arg1, s32 arg2, s32 arg3)
+{
+    s32 count = 0;
+
+    ((s32 *)arg0)[0x24] = (s32)arg1;
+    ((s32 *)arg0)[0x25] = 0;
+    ((s16 *)arg0)[0x4D] = arg2;
+    ((s32 *)arg0)[0x27] = arg3;
+    ((s16 *)arg0)[0x4C] = 0;
+
+    while (*(s16 *)(arg1 + 4) > 0) {
+        arg1 += 8;
+        count++;
+    }
+    ((s16 *)arg0)[0x7E] = count;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_801802E0);
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8018034C);
+extern void func_80180390(void);
+extern s32 D_801F8084;
+extern s32 D_801F808C;
+
+s32 func_8018034C(void) {
+    if (D_801F8084 >= D_801F808C) {
+        func_80180390();
+        return 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180390);
 
@@ -4435,7 +4593,23 @@ extern s32 func_8018034C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180644);
+extern s16 D_801F8094;
+extern void func_80180390(void);
+extern s16 D_801F8098;
+extern s32 D_801F8084;
+extern s32 D_801F808C;
+extern void func_801800B8(void *a0);
+extern s16 D_80185BEC;
+
+void func_80180644(void *a0) {
+    if (D_801F8094 == D_801F8098) {
+        func_80180390();
+    } else if (D_801F8084 >= D_801F808C) {
+        *(s16 *)((char *)a0 + 0x2) = 0xA;
+        func_801800B8(&D_80185BEC);
+    }
+}
+
 
 extern s32 func_8018034C(void);
 void func_801806B4(void) {
@@ -4463,7 +4637,42 @@ INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_801807E
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180840);
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_801808C0);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_80029124(s32 a0, s32 a1);
+extern void func_8017FF24(void);
+extern void func_8017FFA8(void);
+extern void func_8017F2A0(void);
+extern void func_801803F4(s32 a0);
+extern void *D_801F8118;
+
+void func_801808C0(s32 arg0)
+{
+    register s32 param_1 __asm__("$16");   /* $s0 */
+    s32 obj;
+
+    param_1 = arg0;
+    obj = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(param_1 + 0x20) = obj;
+    if (obj == 0) {
+        ((void (*)(s32))func_8012CAE4)(param_1);
+        return;
+    }
+    func_8001C214(obj, 0);
+    func_80029124(0x143, 1);
+    func_80029124(0x6F, 0);
+    func_80029124(0x70, 0);
+    func_80029124(0x71, 0);
+    func_80029124(0x72, 0);
+    func_80029124(0x73, 0);
+    D_801F8118 = (void *)param_1;
+    func_8017FF24();
+    func_8017FFA8();
+    func_8017F2A0();
+    func_801803F4(param_1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_8018097C);
 
@@ -4471,9 +4680,22 @@ INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180A4
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180AE8);
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180BF8);
+extern void (*D_801860A4[])(void);
+
+void func_80180BF8(void *a0) {
+    D_801860A4[*(s16 *)((s32)a0 + 2)]();
+}
+
+
+extern s32 D_801860B8[];
+
+void func_80180C34(s32 arg0) {
+    *(u16 *)(arg0 + 4) = 0;
+    *(u16 *)(arg0 + 6) = 0;
+    *(u16 *)(arg0 + 2) += 1;
+    *(s32 *)(arg0 + 0x50) = D_801860B8[*(s16 *)(arg0 + 0x4C) * 5];
+}
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180C34);
 
 INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180C6C);
 
@@ -4568,7 +4790,17 @@ void func_80180E4C(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8017BEBC", func_80180E68);
+extern void func_80180EFC(void*);
+void func_80180E68(s32 a0, s32 a1) {
+    extern s32 D_8012697C;
+    extern u16 D_80126980;
+    extern s32 D_801F89E0;
+    D_8012697C = a0;
+    D_801F89E0 = a1;
+    D_80126980 = 0;
+    func_8012A018((s32)func_80180EFC, 0);
+}
+
 
 s32 func_80180EA8(void) {
     /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
index 5d6ac4dc80..77f30c0d35 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
@@ -3471,9 +3471,41 @@ void func_8017DEC4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017DF24);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017DFFC);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern void func_8012A828(s32 *a0, s32 a1);
+
+void func_8017DFFC(void *a0) {
+    extern u8 D_801889AC[];
+    extern void (*D_801889EC[])(void);
+
+    if (func_8012C354((s32)a0, (s32)D_801889AC) != 0) {
+        func_8001D0E8(*(s32 *)((s32)a0 + 0x20), 0xC8, 0x168);
+        *(u8 *)((s32)a0 + 0xC0) = 1;
+        *(s32 *)((s32)a0 + 0xB4) = -1;
+        *(s16 *)((s32)a0 + 0xAE) = -1;
+        *(u16 *)((s32)a0 + 0x2) = 1;
+        *(u8 *)((s32)a0 + 0x75) = 0;
+        func_8012A828((s32 *)a0, (s32)D_801889EC);
+    }
+}
+
+
+extern void (*D_80188974)(void);
+
+void func_8017E074(s32 a0)
+{
+    s32 v0;
+    v0 = func_8012BE54(a0);
+    if (v0 < 0x6401) {
+        v0 = func_80181B50();
+        if (v0 == 1) {
+            func_80178B18(a0, (s32)&D_80188974);
+            *(s16 *)(a0 + 2) = 2;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E074);
 
 
 extern int func_80178970(void);
@@ -3645,7 +3677,19 @@ void func_8017E9CC(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EAE4);
+extern void func_8017EEFC(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern s32 D_80194FFC[];
+extern s16 D_8019F708;
+
+void func_8017EAE4(s32 arg0) {
+    s32 r;
+    func_8017EEFC(arg0, 0xE, 0, (s32)D_80194FFC);
+    r = D_8019F708;
+    *(s32 *)(arg0 + 0x1C) = 0x18;
+    func_8012C658(0x2FF, r - 1, arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EB3C);
 
@@ -3657,11 +3701,74 @@ void func_8017EB8C(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EBB8);
+extern u8 D_80196974;
+extern s32 D_80188BFC;
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EC50);
+void func_8017EBB8(void *a0)
+{
+    s32 s0 = (s32)a0;
+    s32 v0 = 0x800;
+    func_8002A04C(s0);
+    func_8017EEFC(s0, 0x10, 0, (s32)&D_80196974);
+    *(s32 *)(s0 + 0x1C) = 0;
+    *(s16 *)(s0 + 0x34) = 0;
+    *(s16 *)(s0 + 0x5E) = 0;
+    *(s8 *)(s0 + 0xC1) = 0;
+    *(s16 *)(s0 + 0x76) = 0;
+    *(s16 *)(s0 + 0x5C) = v0;
+    func_8002D4C8(0xA96, 0);
+    func_80029514(0x578);
+    func_800D0C48(1);
+    func_80178BF8();
+    func_801746A4();
+    func_80178CBC(s0, (s32)&D_80188BFC);
+}
+
+
+extern void (*D_80188CF4[])(void);
+extern void func_8017EE78();
+extern s16 D_8019F720;
+
+void func_8017EC50(void *a0) {
+    D_80188CF4[*(u16 *)((s32)a0 + 0x2)]();
+    if (*(u16 *)a0 != 0) {
+        if (*(s32 *)((s32)a0 + 0xDC) == 1) {
+            func_8017EE78();
+            if (D_8019F720 != 0) {
+                D_8019F720 = D_8019F720 - 1;
+            }
+        }
+    }
+}
+
+
+void func_8017ECE0(s32 arg0) {
+    s32 sp1C;
+    s32 i;
+    s32 var_s0;
+    s32 a;
+    s32 b;
+    s32 tmp;
+
+    for (i = 0; i < 8; i++) {
+        sp1C = func_80132EF4(arg0, 0x22);
+        if (sp1C == 0) {
+            break;
+        }
+        tmp = *(s32 *)(sp1C + 0x20);
+        if (tmp != 0) {
+            *(u16 *)(tmp + 0x2C) = 0xC040;
+        }
+        var_s0 = i * 0x200;
+        a = func_8004787C(var_s0);
+        b = func_80047948(var_s0);
+        *(u16 *)(sp1C + 0x34) = 0x2001;
+        *(s32 *)(sp1C + 0x14) = -0x80000;
+        *(s32 *)(sp1C + 4) += a * 0x200;
+        *(s32 *)(sp1C + 0xC) += b * 0x200;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017ECE0);
 
 void func_8017EDA0(s32 arg0) {
     s32 sp1C;
@@ -3960,7 +4067,16 @@ void func_8017F578(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017F5B4);
+void func_8017F5B4(int a0, int a1)
+{
+    int v0;
+    v0 = func_80132EF4(a0, 0x62);
+    if (v0 != 0) {
+        *(int *)(v0 + 0x34) = a0;
+        *(int *)(v0 + 0x30) = a1;
+    }
+}
+
 
 
 extern void func_8004914C(void *a0);
@@ -4312,7 +4428,41 @@ void func_801803BC(short *a0, short *a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801803FC);
+#include "common.h"
+
+/* func_801803FC — set bit31 of ->0x04 on the four part pointers (global array
+ * D_8019FA00[4]) and on the two tail pointers D_8019FAD0/D_8019FAD4.
+ * The 0x80000000 invariant is hoisted into a register before the loop ($a2);
+ * the two straight-line tails each rematerialize their own lui, which the
+ * scheduler parks in the beqz delay slot. */
+
+extern void *D_8019FA00[4];
+extern void *D_8019FAD0;
+extern void *D_8019FAD4;
+
+void func_801803FC(void)
+{
+    s32 i;
+    void *p;
+
+    for (i = 0; i < 4; i++) {
+        p = D_8019FA00[i];
+        if (p != NULL) {
+            *(s32 *)((s32)p + 0x4) = *(s32 *)((s32)p + 0x4) | 0x80000000;
+        }
+    }
+
+    p = D_8019FAD0;
+    if (p != NULL) {
+        *(s32 *)((s32)p + 0x4) = *(s32 *)((s32)p + 0x4) | 0x80000000;
+    }
+
+    p = D_8019FAD4;
+    if (p != NULL) {
+        *(s32 *)((s32)p + 0x4) = *(s32 *)((s32)p + 0x4) | 0x80000000;
+    }
+}
+
 
 #include "common.h"
 
@@ -5133,7 +5283,21 @@ extern s32 func_8012BEE8(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181D7C);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8017E4FC(s32 a0);
+
+void func_80181D7C(s32 arg0) {
+    s32 s0 = arg0;
+
+    if (func_8012BEE8(s0) == 0) {
+        return;
+    }
+
+    func_8002D4C8(4, 0x97F);
+    func_8017E4FC(s0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181DBC);
 
@@ -5196,19 +5360,85 @@ END:;
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181FB0);
+extern void func_8017ECE0(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8017EAE4(s32 a0);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182008);
+void func_80181FB0(s32 arg0) {
+    register s32 s0 __asm__("$16");
+
+    s0 = arg0;
+    if ((*(s32 *)(s0 + 0x1C) & 3) == 2) {
+        func_8017ECE0(s0);
+    }
+    if (func_8012BEE8(s0)) {
+        func_8017EAE4(s0);
+    }
+}
+
+
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8017EB3C(s32 a0);
+
+void func_80182008(s32 arg0) {
+    s32 s0 = arg0;
+
+    if (*(s32 *)(s0 + 0x1C) == 0xA) {
+        func_8002D4C8(0xA93, 0);
+    }
+    if (func_8012BEE8(s0) != 0) {
+        func_8017EB3C(s0);
+    }
+}
+
+
+extern s16 D_8019F714;
+extern s16 D_8019F708;
+extern s16 D_8019F70C;
+extern s32 D_80194FFC[];
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern void func_8017EEFC(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
+
+void func_8018205C(void *a0) {
+    s16 v = D_8019F714 - 1;
+    D_8019F714 = v;
+    if (v <= 0) {
+        D_8019F70C = 0;
+        D_8019F708 = D_8019F708 + 1;
+        func_8017EEFC((s32)a0, 10, 0, (s32)&D_80194FFC);
+        *(s32 *)((s32)a0 + 0x1C) = 0x18;
+        func_8012C588(0x2FD, (s32)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8018205C);
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801820E0);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801821B8);
+extern u16 D_80188BB4;
+
+void func_801821B8(void *arg0) {
+    D_80188BB4 = *(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801821D4);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182224);
+extern void func_80015D4C(s32 a0, s32 a1, s32 a2, s32 a3, u8 a4, u8 a5, u8 a6, u16 a7, u16 a8);
+void func_80182224(s32 arg0) {
+    s32 temp;
+    s32 out;
+    func_8012AD80(arg0);
+    temp = *(s32 *)(arg0 + 0x1C) + 4;
+    *(s32 *)(arg0 + 0x1C) = temp;
+    if (temp >= 0x100) {
+        out = 0xFF;
+    } else {
+        out = temp;
+    }
+    func_80015D4C(-0xA0, -0x78, 0x140, 0xF0, out, out, out, 0x20, 1);
+}
+
 
 extern void func_8002D4C8(s32 arg0, s32 arg1);
     void func_801822A0(void) {
@@ -5327,9 +5557,61 @@ void func_801824F4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801825DC);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182638);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(s32);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_80182638(int param_1)
+{
+    int v0;
+    int v1;
+
+    v0 = ((int (*)(void))func_8012C1B8)();
+    *(int *)(param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        ((void (*)(int))func_8012CAE4)(param_1);
+    } else {
+        func_8001C214(v0, 0);
+        v1 = func_80132EF4(param_1, 0x5D);
+        if (v1 != 0) {
+            *(int *)(v1 + 0x2C) = param_1;
+            *(unsigned short *)(v1 + 0x30) = *(unsigned short *)(param_1 + 0x36);
+        }
+        *(short *)(param_1 + 2) = 1;
+    }
+}
+
+
+extern void func_80132784(s32 a0, s32 a1, u32 a2);
+extern void func_8012F214(s32 a0, s32 a1, s32 a2);
+extern void func_8012B2CC(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80180F68(s32 a0);
+extern s32 D_801890D8;
+
+void func_801826B4(void *a0)
+{
+    void *s0;
+    s16 out[4];
+
+    s0 = a0;
+    *(s32 *)((u8 *)s0 + 0xC) = 0;
+    *(s32 *)((u8 *)s0 + 0x8) = 0;
+    *(s32 *)((u8 *)s0 + 0x4) = 0;
+    func_80132784((s32)s0, *(s32 *)((u8 *)s0 + 0x64), 4);
+
+    func_8012F214((s32)s0, (s32)&D_801890D8, (s32)out);
+    *(u16 *)((u8 *)s0 + 0x6) = out[0];
+    *(u16 *)((u8 *)s0 + 0xA) = out[1];
+    *(u16 *)((u8 *)s0 + 0xE) = out[2];
+
+    func_8012B2CC((s32)s0);
+    if (func_8012BEE8((s32)s0)) {
+        func_80180F68((s32)s0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801826B4);
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182744);
 
@@ -5386,7 +5668,31 @@ L_else:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182990);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(s32 a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void *D_801937DC;
+extern void func_801813B0(s32 a0);
+
+void func_80182990(s32 param_1)
+{
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)(param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(param_1);
+        return;
+    }
+    func_8001C810(v0, (s32)&D_801937DC);
+    *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x50000000;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10;
+    func_801813B0(param_1);
+    *(s16 *)(param_1 + 2) = 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182A1C);
 
@@ -5433,7 +5739,27 @@ extern void func_8012B2CC(s32 a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182B4C);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(s32 a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern void (*D_801891BC)(void);
+extern void (*D_801891C4)(void);
+
+void func_80182B4C(s32 arg0) {
+    s32 v0 = func_8012C1B8();
+    *(s32 *)(arg0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(arg0);
+        return;
+    }
+    func_8001C214(v0, 0);
+    *(s16 *)(arg0 + 2) = 1;
+    func_8012E8E0(arg0, (s32)&D_801891BC);
+    *(s32 *)(arg0 + 0x58) = (s32)&D_801891C4 | 0x40000000;
+    *(s16 *)(arg0 + 0x5C) = 0x400;
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 extern s32 D_8019A464;
@@ -5451,7 +5777,21 @@ void func_80182BF4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182C30);
+extern void func_80182F44(void *a0);
+
+void func_80182C30(void *param)
+{
+    void *s0 = param;
+
+    func_80182F44(s0);
+    if (*(s16 *)((s32)s0 + 0x210) >= 0) {
+        *(s16 *)((s32)s0 + 0x210) = 0x30;
+    } else {
+        *(s16 *)((s32)s0 + 0x210) = -0x30;
+    }
+    func_80171990((u8 *)s0);
+}
+
 
 
 extern s32 func_80183020(void);
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
index c61a755f72..c402a576ed 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
@@ -3307,9 +3307,46 @@ INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D15
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D1EC);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D288);
+extern void func_8014C6AC(void);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8017D34C(void *a0);
+extern u8 D_80126948[];
+
+void func_8017D288(void) {
+    func_8014C6AC();
+    func_8012A018((s32)func_8017D34C, 0x2);
+    func_8017D34C(D_80126948);
+}
+
+
+extern void func_8014C6C0(void);
+extern void func_8012A018(s32 a, s32 b);
+
+extern s32 D_80126954;
+extern s32 D_8012695C;
+extern s16 D_80126968;
+extern s16 D_8012696A;
+extern s16 D_8012696C;
+extern s16 D_80126976;
+extern s16 D_80126978;
+extern s16 D_8012697A;
+
+void func_8017D34C(void *a0);
+
+void func_8017D2C8(void)
+{
+    func_8014C6C0();
+    D_80126954 = 0x190;
+    D_8012695C = 0x4B0;
+    D_80126968 = 0x1C7;
+    D_8012696A = 0x800;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x20;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017D34C, 0);
+}
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D2C8);
 
 
 extern void (*D_801932D4[])(void);
@@ -3428,7 +3465,16 @@ INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D80
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017D89C);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017DA9C);
+extern s32 func_8012BE54(s32 a0);
+
+void func_8017DA9C(s32 a0) {
+    s32 v0 = func_8012BE54(a0);
+    if (v0 <= 0x23FFF) {
+        *(s16 *)(a0 + 0x34) = 0;
+        *(s16 *)(a0 + 0x2) = 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_8017DAE0);
 
@@ -3694,7 +3740,38 @@ void func_8018096C(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_801809A8);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80180AA8);
+extern u8 D_801202A0[];
+
+void func_80180AA8(void *a0) {
+    s32 i;
+    u8 *p;
+    u16 t;
+
+    switch (*(u16 *)((s32)a0 + 0x34)) {
+    case 0:
+        p = D_801202A0;
+        for (i = 0; i < 0x60; i++) {
+            if (*(u16 *)p == 0x390) {
+                *(void **)((s32)a0 + 0x6C) = p;
+                t = *(u16 *)(p + 0x36);
+                *(u16 *)((s32)a0 + 0x34) = 1;
+                *(u16 *)((s32)a0 + 0xFE) = t;
+            }
+            p += 0x10C;
+        }
+        break;
+    case 1: {
+        u8 *p2 = *(u8 **)((s32)a0 + 0x6C);
+        if (*(s16 *)((s32)a0 + 0xFE) != *(s16 *)(p2 + 0x36)) {
+            *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 4) &= 0x7FFFFFFF;
+            *(u16 *)((s32)a0 + 2) = 2;
+            *(u16 *)((s32)a0 + 0x34) = 0;
+        }
+        break;
+    }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80180B5C);
 
@@ -4773,7 +4850,28 @@ void func_801827E8(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80182824);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_801828FC);
+extern void func_8001C924(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern u8 D_801AC4D8[];
+extern u8 D_801B0EA8[];
+void func_801828FC(s32 a0) {
+    s16 v = *(s16 *)(a0 + 0x100);
+    if (v != 0) {
+        *(s16 *)(a0 + 0x100) = v - 1;
+    } else {
+        s32 *p = *(s32 **)(a0 + 0x20);
+        *(u8 *)(a0 + 0xC1) = 0;
+        *(u16 *)(a0 + 0x5E) = 0;
+        *(s32 *)(p + 0x20) = (s32)D_801AC4D8;
+        if (*(s16 *)(a0 + 0x76) == 0) {
+            func_8001C924(*(s32 *)(a0 + 0x20), &D_801B0EA8);
+            *(s16 *)(a0 + 0xAE) = -1;
+            *(s32 *)(a0 + 0x1C) = 0x20;
+            ((void (*)(s32 *, s32))func_8012AD44)(a0, 4);
+        }
+    }
+}
+
 
 extern u8 *func_8012913C(s32 a0);
 
@@ -4808,7 +4906,23 @@ void func_80182994(s32 a0, s32 a1, s32 a2, s32 a3) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80182B58);
+extern void func_80182BD8(s32 a0, void *a1, s32 a2, s32 a3);
+
+void func_80182B58(s32 a0)
+{
+    s16 sp10[4];
+
+    sp10[1] = 0x100;
+    sp10[2] = 0;
+    sp10[3] = 0;
+    sp10[0] = 0;
+    func_80182BD8(a0, sp10, 0x32, 2);
+    sp10[0] = -0xC0;
+    func_80182BD8(a0, sp10, 0x33, 3);
+    sp10[0] = 0xC0;
+    func_80182BD8(a0, sp10, 0x33, 2);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80182BD8);
 
@@ -5010,7 +5124,20 @@ void func_8018337C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_801833B8);
+extern u8 D_801AC4D8[];
+extern u8 D_801AC4E0[];
+
+void func_801833B8(s32 a0) {
+    s32 p = *(s32 *)(a0 + 0xCC);
+    if (*(s16 *)(a0 + 0x70) >= 2) {
+        if (*(s16 *)(p + 0x100) != 0) {
+            *(s32 *)(*(s32 *)(a0 + 0x20) + 0x80) = (s32)D_801AC4E0;
+        } else {
+            *(s32 *)(*(s32 *)(a0 + 0x20) + 0x80) = (s32)D_801AC4D8;
+        }
+    }
+}
+
 
 
 void func_80183408(s32 target, u16 *cur, s32 step)
@@ -5089,7 +5216,39 @@ void func_8018348C(s32 self)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183598);
+#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 s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_80183598(s32 self)
+{
+    u16 sv[4];
+    u16 scratch[4];
+    s32 obj;
+
+    func_8004914C((void *)(*(s32 *)(self + 0x20) + 0x54));
+    func_800491AC((void *)(*(s32 *)(self + 0x20) + 0x54));
+
+    sv[1] = 0;
+    sv[0] = 0;
+    *(s16 *)&sv[2] = -0x40;
+    RotTransSV(&sv[0], &sv[0], &scratch[0]);
+
+    obj = func_80132EF4(self, 0x23);
+    if (obj != 0) {
+        u16 c;
+        *(u16 *)(obj + 0x6) = sv[0];
+        *(u16 *)(obj + 0xA) = sv[1];
+        c = sv[2];
+        *(u16 *)(obj + 0x34) = 0x4001;
+        *(u16 *)(obj + 0xE) = c;
+        *(u16 *)(*(s32 *)(obj + 0x20) + 0x2C) = 0xC008;
+    }
+}
+
 
 
 extern void (*D_801AC590[])(void);
@@ -5233,7 +5392,16 @@ void func_80183B34(void) {
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183B3C);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183C1C);
+void func_80183C1C(s32 a0) {
+    s16 v = *(s16 *)(a0 + 0x54);
+
+    if (v != 0) {
+        *(s16 *)(a0 + 0x54) = v - 0x10;
+    } else {
+        func_80182EAC(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183C58);
 
@@ -5307,11 +5475,79 @@ void func_80183CB0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183DBC);
+extern s32 func_8012CBCC(s32 a0);
+extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012C218(s32 a0);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183E74);
+extern s32 D_801AC588;
+extern u8 D_800D3918[];
+
+void func_80183DBC(s32 param_1) {
+    s32 s0 = param_1;
+    s32 r;
+    s32 v;
+
+    r = func_8012CBCC(s0);
+    if (func_8012D5E4(s0, (s32)&D_801AC588, (s32)&D_800D3918, 0x40) == 0) {
+        if (r != 0) {
+            func_80146A6C(6, (void *)s0, *(s16 *)(s0 + 0x6), *(s16 *)(s0 + 0xA),
+                          *(s16 *)(s0 + 0xE), 0, 0);
+            v = func_80132EF4(s0, 0x22);
+            if (v != 0) {
+                *(s16 *)(v + 0x34) = 0x2000;
+            }
+        } else {
+            if (func_8012BEE8(s0) == 0) {
+                return;
+            }
+        }
+    }
+    func_8012C218((s32)s0);
+}
+
+
+void func_80183E74(void *arg0) {
+    register s32 s0 __asm__("$16") = (s32)arg0;
+    register s32 a0 __asm__("$4");
+    register s32 a1 __asm__("$5");
+    register s32 v1 __asm__("$3");
+    register s32 v0 __asm__("$2");
+    u16 val;
+
+    a0 = *(s32 *)(s0 + 0x20);
+    val = *(u16 *)(s0 + 0x106);
+    *(u16 *)(a0 + 0x10) = *(u16 *)(a0 + 0x10) + val;
+
+    a1 = *(s32 *)(s0 + 0x20);
+    val = *(u16 *)(s0 + 0x108);
+    *(u16 *)(a1 + 0x14) = *(u16 *)(a1 + 0x14) + val;
+    func_8012AD80(s0);
+
+    if (*(s16 *)(s0 + 0xA) >= *(s16 *)(s0 + 0xE0)) {
+        *(s16 *)(s0 + 0xA) = *(s16 *)(s0 + 0xE0);
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x10) = 0x400;
+
+        if (rand() & 1) {
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x10) = 0xC00;
+        }
+        func_8018386C(s0);
+    }
+    func_80183940(s0, 0x4001);
+}
+
+
+extern s32 func_80183940();
+extern s32 rand(void);
+
+void func_80183F24(s32 a0) {
+    if (func_80183940(a0, 0x2001)) {
+        *(u16 *)(a0 + 0xE6) = (rand() & 0x7F) + 0x10;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80183F24);
 
 extern void (*D_801BC358[])(void);
 extern void func_8012C0EC(void *a0);
@@ -5593,11 +5829,58 @@ void func_801844BC(s32 p)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184644);
+extern void func_8012A828(s32 a0, void *a1);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184678);
+void func_80184644(s32 param_1) {
+    extern u8 D_801D321C[];
+    *(s32 *)(param_1 + 0x1c) = 0x20;
+    *(s16 *)(param_1 + 0x2) = 7;
+    func_8012A828(param_1, D_801D321C);
+}
+
+
+extern s32 func_8012BDBC(s32 a0, s32 a1);
+extern s32 func_8012BCCC(s32 a0);
+extern s32 func_8012BEE8();
+
+void func_80184678(s32 p) {
+    s32 r;
+
+    if (func_8012BDBC(p, 0x300) != 0) {
+        r = func_8012BCCC(p);
+        if (r < 0x100000) {
+            if (r < 0x6400) {
+                *(s16 *)(p + 2) = 8;
+            } else {
+                *(s16 *)(p + 2) = 4;
+            }
+            return;
+        }
+    } else {
+        r = func_8012BCCC(p);
+        if (r < 0x4000) {
+            *(s16 *)(p + 2) = 0xF;
+            return;
+        }
+    }
+
+    if (func_8012BEE8(p) != 0) {
+        *(s16 *)(p + 2) = 2;
+    }
+}
+
+
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80184700(void *arg0) {
+    extern u8 D_801D332C[];
+    s32 *s0 = (s32 *)arg0;
+
+    func_8012A828((s32)arg0, D_801D332C);
+    *(s16 *)((u8 *)s0 + 2) = 9;
+    *(s32 *)((u8 *)s0 + 0xE0) = (*(s32 *)((u8 *)s0 + 0xE0) | 2) & ~0x10;
+}
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184700);
 
 
 extern s32  func_8018769C(s32 a0, s32 a1);
@@ -5662,7 +5945,19 @@ set_and_return:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184888);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80184888(s32 p)
+{
+    extern u8   D_801D3C44[];
+
+    func_8012A828(p, D_801D3C44);
+    *(s16 *)(p + 2) = 0xB;
+    *(s32 *)(p + 0x10) = *(s32 *)(p + 0x10) * 2;
+    *(s32 *)(p + 0x18) = *(s32 *)(p + 0x18) * 2;
+    *(s16 *)(p + 0x34) = 0;
+}
+
 
 
 extern s32  func_8018769C(s32 a0, s32 a1);
@@ -5714,7 +6009,23 @@ void func_801848DC(s32 p)
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184A2C);
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80184A6C);
+extern u8 D_801BC200[];
+extern s32 D_80126B9C;
+void func_80184A6C(s32 a0) {
+    s32 buf[2];
+    s32 v0;
+    func_8012F214(a0, (s32)D_801BC200, (s32)buf);
+    if (func_8012BEE8(a0) != 0 && (D_80126B9C & 2) == 0) {
+        *(s16 *)(a0 + 2) = 4;
+        return;
+    }
+    v0 = *(s32 *)(a0 + 0x20);
+    v0 = func_801897F0(buf, *(s16 *)(v0 + 0x12), 0x400);
+    if (v0 == 0) {
+        *(s16 *)(a0 + 2) = 4;
+    }
+}
+
 
 
 extern void func_8012C218(s32);
@@ -5917,7 +6228,21 @@ void func_80184EB0(s32 p)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80185014);
+void func_80185014(s32 p)
+{
+    extern u8 D_801BBFF8[];
+    extern u8 D_801D35CC[];
+
+    *(s16 *)(p + 2) = 0x14;
+    if ((*(u32 *)(p + 0xE0) & 0x400) == 0) {
+        *(s16 *)(p + 0x34) = 1;
+        func_8012A828(p, D_801D35CC);
+    } else {
+        *(s16 *)(p + 0x34) = 0;
+        func_8012A828(p, D_801BBFF8);
+    }
+}
+
 
 typedef struct {
     SVECTOR_8016E7C8 v[4];               /* 0x00 */
@@ -5969,4 +6294,18 @@ void func_80185068(s32 p)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80185178);
+void func_80185178(s32 a0)
+{
+    extern u8 D_801D35CC[];
+
+    *(s16 *)(a0 + 2) = 0x16;
+    if ((*(u32 *)(a0 + 0xE0) & 0x400) == 0) {
+        func_8012A828(a0, D_801D35CC);
+        *(s16 *)(a0 + 0x34) = 4;
+        *(s32 *)(a0 + 0x1C) = 0xF;
+    } else {
+        *(s32 *)(a0 + 0x1C) = 0x1E;
+        *(s16 *)(a0 + 0x34) = 0;
+    }
+}
+
diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8017BEBC.c b/src/ov_SC06_025/ov_SC06_025_jr_8017BEBC.c
index ed2977819f..48d9fb90e8 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8017BEBC.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8017BEBC.c
@@ -3370,7 +3370,22 @@ s32 func_8017D1DC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017D258);
+extern s32 func_800167F0(s32 a0);
+extern void func_8002931C(void);
+extern void func_80029514(s32 a0);
+extern void func_8002AED0(void);
+
+s32 func_8017D258(void) {
+    s32 result = func_800167F0(4);
+    if ((result & 0xFFFF) == 0) {
+        return 0;
+    }
+    ((void (*)(s32))func_8002931C)(0x41A0000);
+    func_80029514(0x5DC);
+    func_8002AED0();
+    return 1;
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017D2A0(void) {
@@ -3414,7 +3429,35 @@ void func_8017D350(void) {
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017D378);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017D418);
+#include "common.h"
+
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017D4B4(void *a0);
+extern u8 D_80126948[];
+extern s32 D_80126954;
+extern s32 D_8012695C;
+extern s16 D_80126968;
+extern s16 D_8012696A;
+extern s16 D_8012696C;
+extern s16 D_80126976;
+extern s16 D_80126978;
+extern s16 D_8012697A;
+
+void func_8017D418(void) {
+    D_80126954 = 0x190;
+    D_8012695C = 0x6A4;
+    D_80126968 = 0x155;
+    D_8012696A = 0x800;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x20;
+    D_8012697A = 0;
+    ((void (*)(void *, s32))func_8012A018)((void *)func_8017D4B4, 0x1);
+    func_8012A094((s32)D_80126948);
+    func_8017D4B4((void *)D_80126948);
+}
+
 
 
 extern void (*D_8018879C[])(void);
@@ -3615,7 +3658,23 @@ void func_8017DE9C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017DED8);
+extern void func_8014706C(void *a0);
+extern void func_8016F264(void);
+extern void func_8016F2A8(void);
+extern void func_8016F2EC(void);
+extern void func_80171A1C(u8 *a0);
+
+void func_8017DED8(void *a0) {
+    void *s0 = a0;
+    func_8014706C(s0);
+    func_8016F264();
+    func_8016F2A8();
+    func_8016F2EC();
+    func_8017E0F0(s0);
+    func_80171A1C((u8 *)s0);
+    func_8017DF30(s0);
+}
+
 
 extern void func_8017E05C(void);
     void func_8017DF30(void) {
@@ -3623,9 +3682,48 @@ extern void func_8017E05C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017DF50);
+extern void func_8017E100(void);
+extern s32 D_801B12E4;
+extern s32 func_8014C568(s16 *a0, s16 *a1);
+extern s32 func_80146E98(s32 a0);
+extern void func_8017E230(s32);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+
+void func_8017DF50(void *arg0) {
+    register s32 b __asm__("$17");
+    register s32 a __asm__("$16");
+    b = (s32)arg0;
+    a = *(s32 *)(b + 0x20);
+    func_8017E100();
+    *(s16 *)(a + 0x12) = func_8014C568((s16 *)b, (s16 *)D_801B12E4);
+    if (func_80146E98(b) != 0) {
+        ((void (*)(s32 *))func_8017E230)(arg0);
+        func_80154150(b, 0x10);
+        func_80171A1C((u8 *)b);
+    } else {
+        ((void (*)(s32 *))func_8017E230)(arg0);
+        if (*(s16 *)(b + 0x20C) == 0) {
+            if ((*(u16 *)(b + 0xB8) & 0x8000) != 0) {
+                *(u16 *)(b + 0x20C) = 1;
+                *(u16 *)(b + 0xB8) = *(u16 *)(b + 0xBA);
+            }
+        }
+    }
+}
+
+
+extern void func_80171A34(s32 *a0, s8 a1);
+extern void func_8017E05C(void);
+
+void func_8017E008(void *a0) {
+    if (((s32 (*)(void))func_8017E05C)() == 0) {
+        if (*(u16 *)((u8 *)a0 + 0xB8) & 0x8000) {
+            func_80171A34((s32 *)a0, 1);
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E008);
 
 void func_8017E054(void) {
 }
@@ -3636,9 +3734,35 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E0F
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E100);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E18C);
+void func_8017E18C(s32 arg0, s16 *arg1, s32 arg2, s32 arg3)
+{
+    s32 q1;
+    s32 q2;
+
+    arg3 = arg0;
+    if (arg2 <= 0) {
+        arg2 = 1;
+    }
+    q1 = ((arg1[0] - *(s16 *)(arg3 + 6)) << 16) / arg2;
+    q2 = ((arg1[2] - *(s16 *)(arg3 + 0xE)) << 16) / arg2;
+    *(s32 *)(arg3 + 0x28) = arg2 * -0x100000;
+    *(s32 *)(arg3 + 0x24) = q1;
+    *(s32 *)(arg3 + 0x2C) = q2;
+}
+
+
+void func_8017E230(s32 a0)
+{
+    *(s32 *)(a0 + 0x28) += 0x200000;
+    *(s32 *)(a0 + 4) += *(s32 *)(a0 + 0x24);
+    *(s32 *)(a0 + 8) += *(s32 *)(a0 + 0x28);
+    *(s32 *)(a0 + 0xC) += *(s32 *)(a0 + 0x2C);
+    if (*(s16 *)(a0 + 0xA) >= -0x177)
+    {
+        *(s16 *)(a0 + 0xA) = -0x178;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E230);
 
 
 extern void func_8012DFD4(void *a0);
@@ -3657,7 +3781,19 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E2F
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E3C0);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E430);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 D_801887C4;
+
+void func_8017E430(s32 *a0)
+{
+    if (--a0[7] == 0) {
+        func_80178B18((s32)a0, (s32)&D_801887C4);
+        *(u16 *)((s32)a0 + 2) = 2;
+        func_8002D4C8(0xC0C, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E48C);
 
@@ -3875,7 +4011,26 @@ void func_8017E6C0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E95C);
+extern void func_80016714(void *a0, s32 a1);
+
+typedef struct {
+    s16 unk0;                /* 0x00 */
+    u8 pad[0x102];           /* -> 0x104 */
+} St_8017E95C_r;
+
+extern St_8017E95C_r D_801B12F0[4];
+extern St_8017E95C_r D_801B12F8[4];
+
+void func_8017E95C(void) {
+    s32 i;
+
+    func_80016714(D_801B12F0, 0x410);
+    for (i = 0; i < 4; i++) {
+        D_801B12F0[i].unk0 = 1;
+        D_801B12F8[i].unk0 = i;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8017E9B8);
 
@@ -4302,7 +4457,39 @@ void func_801807F8(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80180808);
+/* func_80180808 -- cursor-advance probe over the 8-byte record at *D_801B1B50.
+ * Returns: 3 = cursor unset (-1), 2 = pos outside [min,max], 1 = advanced,
+ * or (max < pos*2) << 1 when the selector itself is unset. */
+s32 func_80180808() {
+
+    typedef struct { s32 f0; s16 f4; s16 f6; } Rec_80180808;
+
+    extern s16 D_801B1704;
+    extern s16 D_801B1720;
+    extern s32 D_801B1B50;
+
+    s32 pos = D_801B1704 * 2;
+    Rec_80180808 *rec = (Rec_80180808 *)D_801B1B50;
+
+    if (rec->f0 == -1) {
+        return 3;
+    }
+    if (D_801B1720 != -1) {
+        if (D_801B1720 != rec->f0) {
+            return 2;
+        }
+        if (pos < rec->f4) {
+            return 2;
+        }
+        if (!(rec->f6 < pos)) {
+            D_801B1B50 = (s32)(rec + 1);
+            return 1;
+        }
+        return 2;
+    }
+    return (rec->f6 < pos) << 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801808AC);
 
@@ -4312,7 +4499,7 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8018098
 
 #include "common.h"
 
-extern void func_80181750(s32 a0, s32 a1);
+extern void func_80181750();
 extern void func_80181C74(s32 *a0, s32 a1);   /* verbatim from its own definition later in this TU */
 extern void func_8012AD80(s32 a0);
 extern void func_80181700(void *a0);
@@ -4641,7 +4828,16 @@ void func_80181488(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801814C4);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern u8 D_80189408[];
+
+void func_801814C4(void *a0) {
+    s32 s0 = (s32)a0;
+    *(s16 *)(s0 + 0x2) = 2;
+    func_8012E8E0((s32)a0, (s32)D_80189408 + (*(s16 *)(s0 + 0x70) << 3));
+    *(s32 *)(s0 + 0x1C) = 0x77;
+}
+
 
 #include "common.h"
 
@@ -4712,7 +4908,21 @@ void func_801816C4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80181700);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80181750);
+void func_80181750(void *a0)
+{
+    s32 *p = (s32 *)a0;
+    s32 *q1, *q2;
+    s32 r, t;
+
+    t = func_8012B744(p + 1);
+    q1 = *(s32 **)((u8 *)p + 0x20);
+    r = func_8012B608(*(s16 *)((u8 *)q1 + 0x12), t, 4);
+    q2 = *(s32 **)((u8 *)p + 0x20);
+    t = *(u16 *)((u8 *)q2 + 0x12);
+    t += r;
+    *(s16 *)((u8 *)q2 + 0x12) = t;
+}
+
 
 #include "common.h"
 
@@ -4762,7 +4972,22 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801818D
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80181B90);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80181BC8);
+extern u16 D_80126B62;
+extern s16 D_801B1718;
+extern s16 D_801B171C;
+
+void func_80181BC8(void) {
+    s32 hit;
+
+    hit = ((s16)D_80126B62 == -0x178);
+    if (D_801B1718 == 0 && hit) {
+        D_801B171C = 1;
+    } else {
+        D_801B171C = 0;
+    }
+    D_801B1718 = hit;
+}
+
 
 
 extern void Square0(s32 *a0, s32 *a1);
@@ -4983,7 +5208,17 @@ void func_80181E08(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182090);
+s32 func_80182090(s32 color, s32 mult) {
+    s32 g = ((u32)color >> 8) & 0xFF;
+    s32 r = color & 0xFF;
+    s32 b = ((u32)color >> 16) & 0xFF;
+
+    r = func_80182118(r, mult);
+    g = func_80182118(g, mult);
+    b = func_80182118(b, mult);
+    return r | (g << 8) | (b << 16);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182118);
 
@@ -4997,9 +5232,38 @@ void func_80182148(void) {
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182170);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182268);
+#include "common.h"
+
+extern s16 D_80126B5E;
+extern s16 D_80126B66;
+
+void func_80182268(s32 a0, s32 a1, s32 a2, s32 a3) {
+    if (D_80126B5E < a0) {
+        D_80126B5E = a0;
+    }
+    if (a1 < D_80126B5E) {
+        D_80126B5E = a1;
+    }
+    if (D_80126B66 < a2) {
+        D_80126B66 = a2;
+    }
+    if (a3 < D_80126B66) {
+        D_80126B66 = a3;
+    }
+}
+
+
+extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5);
+extern u8 D_80189514[];
+extern u8 D_8018950C;
+extern s16 D_80126B9A;
+
+s32 func_801822F0(void)
+{
+    func_8012F568(1, 0xC01A, 0, 0x5A, &D_80189514, &D_8018950C);
+    D_80126B9A = 0;
+}
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801822F0);
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8018233C);
 
@@ -5151,7 +5415,22 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801825E
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182720);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182850);
+void func_80182850(s32 *a0) {
+    extern void func_8012B2CC(s32 a0);
+    extern void func_8012B200(void *a0);
+    extern void func_8012B14C(s32 a0, s32 a1);
+    extern void (*D_80188EE4)(void *);
+    extern s32 D_80188EF0;
+    s32 v0;
+
+    func_8012B2CC((s32)a0);
+    func_8012B200(a0);
+    func_8012B14C((s32)a0, (s32)&D_80188EE4);
+    v0 = D_80188EF0;
+    a0[7] = 0;
+    a0[18] = v0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801828A0);
 
@@ -5159,7 +5438,45 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8018293
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182950);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801829B4);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern void func_8017DB6C(s32 a0);
+extern s16 D_801B173C;
+
+void func_801829B4(void *a0)
+{
+    void *s0;
+    s32 v1;
+
+    s0 = a0;
+    v1 = *(u16 *)((u8 *)s0 + 0x34);
+
+    switch (v1) {
+    case 0:
+        *(u16 *)((u8 *)s0 + 0x34) = *(u16 *)((u8 *)s0 + 0x34) + 1;
+        return;
+
+    case 1:
+        if (((s32 (*)(void *))func_80178970)(s0) == 0) {
+            return;
+        }
+        ((void (*)(void *))func_80178D18)(s0);
+
+        *(u16 *)((u8 *)s0 + 0x34) = *(u16 *)((u8 *)s0 + 0x34) + 1;
+        return;
+
+    case 2:
+        func_8017DB6C(1);
+        *(u16 *)((u8 *)s0 + 0x34) = *(u16 *)((u8 *)s0 + 0x34) + 1;
+        return;
+
+    case 3:
+        func_8017DB6C(1);
+        D_801B173C = 1;
+        return;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182A78);
 
@@ -5179,7 +5496,20 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182F20);
+extern void func_80015D4C(s32 a0, s32 a1, s32 a2, s32 a3, u8 a4, u8 a5, u8 a6, u16 a7, u16 a8);
+extern s16 D_801B1748;
+
+void func_80182F20(void) {
+    s32 x;
+    x = D_801B1748;
+    x = x + 4;
+    if (x >= 0x100) {
+        x = 0xFF;
+    }
+    func_80015D4C(-0xA0, -0x78, 0x140, 0xF0, x, x, x, 0x20, 2);
+    D_801B1748 = x;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80182F98);
 
@@ -5209,7 +5539,18 @@ void func_80183090(void) {
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801830C8);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80183100);
+extern s32 func_8012E544(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801A6584[];
+
+void func_80183100(void) {
+    s32 v0;
+    v0 = func_8012E544(0x2CD);
+    if (v0 != 0) {
+        func_8012A828(v0, D_801A6584);
+    }
+}
+
 
 #include "common.h"
 
@@ -5272,7 +5613,39 @@ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_8018329
 void func_80183328(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80183330);
+#include "common.h"
+
+extern void func_8012C1B8(void);   /* fleet-modal spelling, cast at call */
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012E8E0(s32 a0, s32 a1);
+
+extern s32 D_801893AC[];
+extern u8 D_801893B4[];
+extern u8 D_801893C4[];
+
+void func_80183330(void *a0)
+{
+    s32 iVar2;
+
+    iVar2 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = iVar2;
+    if (iVar2 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(iVar2, D_801893AC[*(s16 *)((s32)a0 + 0x70)]);
+
+    *(u16 *)((s32)a0 + 0x5C) = 0xC00;
+    *(s32 *)((s32)a0 + 0x58) = ((s32)&D_801893C4 | 0x40000000);
+    *(u8 *)((s32)a0 + 0x75) = 8;
+    *(s16 *)((s32)a0 + 0x2) = 1;
+    func_8012E8E0((s32)a0, (s32)&D_801893B4[*(s16 *)((s32)a0 + 0x70) * 8]);
+    *(s32 *)((s32)a0 + 0x1C) = 0x1E;
+    *(s16 *)((s32)a0 + 0x34) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801833E8);
 
@@ -5315,7 +5688,29 @@ void func_80183724(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80183774);
+extern u8 D_801AD9EC[];
+extern void func_80147324(s32 a0);
+extern int func_801511E0(int arg);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_80149020(s32 *a0);
+extern void func_80183988(void);
+extern s32 func_80172630(u8 *a0);
+extern void func_80146CA0(void *a0);
+
+void func_80183774(s32 a0)
+{
+    s32 s0 = a0;
+    func_80147324(0x451);
+    ((void (*)(s32))func_801511E0)(s0);
+    ((void (*)(s32, s32))func_80154274)(s0, (s32)D_801AD9EC);
+    ((void (*)(s32))func_80149020)(s0);
+    *(u8 *)(s0 + 0xDE) = 0x1E;
+    *(u8 *)(s0 + 0xDF) = 0;
+    func_80183988();
+    ((void (*)(s32))func_80172630)(s0);
+    ((void (*)(s32))func_80146CA0)(s0);
+}
+
 
 
 /* func_801837E0 @ ov_SC02_016 (subseg ov_SC02_016_jr_8017DC70) — 85 ins.
@@ -5930,9 +6325,27 @@ extern void func_801842C0(s32 *a0);
 
 INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_801842C0);
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80184340);
+extern u16 D_800B99DA;
 
-extern void func_80184410(void *a0);
+void func_80184340(s32 *a0) {
+    s32 pad[8];
+    func_80149020(a0);
+    func_80147A84((s32)a0);
+    func_801473EC(a0);
+    func_80148038((s32)a0, 0x18000);
+    func_80147460((s32)a0);
+    if (!(D_800B99DA & 1)) {
+        func_8014C010((s32)a0, 2);
+    }
+    func_801535F4(a0);
+    if (*(s16 *)((s32)a0 + 0xE) < -0x38) {
+        *(s16 *)((s32)a0 + 0xE) = -0x38;
+        func_80146CA0(a0);
+    }
+}
+
+
+extern void func_80184410();
 extern void func_80159B3C(void*);
 extern void func_80165718(s32);
 void func_801843D8(void *a0) {
@@ -5942,7 +6355,19 @@ void func_801843D8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017BEBC", func_80184410);
+extern void func_80015978(s32 a0, s32 *a1);
+extern void func_80151664(void);
+extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5);
+
+void func_80184410(s32 a0)
+{
+    s32 buf[2];
+
+    ((void (*)(s32))func_80151664)(a0);
+    func_80015978(a0 + 4, buf);
+    func_8012F568(1, 0xC018, *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), 0x5A, buf, buf);
+}
+
 
 
 extern void (*D_801AE188[])(void);
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
index 0b72a02dd1..aaa57c7bef 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
@@ -3095,7 +3095,19 @@ void func_80182E68(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80182FD8);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+
+void func_80182FD8(s32 param_1) {
+    *(s32 *)(param_1 + 0x1C) = 0x18;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0x80;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12);
+    func_8012B2CC(param_1);
+    func_8012B178(param_1, -0x100000);
+    *(u16 *)(param_1 + 2) = 2;
+}
+
 
 
 extern void func_8012C218(void *a0);
@@ -3208,7 +3220,23 @@ LAB_80188494:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80183298);
+void func_80183298(s32 param_1) {
+    s32 v1;
+    s32 v0;
+    s32 v2;
+
+    v1 = *(s32 *)(param_1 + 0x64);
+    *(s32 *)(param_1 + 0x48) = 0xC000;
+    v0 = *(s32 *)(v1 + 0x20);
+    v2 = *(s32 *)(param_1 + 0x20);
+    *(u16 *)(v2 + 0x12) = *(u16 *)(v0 + 0x12);
+    func_8012B2CC(param_1);
+    func_8012B178(param_1, 0x20000);
+    *(s16 *)(param_1 + 0x2) = 4;
+    *(s32 *)(param_1 + 0x1C) = 0;
+    *(s16 *)(param_1 + 0x34) = 0;
+}
+
 
 
 extern void func_8012C218(void *a0);
@@ -3261,7 +3289,19 @@ LAB_tail:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80183430);
+void func_80183430(void *arg0) {
+    s32 temp;
+    s32 src;
+    s32 dst;
+
+    temp = *(s32 *)((s8 *)arg0 + 0x64);
+    *(u16 *)((s8 *)arg0 + 2) = 6;
+    *(u16 *)((s8 *)arg0 + 0x34) = 0;
+    src = *(s32 *)((s8 *)temp + 0x20);
+    dst = *(s32 *)((s8 *)arg0 + 0x20);
+    *(u16 *)((s8 *)dst + 0x12) = *(u16 *)((s8 *)src + 0x12);
+}
+
 
 
 // @class: struct
@@ -3468,7 +3508,20 @@ void func_80183AF8(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80183B34);
+extern s32 func_8012D624(void *a0, s32 a1, s32 a2);
+
+void func_80183B34(s32 param_1) {
+    extern u16 D_80126B96;
+    if (*(u16 *)(param_1 + 0x70) & 1) {
+        if (func_8012D624((void *)param_1, 0x60, *(s16 *)(param_1 + 0x104)) == 1) {
+            D_80126B96 = 0x4001;
+        }
+    }
+    if (func_801841F0(param_1, 0x60, *(s16 *)(param_1 + 0x104)) == 1) {
+        func_8012C218((void *)param_1);
+    }
+}
+
 
 
 /* func_80183BB4 @ ov_SC06_018 (subseg ov_SC06_018_jr_8017C24C) — 124 ins. MATCH.
@@ -3740,7 +3793,25 @@ s32 aF80184170(s32 a0, s16 a1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801841F0);
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+s32 func_801841F0(s32 param_1, s32 param_2, s32 param_3)
+{
+    s32 result;
+
+    if (func_8012BEE8(param_1) != 0) {
+        result = func_80132EF4(param_1, 0x22);
+        if (result != 0) {
+            *(u16 *)(result + 0x34) = 0x7FFF;
+            *(u16 *)(*(s32 *)(result + 0x20) + 0x2C) = 0xC006;
+            *(u32 *)(result + 0x14) = 0xFFFE0000;
+        }
+        return 1;
+    }
+    return 0;
+}
+
 
 
 extern void (*D_801A6A10[])(void);
@@ -4526,15 +4597,78 @@ INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857F
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185860);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801859A0);
+extern u8 D_801BEE64[];
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_801859A0(void *a0)
+{
+    s32 a1;
+
+    a1 = *(s32 *)((s32)a0 + 0xCC);
+    if (a1 != 0) {
+        s32 f = *(u16 *)((s32)a0 + 0xFE) & 1;
+        *(s16 *)(a1 + 0x54) = f;
+        *(s16 *)(a1 + 0x50) = f;
+        *(s16 *)((s32)a0 + 0x54) = f;
+        *(s16 *)((s32)a0 + 0x50) = f;
+    }
+    if (*(s16 *)((s32)a0 + 0xFE) != 0) {
+        *(s16 *)((s32)a0 + 0xFE) -= 1;
+    } else {
+        *(u8 *)((s32)a0 + 0xC1) = 0;
+        *(s16 *)((s32)a0 + 0x5E) = 0;
+        *(u8 **)(*(s32 *)((s32)a0 + 0x20) + 0x80) = D_801BEE64;
+        if (a1 != 0) {
+            *(u8 **)(*(s32 *)(a1 + 0x20) + 0x80) = D_801BEE64;
+        }
+        if (*(s16 *)((s32)a0 + 0x76) == 0) {
+            *(s32 *)((s32)a0 + 0x1C) = 4;
+            func_8012AD44((s32 *)a0, 3);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185A44);
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185B4C);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185CD8);
+/* func_80185CD8 -- ov_SC06_032. Head-crack init: memset D_801D0D80[0x80] then
+ * two align-1 4-byte block moves (cookbook §160a idiom, cf. ov_SC02_005
+ * func_8018CE04 / func_8018BDD0). */
+
+typedef struct { u8 d[4]; } Blk4_80185CD8;
+
+void func_80185CD8(void) {
+    extern u8 D_801D0D80;
+    extern u8 D_801D0D84;
+    extern u8 D_801CF0DC;
+    extern u8 D_801CF0E0;
+
+    func_800233CC(&D_801D0D80, 0x80);
+
+    *(Blk4_80185CD8 *)&D_801D0D80 = *(Blk4_80185CD8 *)&D_801CF0DC;
+    *(Blk4_80185CD8 *)&D_801D0D84 = *(Blk4_80185CD8 *)&D_801CF0E0;
+}
+
+
+typedef struct { u8 b[4]; } Blk4_80185D4C;
+
+extern Blk4_80185D4C D_801D0D80;
+extern Blk4_80185D4C D_801CF0E4;
+extern Blk4_80185D4C D_801CF0DC;
+
+void func_80185D4C(void) {
+    Blk4_80185D4C *dst;
+
+    dst = &D_801D0D80;
+    if (dst->b[0] == 0xFF) {
+        *dst = D_801CF0E4;
+    } else {
+        *dst = D_801CF0DC;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185D4C);
 
 
 void func_80185DAC(s32 target, u16 *cur, s32 step)
@@ -4568,7 +4702,24 @@ void func_80185DAC(s32 target, u16 *cur, s32 step)
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185E30);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185EAC);
+extern s32 func_8012B8A4(s16 *a0);
+extern void func_80185F4C(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 rand(void);
+
+void func_80185EAC(s32 param_1)
+{
+    s32 r;
+    s32 t;
+    s32 w;
+
+    r = func_8012B8A4((s16 *)param_1);
+    func_80185F4C(param_1, 0x32, 2, (s16)r);
+    t = r - 0x200;
+    func_80185F4C(param_1, 0x33, 3, (s16)(t - (rand() & 0x3F0)));
+    w = r + 0x200;
+    func_80185F4C(param_1, 0x33, 2, (s16)(w + (rand() & 0x3F0)));
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185F4C);
 
@@ -4794,7 +4945,26 @@ void func_80186834(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186870);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801868EC);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_801868EC(s32 param_1)
+{
+    u16 val_fe;
+    s32 result;
+
+    val_fe = *(u16 *)(param_1 + 0xFE);
+    val_fe = val_fe + 1;
+    *(u16 *)(param_1 + 0xFE) = val_fe;
+    if ((val_fe & 7) == 0) {
+        result = func_80132EF4(param_1, 0x22);
+        if (result != 0) {
+            *(u32 *)(result + 0x14) = 0xFFF80000;
+            *(u16 *)(result + 0x34) = 0x4001;
+            *(u16 *)(*(s32 *)(result + 0x20) + 0x2C) = 0xC010;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018694C);
 
@@ -4813,7 +4983,22 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186BAC);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186CF0);
+void func_80186CF0(void *a0) {
+    extern void (*D_801BEF84[])(void);
+    D_801BEF84[*(u16 *)(a0 + 2)]();
+    if (*(u16 *)a0 != 0) {
+        s32 p = *(s32 *)(a0 + 0x64);
+        if (*(s16 *)(p + 0x36) == *(s16 *)(a0 + 0x100)) {
+            if (*(u16 *)(p + 2) != 4) return;
+        }
+        p = *(s32 *)(a0 + 0xCC);
+        if (p != 0) {
+            func_80016714((void *)p, 0x38);
+        }
+        func_8012C218(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186D90);
 
@@ -5279,7 +5464,33 @@ void func_80187A5C(void) {
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80187A64);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80187B88);
+extern void func_8012AD80(s32 a0);
+extern void func_801437D8(s32 a0, s32 a1, s32 a2, s32 a3);
+extern u8 D_801BEEF0[];
+
+void func_80187B88(s32 param_1)
+{
+    struct {
+        u16 f0;
+        u16 f2;
+        u16 f4;
+        u16 f6;
+    } local;
+
+    func_8012AD80(param_1);
+    local.f0 = *(u16 *)(param_1 + 0x6);
+    local.f2 = *(u16 *)(param_1 + 0xA);
+    local.f4 = *(u16 *)(param_1 + 0xE);
+    local.f6 = 0x3000;
+    func_801437D8(param_1 + 0x100, (s32)&local, (s32)D_801BEEF0, 0);
+    if ((*(u16 *)(param_1 + 0x100) & 3) == 0) {
+        func_8002D4C8(0xA9F, 0);
+    }
+    if (func_8012BEE8(param_1) != 0) {
+        func_8012C218((void *)param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80187C1C);
 
@@ -7144,7 +7355,15 @@ void func_8018ABE8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018AE6C);
+void func_8018AE6C(s32 *a0) {
+    s32 v1 = *(s32 *)((u8 *)a0 + 0xCC);
+    *(s16 *)((u8 *)a0 + 0x5C) = 0;
+    *(s16 *)((u8 *)a0 + 0xFC) = 0x1E;
+    *(s16 *)((u8 *)v1 + 0x5C) = 0;
+    v1 = *(s32 *)((u8 *)a0 + 0xD0);
+    *(s16 *)((u8 *)v1 + 0x5C) = 0;
+}
+
 
 
 extern void func_8012B1B4(void*, void*);
@@ -7184,7 +7403,30 @@ void func_8018AE8C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018AF8C);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_8018AF8C(s32 a0) {
+    extern u8 D_801CA1A8[];
+    extern u8 D_801CA2A8[];
+    extern u8 D_801CA3A8[];
+    s16 var;
+
+    var = *(s16 *)(a0 + 0x100);
+    if (var != 0) goto dec;
+    *(u16 *)(a0 + 2) = 1;
+    *(s16 *)(a0 + 0x100) = 0x3C;
+    func_8012A828(a0, D_801CA1A8);
+    if (*(s32 *)(a0 + 0xCC) != 0) {
+        func_8012A828(*(s32 *)(a0 + 0xCC), D_801CA2A8);
+    }
+    if (*(s32 *)(a0 + 0xD0) != 0) {
+        func_8012A828(*(s32 *)(a0 + 0xD0), D_801CA3A8);
+    }
+    return;
+dec:
+    *(s16 *)(a0 + 0x100) = var - 1;
+}
+
 
 
 extern void func_8012B370(int a0);
@@ -8129,7 +8371,21 @@ extern void func_8018BA4C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018C8D4);
+extern void func_80131E00(s32, s32);
+extern void func_8018BA4C(void);
+
+void func_8018C8D4(s32 a0)
+{
+    if (*(s16 *)(a0 + 0x76) < 0) {
+        func_80131E00(a0, 6);
+    } else {
+        *(s16 *)(a0 + 0x2) = 1;
+        *(s16 *)(a0 + 0x100) = 0x3C;
+        *(u16 *)(a0 + 0x34) = 0;
+        func_8018BA4C();
+    }
+}
+
 
 
 extern int func_80143C74(short*, int);
@@ -8176,7 +8432,26 @@ extern void func_8018B878(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018CA6C);
+extern void func_801319E0(s32 a0);
+extern s32  func_8012BEE8(s32 a0);
+extern void func_80131E00(int a0, int a1);
+extern s32  func_8012CBF4(s32 a0);
+extern void func_80131C78(s32 a0);
+extern void func_8018B878(void);
+
+void func_8018CA6C(s32 a0) {
+    if (*(s16 *)(a0 + 0xA) >= 0x10) {
+        func_801319E0(a0);
+    } else if (func_8012BEE8(a0) != 0) {
+        func_80131E00(a0, 6);
+    } else {
+        if (func_8012CBF4(a0) & 0x2000) {
+            func_80131C78(a0);
+        }
+        ((void (*)(s32))func_8018B878)(a0);
+    }
+}
+
 
 
 extern s32 func_8012C354(s32 a0, s32 a1);
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
index 56c1b436b8..b2cd9c1efb 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -3597,7 +3597,12 @@ void func_8017CDF0(s32 a0, s32 a1, s32 a2)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017D8C4);
+extern void func_8002931C();
+
+void func_8017D8C4(void) {
+    ((void (*)(int))func_8002931C)(0x4740000);
+}
+
 
 
 extern void (*D_801860B8[])(void);
@@ -3639,7 +3644,22 @@ s32 func_8017D9C4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017D9E0);
+s32 func_8017D9E0(void *a0) {
+    s32 v0;
+    s32 v1 = -1;
+    v0 = *(s32 *)(a0 + 0x28);
+    v0 += -1;
+    *(s32 *)(a0 + 0x28) = v0;
+    if (v0 == v1) {
+        func_8002D4C8(0x1C, 0);
+        func_8001BFD0();
+        func_8002D4C8(0x1D, 0);
+        func_800167B8(4);
+        *(u8 *)(a0 + 0x15) = *(u8 *)(a0 + 0x15) + 1;
+    }
+    return 0;
+}
+
 
 extern int func_800167F0(int arg);
 int func_8017DA54(void) {
@@ -3730,7 +3750,17 @@ extern s32 D_801D0598;
     }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017DF94);
+extern s32 *D_80186150[];
+extern s32 D_801861C8[];
+
+void func_8017DF94(s32 arg0, s16 *arg1, s32 arg2) {
+    *(s32 *)(D_80186150[arg0] + 6) = arg1[0];
+    *(s32 *)(D_80186150[arg0] + 7) = arg1[1];
+    *(s32 *)(D_80186150[arg0] + 8) = arg1[2];
+    *D_80186150[arg0] = 0;
+    D_801861C8[arg0] = arg2;
+}
+
 
 s32 func_8017DFF4(void) {
         return 0x86;
@@ -3794,11 +3824,47 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E0B0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8013C9C4(void *a0);
+extern u8 D_801862AC[];
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E118);
+s32 func_8017E0B0(s32 arg0)
+{
+    if (func_8012BEE8(arg0) != 0) {
+        func_8002D4C8(4, 0xB70);
+        return 1;
+    }
+    if ((*(u32 *)(arg0 + 0x1C) & 7) == 0) {
+        func_8013C9C4(D_801862AC);
+    }
+    return 0;
+}
+
+
+extern void func_8017DF84(s32 arg0);
+extern void func_80180854(void);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u16 D_801D0BB8;
+
+void func_8017E118(s32 arg0)
+{
+    func_8017DF84(0);
+    D_801D0BB8 |= 1;
+    func_80180854();
+    *(s32 *)(arg0 + 0xCC) = func_8012C658(0x3B3, 0, arg0);
+    *(s32 *)(arg0 + 0xD0) = func_8012C658(0x3B3, 1, arg0);
+    func_8002D4C8(0xB74, 0);
+    *(s32 *)(arg0 + 0x1C) = 0x20;
+    *(s16 *)(arg0 + 0x34) = 3;
+}
+
+
+s32 func_8017E1A8(s32 arg0) {
+    return *(s16 *)(arg0 + 0xE) >= 0x1C1;
+}
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E1A8);
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E1BC);
 
@@ -3806,7 +3872,16 @@ INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E20
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E268);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E3A4);
+extern u16 D_80126B66;
+extern void func_80142454(s32 a0);
+
+void func_8017E3A4(void *a0) {
+    if (*(s16 *)((s32)a0 + 0x100) == 0 && *(s16 *)&D_80126B66 >= 0x2E41) {
+        (*(s16 *)((s32)a0 + 0x100))++;
+        func_80142454(-0x80);
+    }
+}
+
 
 
 s32 func_8017E3F0(s32 arg0) {
@@ -3901,7 +3976,14 @@ void func_8017E7E8(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E804);
+void func_8017E804(s32 *a0, s32 a1, s32 a2) {
+    s32 v = a0[6];
+    if (v < a1)
+        a0[6] = v + a2;
+    else if (v > a1)
+        a0[6] = v - a2;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E830);
 
@@ -3917,14 +3999,77 @@ void func_8017EBC4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017EC00);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern u32 D_80186250[];
+extern s32 D_801B0A20;
+extern u16 D_801D0BB8;
+extern void func_8017DFFC(void);
+extern void func_80180440(s32 arg0);
+
+void func_8017EC00(s32 a0) {
+    s32 s0 = a0;
+    s32 v1;
+    s32 v0;
+
+    if (func_8012C354(a0, (s32)D_80186250) != 0) {
+        *(u8 *)(s0 + 0xC0) = 1;
+        *(s32 *)(s0 + 0xB4) = -1;
+        *(s16 *)(s0 + 0xAE) = -1;
+        func_8001D0E8(*(s32 *)(s0 + 0x20), 0x280, 0x1E0);
+        func_8012A828(s0, &D_801B0A20);
+        v1 = *(s32 *)(s0 + 0x20);
+        v0 = *(u16 *)(v1 + 0x2C);
+        (*(s16 *)&D_801D0BB8) = 0;
+        *(u16 *)(v1 + 0x2C) = v0 | 0x10;
+        v1 = *(s32 *)(s0 + 0x20);
+        *(u16 *)(v1 + 0x1C) = 0x1C00;
+        *(u16 *)(v1 + 0x1A) = 0x1C00;
+        *(u16 *)(v1 + 0x18) = 0x1C00;
+        func_80180440(s0);
+        ((void (*)(s32))func_8017DFFC)(s0);
+    }
+}
+
 
 void func_8017ECAC(void) {
 }
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017ECB4);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017ED8C);
+void func_8017ED8C(s32 arg0)
+{
+    extern void func_8017E658(void *);
+    extern void func_8017E830(void *);
+    extern void func_8017E20C(void *);
+    extern u16 D_80126B62;
+    extern u16 D_80126B66;
+    extern s32 D_80126B58;
+
+    s32 s0 = arg0;
+    s32 v1;
+    s32 a0;
+    s32 anchor;
+
+    (void)&anchor;
+    ((void (*)(void *))func_8017E658)(s0);
+    v1 = *(s16 *)((u8 *)s0 + 0xE);
+    a0 = v1;
+    v1 = v1 + 0x40;
+    if ((s16)D_80126B66 < v1) {
+        D_80126B66 = a0 + 0x40;
+    }
+    ((void (*)(void *))func_8017E830)(s0);
+    if ((s16)D_80126B66 >= 0x2D80) {
+        if ((s16)D_80126B62 < -0x5E1) {
+            if ((u16)((*(u16 *)&D_80126B58) - 2) >= 2) {
+                ((void (*)(void *))func_8017E20C)(s0);
+            }
+        }
+    }
+}
+
 
 void func_8017EE38(void) {
 }
@@ -3943,7 +4088,21 @@ INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017EEC
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017EEE0);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F044);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B200(u8 *a0);
+extern void func_8017F888(s32 *a0, s32 *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void D_801BCCAC;
+extern void D_80186558;
+
+void func_8017F044(s32 a0) {
+    s32 s0 = a0;
+    func_8012A828(s0, (void *)&D_801BCCAC);
+    func_8012B200((u8 *)s0);
+    func_8017F888((s32 *)s0, (s32 *)&D_80186558);
+    func_8012AD44((s32 *)s0, 4);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F098);
 
@@ -4033,7 +4192,7 @@ void func_801801C4(void *a0) {
 
 
 extern u16 D_80186764[];
-extern void func_801803F0(void *a0, void *a1);
+extern void func_801803F0();
 
 void func_80180200(void *a0) {
     struct { s16 x; s16 y; s16 z; } sp;
@@ -4064,7 +4223,20 @@ void func_80180200(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801802E4);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801803F0);
+extern u8 *func_801290DC();
+
+void func_801803F0() {
+    u8 *rec;
+    s32 r;
+
+    rec = func_801290DC(0x22);
+    if (rec != NULL) {
+        *(s32 *)(rec + 0x34) = 0x4000;
+        r = rand();
+        *(s32 *)(rec + 0x14) = -((r & 0x3FF0 | 0x8000) << 4);
+    }
+}
+
 
 
 extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
@@ -4120,9 +4292,35 @@ void func_80180584(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801805C0);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180704);
+extern s32 rand(void);
+
+void func_80180704(void *a0) {
+    s32 v0;
+
+    *(s32 *)((u8 *)a0 + 0x10) = (*(s16 *)((u8 *)a0 + 6) - *(s16 *)(*(s32 *)((u8 *)a0 + 0x64) + 6)) << 11;
+    *(s32 *)((u8 *)a0 + 0x14) = ((*(s16 *)((u8 *)a0 + 0xA) - *(s16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xA)) << 10) - 0x200000;
+    v0 = rand() & 0xFF;
+    *(s32 *)((u8 *)a0 + 0x18) = ((*(s16 *)((u8 *)a0 + 0xE) - *(s16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xE)) + v0 - 0x80) << 12;
+}
+
+
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_80180790(s32 self) {
+    s32 obj;
+    char *prim;
+
+    obj = func_80132EF4(self, 0x22);
+    if (obj != 0) {
+        prim = *(char **)(obj + 0x20);
+        *(s32 *)(obj + 0x34) = 0x7002;
+        *(u16 *)(prim + 0x2C) = 0xC020;
+        *(s32 *)(obj + 0x10) = (*(s32 *)(self + 0x10) >> 2) * 3;
+        *(s32 *)(obj + 0x14) = *(s32 *)(self + 0x14) >> 2;
+        *(s32 *)(obj + 0x18) = (*(s32 *)(self + 0x18) >> 2) * 3;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180790);
 
 
 extern void (*D_80186858[])(void);
@@ -4178,13 +4376,41 @@ void func_8018091C(void *a0, void *a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8018096C);
+void func_8018096C(void *a0) {
+    *(s32 *)((s32)a0 + 0x10) = *(s16 *)((s32)a0 + 0x06) << 13;
+    *(s32 *)((s32)a0 + 0x14) = (*(s16 *)((s32)a0 + 0x0A) + 0x400) << 13;
+    *(s32 *)((s32)a0 + 0x18) = (*(s16 *)((s32)a0 + 0x0E) - 0x180) * 3 << 13;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801809A4);
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180A3C);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180AA4);
+extern s16 D_801D0B7C;
+extern void func_8017EEC0(void);
+void func_80180AA4(void *a0) {
+    s32 a1;
+    s32 v1;
+    short v;
+    a1 = *(s32 *)(a0 + 0x20);
+    v = *(s16 *)(a1 + 0x12);
+    if (v != 0) {
+        *(s16 *)(a1 + 0x12) = v - 0x100;
+        v1 = *(s32 *)(a0 + 0x20);
+        if (*(s16 *)(v1 + 0x12) < 0) {
+            *(s16 *)(v1 + 0x12) = 0;
+        }
+        if (*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) == 0) {
+            D_801D0B7C = 1;
+        }
+    } else {
+        if (*(u16 *)&D_801D0B7C == 2) {
+            func_8017EEC0();
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180B3C);
 
@@ -4330,7 +4556,20 @@ INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801814B
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80181528);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_801815F8);
+extern s32 func_8012BEE8(s32 arg0);
+extern void func_8012C218(void *arg0);
+extern void func_8012AD80(s32 arg0);
+
+void func_801815F8(s32 param) {
+    if (func_8012BEE8(param) != 0) {
+        func_8012C218((void *)param);
+    } else {
+        func_8012AD80(param);
+        *(u16 *)(*(s32 *)(param + 0x20) + 0x10) += *(u16 *)(param + 0x106);
+        *(u16 *)(*(s32 *)(param + 0x20) + 0x14) += *(u16 *)(param + 0x108);
+    }
+}
+
 
 
 extern void (*D_80186860[])(void);
diff --git a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
index b3a5f6d605..6fac23cd30 100644
--- a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
+++ b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
@@ -4054,7 +4054,13 @@ void func_8017D688(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D6C4);
+void func_8017D6C4(s32 *a0) {
+    func_8017DCB8(2);
+    func_80171A80(a0, 0x12C);
+    *(s16 *)((s32)a0 + 0x20C) = 0;
+    func_80171990((u8 *)a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D708);
 
@@ -4096,13 +4102,46 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D97
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D9CC);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DA30);
+extern void func_80147324(s32 a0);
+extern void func_8013C9C4(void *a0);
+extern void func_8017EBB8(void *a0, void *a1);
+extern void func_8017F5FC(s16);
+extern s32 func_80171990(u8 *a0);
+extern u8 D_80185B70[];
+extern s32 D_80185C10;
+
+void func_8017DA30(void *arg0) {
+    if (*(u16 *)((s32)arg0 + 0xB8) & 0x4000) {
+        func_80147324(0xC12);
+        func_8013C9C4(&D_80185C10);
+    }
+    if (*(u16 *)((s32)arg0 + 0xB8) & 0x8000) {
+        func_8017EBB8((void *)3, D_80185B70);
+        func_8017EBB8((void *)4, D_80185B70);
+        ((void (*)(s32))func_8017F5FC)(0);
+        ((void (*)(s32))func_8017F5FC)(1);
+        func_80171990(arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DAD0);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DB14);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DC10);
+extern void func_80016450(s32 a0, s32 a1);
+extern s32 func_80171A88(s32 a0);
+extern void func_80171928(void *a0);
+extern void func_8017DCB8(s32 a0);
+
+void func_8017DC10(void *arg0) {
+    func_80016450((*(s32 *)((char *)arg0 + 0x200) << 1) & 0xFE, 0);
+    if (func_80171A88((s32)arg0) != 0) {
+        func_8017DCB8(7);
+        func_80171928(arg0);
+    }
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017DC68(void) {
@@ -4138,7 +4177,36 @@ s32 func_8017DCC8(void) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DCD8);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017DDA0);
+
+
+void func_8017DDA0(s32 *a0) {
+    extern u8 D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    extern void func_8017DE68(void *a0);
+    extern Blob8_8018A47C_8017DEA4 D_801274E8;
+    extern Blob8_8018A47C_8017DEA4 D_80185C64;
+
+    D_801274E8 = D_80185C64;
+    D_80126954 = 0x190;
+    D_8012695C = 0x190;
+    D_80126968 = 0x38;
+    D_8012696A = 0x400;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x10;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017DE68, 0);
+    func_8012A094((s32)D_80126948);
+    func_8017DE68((void *)D_80126948);
+}
+
 
 
 
@@ -4253,7 +4321,26 @@ void func_8017E298(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E2D4);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E374);
+extern u16 D_800B99DA;
+extern void func_8017E70C(s32 a0);
+
+void func_8017E374(s32 a0) {
+    s32 v0;
+    s32 s0;
+    s0 = a0;
+    v0 = func_8017DCC8();
+    if (v0 == 2) {
+        if ((D_800B99DA & 3) == 0) {
+            func_8017E70C(s0);
+        }
+    }
+    v0 = func_8017DCC8();
+    if (v0 == 3) {
+        *(s16*)(s0 + 0x100) = 0x80;
+        func_8012AD44((s32*)s0, 2);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E3EC);
 
@@ -4278,9 +4365,24 @@ void func_8017E854(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E890);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E900);
+extern s16 D_800B9ABA;
+
+void func_8017E900(void *a0) {
+    D_800B9ABA = 0xF0;
+    *(s16 *)((s32)a0 + 0xA) = 0xF0;
+}
+
+
+void func_8017E914(void *a0) {
+
+    extern void (*D_80185DB8[])(void);
+    D_80185DB8[*(u16 *)((s32)a0 + 0x2)]();
+
+    if (a0 != 0 && *(s32 *)((s32)a0 + 0x20) != 0) {
+        func_8012B2CC((s32)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E914);
 
 extern s32 func_8012AD50(void*);
 void func_8017E97C(void) {
@@ -4290,7 +4392,39 @@ void func_8017E97C(void) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E99C);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017EAF4);
+void func_8017EAF4(s32 arg0) {
+    extern u16 D_800B99DA;
+    extern void func_8012AD80(s32 a0);
+    extern s32 func_8012BEE8(s32 a0);
+    extern u8 *func_8012913C(s32 a0);
+    extern void func_8012C098(void *a0);
+    register s32 pv __asm__("$16") = arg0;
+    register s32 wp __asm__("$17");
+    u16 flag;
+    u8 *a;
+    s32 t;
+
+    flag = D_800B99DA;
+    wp = *(s32 *)(pv + 0x20);
+    if ((flag & 3) == 0) {
+        a = func_8012913C(0x75);
+        if (a != 0) {
+            *(s32 *)(a + 4) = *(s32 *)(pv + 4);
+            *(s32 *)(a + 8) = *(s32 *)(pv + 8);
+            t = *(s32 *)(pv + 0xC);
+            *(s32 *)(a + 0x34) = 1;
+            *(s32 *)(a + 0xC) = t;
+        }
+    }
+    *(u16 *)(wp + 0x10) += 0x38;
+    *(u16 *)(wp + 0x12) += 0x71;
+    *(u16 *)(wp + 0x14) += 0x5B;
+    func_8012AD80(pv);
+    if (func_8012BEE8(pv) != 0) {
+        func_8012C098((void *)pv);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017EBB8);
 
@@ -4391,13 +4525,23 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F1C
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F214);
 
-extern void func_8017F2BC(void);
+extern void func_8017F2BC();
 void func_8017F29C(void) {
     func_8017F2BC();
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F2BC);
+extern u32 D_801A7D0C[];
+extern u16 D_800B99DA;
+
+void func_8017F2BC(s16 *arg0) {
+    u32 *dst = (u32 *)((u8 *)D_801A7D0C + ((s32)arg0[0x38] << 6));
+    if (D_800B99DA & 1)
+        *dst = 0xC0C0C0;
+    else
+        *dst = 0xFFFFFF;
+}
+
 
 extern s32 func_8012AD50(void*);
 void func_8017F2FC(void) {
@@ -4426,11 +4570,28 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F4A
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F51C);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F54C);
+extern void func_8017F5A4(void *a0, s32 a1);
+
+s32 func_8017F54C(void *a0, void *a1) {
+    func_8017F5A4(a0, *(s16 *)a1);
+    func_8017F5A4((s8 *)a0 + 4, *((s16 *)a1 + 1));
+    return (*(u32 *)a0 | *(u32 *)((s8 *)a0 + 4)) == 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F5A4);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F5FC);
+extern s32 func_8012C588(s32 a0, s32 a1);
+
+void func_8017F5FC(s16 param_1)
+{
+    s32 v0;
+    v0 = func_8012C588(0x3AA, 0);
+    if (v0 != 0) {
+        *(s16 *)(v0 + 0xFC) = param_1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F638);
 
@@ -4444,7 +4605,15 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F79
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F860);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017FA24);
+void func_8017FA24(void *a0) {
+    extern s32 D_80185C70[];
+    u16 idx;
+
+    idx = *(u16 *)((s32)a0 + 0x18);
+    *(u16 *)((s32)a0 + 0x18) = idx + 1;
+    *(s32 *)((s32)a0 + 0x14) = D_80185C70[idx & 7];
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017FA50);
 
@@ -4508,9 +4677,26 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018013
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801802CC);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180378);
+extern void func_80180674(s32, s16);
+
+void func_80180378(void *a0) {
+    s32 *s0 = *(s32 **)((s32)a0 + 0x20);
+    if (func_8017DCC8() == 6) {
+        *(u16 *)((s32)s0 + 0x12) = 0x400;
+        *(s32 *)((s32)s0 + 4) &= 0x7FFFFFFF;
+        ((void (*)(void *, s32))func_80180674)(a0, 0x80);
+        func_8012AD50(a0);
+    }
+}
+
+
+void func_801803E8(s32 *a0) {
+    if (func_8017DCC8() == 7) {
+        func_8012BF4C(a0, 30);
+        func_8012AD50(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801803E8);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018042C);
 
@@ -4522,9 +4708,30 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018059
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801805E4);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018062C);
+extern void func_80180694(s32 a0);
+extern s32 func_80180A98(s32 a0);
+extern void func_8017DCB8(s32 a0);
+extern void func_8012C098(void *a0);
+
+void func_8018062C(s32 a0) {
+    func_80180694(a0);
+    if (func_80180A98(a0) != 0) {
+        func_8017DCB8(0xA);
+        func_8012C098((void *)a0);
+    }
+}
+
+
+extern s16 D_801A9250;
+extern s16 D_801A924E;
+extern s16 D_801A924C;
+
+void func_80180674(s32 a0, s16 a1) {
+    D_801A9250 = a1;
+    D_801A924E = a1;
+    D_801A924C = a1;
+}
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180674);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180694);
 
@@ -4534,7 +4741,21 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018078
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180834);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180894);
+void func_80180894(s32 arg0) {
+    register s32 s0 __asm__("$16") = arg0;
+    s32 v0, v1;
+    func_80180944(arg0);
+    v1 = *(s32 *)(s0 + 0x20);
+    v0 = *(u16 *)(v1 + 0x12);
+    v0 += 0x10;
+    *(u16 *)(v1 + 0x12) = v0;
+    v0 = func_8012BEE8(s0);
+    if (v0 != 0) {
+        func_80180A50(s0);
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801808F0);
 
@@ -4550,13 +4771,44 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180CD
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180D30);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180DC4);
+
+extern void func_80181204(A801593E4 *a0);
+extern void func_80181224(void);
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_8012AD50(void *a0);
+
+void func_80180DC4(A801593E4 *a0) {
+    void *s1 = *(void **)((u8 *)a0 + 0x20);
+    func_80181204(a0);
+    ((void (*)(A801593E4 *))func_80181224)(a0);
+    if (func_8012BEE8((s32)a0) != 0) {
+        if (*(s16 *)((u8 *)a0 + 0xFC) != 0) {
+            if (*(s16 *)((u8 *)s1 + 0x12) >= 0x400) {
+                *(s16 *)((u8 *)s1 + 0x12) = 0x400;
+                *(s16 *)((u8 *)a0 + 0xFC) = 0;
+                func_8012AD50((void *)a0);
+            }
+        } else {
+            if (*(s16 *)((u8 *)s1 + 0x12) < 0x400) {
+                *(s16 *)((u8 *)a0 + 0xFC) = 1;
+            }
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80180E68);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801810F8);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801811C8);
+void func_801811C8(s32 arg0) {
+    u16 temp;
+    arg0 = *(s32 *)(arg0 + 0x20);
+    temp = *(u16 *)(arg0 + 0x1A);
+    *(s16 *)(arg0 + 0x1C) = temp;
+    *(s16 *)(arg0 + 0x18) = (((s32)(s16)temp << 7) / 94);
+}
+
 
 void func_80181204(A801593E4 *a0) {
     S801593E4 *v1 = a0->p20;
@@ -4588,21 +4840,95 @@ void func_801813D0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801813F8);
+void func_801813F8(void *a0, void *a1, void *a2) {
+    u16 var;
+    var = *(u16 *)((s32)a1 + 6);
+    *(u16 *)((s32)a1 + 0) = 0;
+    *(u16 *)((s32)a1 + 2) = var;
+    *(s32 *)((s32)a2 + 0) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018140C);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181534);
+extern s32 func_8017DCC8(void);
+extern void func_800167B8(s32 a0);
+extern s32 func_8012AD50(void *a0);
+
+void func_80181534(void *a0) {
+    if (func_8017DCC8() == 11) {
+        func_800167B8(4);
+        func_8012AD50(a0);
+    }
+}
+
+
+extern u16 D_800AF7CE;
+extern u8 D_800B9A11;
+extern s32 D_800B9A18;
+void func_80181578(void *arg0) {
+    u16 v0;
+    v0 = D_800AF7CE;
+    D_800AF7CE = v0 + 4;
+    if ((u16)(v0 + 4) < 0xFF) {
+    } else {
+        D_800AF7CE = 0xFF;
+    }
+    func_80016224((u8)D_800AF7CE, 0);
+    if (D_800AF7CE == 0xFF) {
+        func_8017DCB8(0xC);
+        func_800167B8(0);
+        D_800B9A11 = 1;
+        func_800146B0(7);
+        D_800B9A18 = 0;
+        func_8012AD50(arg0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181578);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181620);
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8018165C);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_801816D4);
+extern s32 func_80014D94();
+extern s32 func_8012AD50(void *a0);
+extern void func_801817D0();
+extern s16 D_800B9A02;
+
+void func_801816D4(void *a0) {
+    if ((func_80014D94(0) & 0xF0) != 0) {
+        func_8012AD50(a0);
+    }
+    func_801817D0(*(u16 *)&D_800B9A02, *(s16 *)((s32)a0 + 0xFC));
+}
+
+
+void func_80181728(void *a0) {
+    extern void func_801817D0();
+    extern void func_800146B0(s32 a0);
+    extern void func_800D1724(s32 a0);
+    extern s32 func_8012AD50(void *a0);
+    extern short D_800B9A02;
+    extern s32 D_800B9A18;
+    extern u8 D_80078E78[];
+    extern void (*D_801859D0)(void *);
+    u16 v;
+
+    v = *(u16 *)((s32)a0 + 0xFC) - 4;
+    *(u16 *)((s32)a0 + 0xFC) = v;
+    if ((s16)v < 0) {
+        *(u16 *)((s32)a0 + 0xFC) = 0;
+    }
+    func_801817D0(*(u16 *)&D_800B9A02, *(s16 *)((s32)a0 + 0xFC));
+    if (*(s16 *)((s32)a0 + 0xFC) == 0) {
+        func_800146B0(1);
+        D_800B9A18 = 2;
+        *(u32 *)&D_80078E78 = 1;
+        func_800D1724((s32)&D_801859D0);
+        func_8012AD50(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181728);
 
 void func_801817C8(void) {
 }
@@ -4622,7 +4948,32 @@ void func_80181B2C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181B98);
+extern s32 func_8001CC3C(s32, s32, s32, s32);
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+extern u8 D_800D387C[];
+extern void (*D_80185FD0)(void);
+
+void func_80181B98(s32 param_1)
+{
+    s32 work;
+    s32 val;
+    s32 res;
+
+    work = *(s32 *)(param_1 + 0x20);
+    ((void (*)(s32, s32, s32, s32))func_8001CC3C)(work, D_800D387C, 0, 0);
+    *(u8 *)(work + 0x27) = 0x9C;
+    *(s32 *)(work + 4) = *(s32 *)(work + 4) | 0x50000000;
+    val = *(s32 *)(param_1 + 0x2C);
+    *(u8 *)(work + 0x24) = 0xC0;
+    *(u8 *)(work + 0x25) = 0x40;
+    *(u8 *)(work + 0x26) = 0x20;
+    res = ((8 - val) * 3) << 9;
+    *(u16 *)(work + 0x1A) = res;
+    *(u16 *)(work + 0x18) = res;
+    func_80128EA8(work, param_1 + 0x24, &D_80185FD0);
+    *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181C54);
 
@@ -4641,7 +4992,25 @@ void func_80181E20(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181E5C);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181EEC);
+extern s32 func_80128ED8(s32 param_1, s32 *param_2);
+extern void func_801292C8(u8 *a0);
+
+void func_80181EEC(int param_1)
+{
+    int base;
+    unsigned short *p;
+    unsigned short val;
+
+    base = *(int *)(param_1 + 0x20);
+    p = (unsigned short *)(base + 0x1A);
+    val = *p - 0x100;
+    p[0] = val;
+    p[-1] = val;
+    if (func_80128ED8(base, (s32 *)(param_1 + 0x24)) != 0) {
+        func_801292C8((u8 *)param_1);
+    }
+}
+
 
 
 
diff --git a/src/shared/engine_core.h b/src/shared/engine_core.h
index 706e286b09..9dba809c9d 100644
--- a/src/shared/engine_core.h
+++ b/src/shared/engine_core.h
@@ -59945,7 +59945,7 @@
     extern char D_801A668C[]; \
     extern void func_8017F5A0(int param_1); \
     extern s32 D_801A72C4; \
-    extern void func_8017F5E4(s32 param_1); \
+    extern void func_8017F5E4(); \
     extern void func_8017FC9C(void *a0); \
     extern s32 D_801270CC; \
     extern void func_8012C098(void); \
@@ -65040,7 +65040,7 @@
     extern char D_801A668C[]; \
     extern void func_8017F5A0(int param_1); \
     extern s32 D_801A72C4; \
-    extern void func_8017F5E4(s32 param_1); \
+    extern void func_8017F5E4(); \
     extern void func_8017FC9C(void *a0); \
     extern s32 D_801270CC; \
     extern void func_8012C098(void); \
@@ -155343,7 +155343,7 @@
     extern char D_801A668C[]; \
     extern void func_8017F5A0(int param_1); \
     extern s32 D_801A72C4; \
-    extern void func_8017F5E4(s32 param_1); \
+    extern void func_8017F5E4(); \
     extern void func_8017FC9C(void *a0); \
     extern s32 D_801270CC; \
     extern void func_8012C098(void); \
@@ -160438,7 +160438,7 @@
     extern char D_801A668C[]; \
     extern void func_8017F5A0(int param_1); \
     extern s32 D_801A72C4; \
-    extern void func_8017F5E4(s32 param_1); \
+    extern void func_8017F5E4(); \
     extern void func_8017FC9C(void *a0); \
     extern s32 D_801270CC; \
     extern void func_8012C098(void); \