From 4bfb94cc8e4ee1e8a1d2786cd2c0235b3d31ff9c Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Sun, 23 Aug 2026 07:09:48 -0600
Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20ae=20=E2=80=94=2017?=
 =?UTF-8?q?7=20banked\n\nCard-fuelled=20ox=20drafts,=20reloc=5Fidentity=20?=
 =?UTF-8?q?pre-filtered,=20gated=20via=20sweep=5Fparallel.\nfunc=5F8017D68?=
 =?UTF-8?q?4=20func=5F8017DAA8=20func=5F8017DF5C=20func=5F8017E1D8=20func?=
 =?UTF-8?q?=5F8017E400=20func=5F8017E424=20func=5F8017E568=20func=5F8017E5?=
 =?UTF-8?q?9C=20func=5F8017E5C0=20func=5F8017ED18=20func=5F8017EE90=20func?=
 =?UTF-8?q?=5F8017EF34=20func=5F8017FBA0=20func=5F801800A4=20func=5F801800?=
 =?UTF-8?q?F4=20func=5F80180580=20func=5F801805C4=20func=5F80180730=20func?=
 =?UTF-8?q?=5F80180A48=20func=5F80180B38=20func=5F80180C6C=20func=5F80180C?=
 =?UTF-8?q?E8=20func=5F80180D5C=20func=5F80180E74=20func=5F80180EC8=20func?=
 =?UTF-8?q?=5F80180F38=20func=5F80181280=20func=5F80181384=20func=5F801813?=
 =?UTF-8?q?A8=20func=5F801813CC=20func=5F8018141C=20func=5F8018144C=20func?=
 =?UTF-8?q?=5F80181470=20func=5F80181494=20func=5F80181730=20func=5F801817?=
 =?UTF-8?q?D0=20func=5F80181960=20func=5F80181AA8=20func=5F80181B28=20func?=
 =?UTF-8?q?=5F80181DFC=20=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/ov_SC02_000/ov_SC02_000_jr_8018173C.c | 714 +++++++++++++++++--
 src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c | 101 ++-
 src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c | 829 ++++++++++++++++++++--
 src/ov_SC06_029/ov_SC06_029_jr_8017C954.c | 759 ++++++++++++++++++--
 src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c | 707 ++++++++++++++++--
 src/shared/engine_core.h                  |  12 +-
 6 files changed, 2931 insertions(+), 191 deletions(-)

diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c b/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c
index d4bc184de..588a98049 100644
--- a/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c
+++ b/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c
@@ -2800,9 +2800,38 @@ DEFINE_func_80181934()  /* dedup: shared engine-core @0x80181934 (src/shared) */
 DEFINE_func_801819F4()  /* dedup: shared engine-core @0x801819F4 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80181A94);
+void func_80181A94(void) {
+    extern u8 D_80126948[];
+    extern void func_80181AD4(u8 *a0);
+    extern void func_8012A094(s32 a0);
+    extern void func_80181D2C(u8 *a0);
+    func_80181AD4(D_80126948);
+    func_8012A094((s32)D_80126948);
+    func_80181D2C(D_80126948);
+}
+
+
+extern u16 D_80126B5E;
+extern s16 D_801274E8;
+extern void func_80181D2C(u8 *param_1);
+extern void func_8012A018(s32 a, s32 b);
+
+void func_80181AD4(void *arg0)
+{
+    D_801274E8 = D_80126B5E;
+    *(s32 *)((s32)arg0 + 0xC) = 0x12C;
+    *(s32 *)((s32)arg0 + 0x14) = 0x190;
+    *(s16 *)((s32)arg0 + 0x20) = 0x80;
+    *(s16 *)((s32)arg0 + 0x22) = 0x800;
+    *(s16 *)((s32)arg0 + 0x30) = -0x80;
+    *(s16 *)((s32)arg0 + 0x24) = 0;
+    *(s16 *)((s32)arg0 + 0x2E) = 0;
+    *(s16 *)((s32)arg0 + 0x32) = -0xC8;
+    *(s32 *)((s32)arg0 + 0x9C) = 0;
+    *(u8 *)((s32)arg0 + 0xA0) = 0;
+    func_8012A018((s32)func_80181D2C, 2);
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80181AD4);
 
 #include "common.h"
 
@@ -2937,7 +2966,19 @@ void func_80182154(void *a0) {
 DEFINE_func_80182190()  /* dedup: shared engine-core @0x80182190 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801821E8);
+#include "common.h"
+
+extern s32 func_800167F0(s32 a0);
+extern u8 D_80126D6C;
+
+s32 func_801821E8(void) {
+    if ((func_800167F0(0) & 0xFFFF) != 0) {
+        D_80126D6C += 1;
+        return 1;
+    }
+    return 0;
+}
+
 
 
 extern void (*D_8018EACC[])(void);
@@ -2980,7 +3021,19 @@ void func_80182414(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182450);
+extern void func_8016EDEC(s32 a0, s32 a1, s32 a2);
+extern void func_800167B8(s32 a0);
+extern void func_80183718(void *a0);
+extern s32 D_801E8770;
+
+s32 func_80182450(s32 param_1) {
+    D_801E8770 = 0;
+    ((void (*)(void *, s32))func_8016EDEC)((void *)func_80183718, 0xB000000);
+    func_800167B8(0);
+    *(u8 *)(param_1 + 0x15) = *(u8 *)(param_1 + 0x15) + 1;
+    return 0;
+}
+
 
 DEFINE_func_801824A8()  /* dedup: shared engine-core @0x801824A8 (src/shared) */
 
@@ -3001,13 +3054,46 @@ void func_801824E0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018251C);
+
+
+struct S;
+extern s32 func_800CF854(void);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_8014708C(void *arg0);
+extern s32 func_801472C8(struct S *a0);
+extern u8 D_800D5A34[];
+
+void func_8018251C(s32 param_1) {
+    if (((s32 (*)(s32))func_800CF854)(param_1) != 0) {
+        *(u8 *)(param_1 + 0x214) = 5;
+    } else {
+        func_80154274((s32 *)param_1, (s32)D_800D5A34);
+        func_8014708C((void *)param_1);
+        func_801472C8((struct S *)param_1);
+        *(u8 *)(param_1 + 0x4D) += 1;
+        *(u8 *)(param_1 + 0x214) += 1;
+    }
+}
+
 
 DEFINE_func_8018258C()  /* dedup: shared engine-core @0x8018258C (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182594);
+void func_80182594(void *a0) {
+    func_80146994(0x1A, (s32)a0, 0x4CC04CD, 0);
+    *(u8 *)((s32)a0 + 0x214) = *(u8 *)((s32)a0 + 0x214) + 1;
+}
+
+
+extern s32 func_8014C050(s32 a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+
+void func_801825E0(s32 a0) {
+    if (func_8014C050(a0, 0x1A) == 0) {
+        *(s32 *)(a0 + 0x198) = func_8013767C(*(s32 *)(a0 + 0x198));
+        *(u8 *)(a0 + 0x214) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801825E0);
 
 #include "common.h"
 
@@ -3038,7 +3124,17 @@ void func_801826C4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182700);
+extern void func_80171B44(s32 *a0);
+extern void func_80182744(s32 a0);
+
+void func_80182700(s32 a0)
+{
+    *(u8 *)(a0 + 0x214) = *(u8 *)(a0 + 0x214) + 1;
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = 0;
+    func_80171B44((s32 *)a0);
+    func_80182744(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182744);
 
@@ -3048,9 +3144,32 @@ extern void func_8016F0E4(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801827C0);
+void func_801827C0(void *a0) {
+
+    extern int func_8001AAA0();
+    extern void (*D_8018ED44[])(void *);
+
+    if (*(s16 *)((s32)a0 + 0x20E) < 0) {
+        if (((int (*)(s32))func_8001AAA0)(0x13) != 0) {
+            *(s16 *)((s32)a0 + 0x20E) = 0;
+        }
+    }
+    if (*(s16 *)((s32)a0 + 0x20E) > 0) {
+        *(s16 *)((s32)a0 + 0x20E) = *(s16 *)((s32)a0 + 0x20E) - 1;
+        if (*(s16 *)((s32)a0 + 0x20E) == 0) {
+            *(s16 *)((s32)a0 + 0x20E) = -1;
+        }
+    }
+    D_8018ED44[*(u8 *)((s32)a0 + 0x214)](a0);
+}
+
+
+void func_80182854(u8 *arg0) {
+    func_80175454();
+    func_801818C0();
+    *(u8 *)(arg0 + 0x214) = *(u8 *)(arg0 + 0x214) + 1;
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182854);
 
 #include "common.h"
 
@@ -3059,16 +3178,69 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018285
 DEFINE_func_80182894()  /* dedup: shared engine-core @0x80182894 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182964);
+void func_80182964(u8 *a0)
+{
+    s16 *p;
+    s32 r;
+    u8 v0;
+    u16 v1;
+
+    r = func_80012B04(((s16 **)a0)[8][9], 0xC00, 4);
+    if ((s16)r == 0) {
+        func_800D0C48(0);
+        v0 = a0[0x214];
+        v1 = *(u16 *)(a0 + 0xBA);
+        *(u32 *)(a0 + 0x204) = 0;
+        a0[0x20C] = 0;
+        a0[0x20D] = 0;
+        *(u16 *)(a0 + 0xB8) = v1;
+        a0[0x214] = v0 + 1;
+    }
+    p = ((s16 **)a0)[8];
+    ((u16 *)p)[9] = (((u16 *)p)[9] + r) & 0xFFF;
+}
+
 
 #include "common.h"
 
 DEFINE_func_801829F8()  /* dedup: shared engine-core @0x801829F8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182AE4);
+extern void func_801553A8(s32 *arg);
+extern void func_80147324(s32 arg);
+
+void func_80182AE4(void *a0) {
+    u16 flags = *(u16 *)((s32)a0 + 0xB8);
+    if (flags & 0x2000) {
+        func_801553A8((s32 *)a0);
+        func_80147324(0x445);
+    } else if (flags & 0x4000) {
+        *(u16 *)((s32)a0 + 0xD4) += 1;
+    }
+    if (*(u16 *)((s32)a0 + 0xB8) == 0x8000) {
+        *(u8 *)((s32)a0 + 0x214) += 1;
+        *(u8 *)((s32)a0 + 0x4D) -= 1;
+    }
+}
+
+
+extern s32 func_8001B23C(s32 a0);
+extern void func_8016F0E4(void);
+extern void func_801599A4(void *a0);
+extern void func_801553A8(s32 *a0);
+extern void func_8016EDEC(s32 a0, s32 a1, s32 a2);
+extern void func_80182D00(void *a0);
+
+void func_80182B74(s32 param_1) {
+    s32 s0 = param_1;
+    if (func_8001B23C(0)) {
+        ((void (*)(s32))func_8016F0E4)(s0);
+        func_801599A4((void *)s0);
+        func_801553A8((s32 *)s0);
+        ((void (*)(void *, s32))func_8016EDEC)((void *)func_80182D00, 0x1000000);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182B74);
 
 #include "common.h"
 
@@ -3128,9 +3300,45 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182D3
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182D84);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182E08);
+extern void func_80154274(s32 *a0, s32 a1);
+extern s32 D_800D4744;
+extern s32 D_801A7F50;
+extern s32 D_801A7FF0;
+
+void func_80182E08(void *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = M2C_FIELD(arg0, s32 *, 0x204) - 1;
+    M2C_FIELD(arg0, s32 *, 0x204) = temp_v0;
+    if (temp_v0 == -1) {
+        M2C_FIELD(arg0, s32 *, 0x204) = 0x40;
+        func_80154274(arg0, (s32)&D_800D4744);
+        M2C_FIELD(arg0, s32 *, 0xB0) = (s32)&D_801A7F50;
+        M2C_FIELD(arg0, s32 *, 0xCC) = (s32)&D_801A7FF0;
+        M2C_FIELD(arg0, u8 *, 0x4D) = (u8) (M2C_FIELD(arg0, u8 *, 0x4D) + 1);
+        M2C_FIELD(arg0, u8 *, 0x214) = (u8) (M2C_FIELD(arg0, u8 *, 0x214) + 1);
+    }
+}
+
+
+extern void func_801831A8(void*);
+extern void func_8002D4C8(s32 _arg0, s32 _arg1);
+
+void func_80182E84(s32 param_1) {
+    s32 temp_v0;
+
+    ((void (*)(s32))func_801831A8)(param_1);
+    temp_v0 = *(s32 *)(param_1 + 0x204) - 1;
+    *(s32 *)(param_1 + 0x204) = temp_v0;
+    if (temp_v0 != -1) {
+        return;
+    }
+    func_8002D4C8(4, 0x4E0);
+    *(s32 *)(param_1 + 0x204) = 0x40;
+    *(u8 *)(param_1 + 0x4D) = *(u8 *)(param_1 + 0x4D) - 1;
+    *(u8 *)(param_1 + 0x214) = *(u8 *)(param_1 + 0x214) + 1;
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182E84);
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182EEC);
 
@@ -3140,7 +3348,14 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80182F7
 
 DEFINE_func_80183010()  /* dedup: shared engine-core @0x80183010 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183018);
+void func_80183018(u8 *a0) {
+    func_801466F0(3, (s32)a0, 0, 0, 0, 0, 0, 1);
+    *(u8 *)(a0 + 0x4D) = *(u8 *)(a0 + 0x4D) + 1;
+    func_80154150((s32)a0, 0xF);
+    func_801477E8((s32 *)a0, 0);
+    *(u8 *)(a0 + 0x214) = *(u8 *)(a0 + 0x214) + 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183098);
 
@@ -3164,7 +3379,32 @@ void func_80183238(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183274);
+extern s32 func_800CF854(void);
+extern void func_800D1744(s32 *a0);
+extern void func_80183A78(s32 *a0);
+extern void func_80175414(s32 _arg0);
+extern s32 D_8018EA6C;
+extern s32 D_801A7F50;
+extern s32 D_801A7FF0;
+
+void func_80183274(s32 *a0) {
+    s32 v0;
+    func_8016F094(a0);
+    v0 = func_800CF854();
+    if (v0 != 0) {
+        ((void (*)(void))func_80175414)();
+    }
+    func_800D1744(&D_8018EA6C);
+    *(s16 *) ((s32) a0 + 0x136) = 2;
+    *(s32 *) ((s32) a0 + 0xB0) = (s32) &D_801A7F50;
+    *(s32 *) ((s32) a0 + 0xCC) = (s32) &D_801A7FF0;
+    *(s16 *) ((s32) a0 + 0x132) = 0;
+    *(s32 *) ((s32) a0 + 0x44) = *(s32 *) ((s32) a0 + 0x44) | 0x3000000;
+    func_80183A78(a0);
+    v0 = *(u8 *) ((s32) a0 + 0x214);
+    *(u8 *) ((s32) a0 + 0x214) = v0 + 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183310);
 
@@ -3184,13 +3424,56 @@ void func_80183574(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801835C8);
+void func_801835C8(void *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = M2C_FIELD(arg0, s32 *, 0x204) - 1;
+    M2C_FIELD(arg0, s32 *, 0x204) = temp_v0;
+    if (temp_v0 == -1) {
+        M2C_FIELD(arg0, s32 *, 0x204) = 0x30;
+        M2C_FIELD(arg0, u8 *, 0x214) = (u8) (M2C_FIELD(arg0, u8 *, 0x214) + 1);
+    }
+}
+
+
+void func_801835F8(void *arg0) {
+    s32 temp_v0;
+
+    M2C_FIELD(arg0, s16 *, 0x132) = 0x800;
+    if ((M2C_FIELD(arg0, s32 *, 0x204) & 0xF) == 0) {
+        M2C_FIELD(arg0, s16 *, 0xAC) = 0x40;
+        M2C_FIELD(arg0, s16 *, 0xAA) = 0x40;
+    }
+    temp_v0 = M2C_FIELD(arg0, s32 *, 0x204) - 1;
+    M2C_FIELD(arg0, s32 *, 0x204) = temp_v0;
+    if (temp_v0 == -1) {
+        func_80185F58();
+        M2C_FIELD(arg0, s32 *, 0x204) = 0x10;
+        M2C_FIELD(arg0, u8 *, 0x214) = (u8) (M2C_FIELD(arg0, u8 *, 0x214) + 1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801835F8);
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018366C);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801836C8);
+extern void func_8016F0E4(void);
+extern void func_8016EDEC(s32 a0, s32 a1, s32 a2);
+extern void func_80183718(void *a0);
+
+void func_801836C8(void *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = *(s32 *)((s32)arg0 + 0x204) - 1;
+    *(s32 *)((s32)arg0 + 0x204) = temp_v0;
+    if (temp_v0 == -1) {
+        *(u16 *)((s32)arg0 + 0x132) = 0;
+        *(u16 *)((s32)arg0 + 0xAC) = 0x40;
+        *(u16 *)((s32)arg0 + 0xAA) = 0x40;
+        func_8016F0E4();
+        ((void (*)(void *, s32))func_8016EDEC)((void *)func_80183718, 0xB000000);
+    }
+}
+
 
 
 extern void (*D_8018EDC0[])(void);
@@ -3243,7 +3526,16 @@ DEFINE_func_80183A78()  /* dedup: shared engine-core @0x80183A78 (src/shared) */
 DEFINE_func_80183A80()  /* dedup: shared engine-core @0x80183A80 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183B64);
+extern u8 D_800A5E94;
+extern u8 D_800A5E95;
+extern u8 D_800A5E96;
+
+void func_80183B64(s32 a0) {
+    *(u16 *)((s32)a0 + 0x20E) = D_800A5E94 << 8;
+    *(u16 *)((s32)a0 + 0x210) = D_800A5E95 << 8;
+    *(u16 *)((s32)a0 + 0x212) = D_800A5E96 << 8;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183BA4);
 
@@ -3284,7 +3576,18 @@ void func_80183C9C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183D80);
+typedef struct {
+    void (*fn[3])(void *);
+} Tbl_801E6CA4;
+
+extern Tbl_801E6CA4 D_801E6CA4;
+
+void func_80183D80(void *arg0) {
+    Tbl_801E6CA4 local = D_801E6CA4;
+    u16 idx = *(u16 *)((s32)arg0 + 2);
+    local.fn[idx](arg0);
+}
+
 
 #include "common.h"
 
@@ -3329,7 +3632,16 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183EB
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183F0C);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80183F64);
+extern void (*D_8018F1B4[])(void);
+extern void func_8013D064(void);
+
+void func_80183F64(void *a0) {
+    D_8018F1B4[*(u16 *)((s32)a0 + 0x2)]();
+    if (*(u16 *)((s32)a0 + 0x2) >= 0xA) {
+        func_8013D064();
+    }
+}
+
 
 #include "common.h"
 
@@ -3432,7 +3744,26 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018435
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018453C);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801847B8);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8018483C(s32 a0);
+extern u8 D_8018EDF4[];
+extern s32 D_801E8754;
+
+void func_801847B8(s32 a0) {
+    s32 val;
+
+    if ((*(s16 *)(a0 + 0xDC) -= 1) == 0) {
+        func_8012A828(a0, D_8018EDF4);
+        *(u16 *)(a0 + 0xDC) = 0x3C;
+        *(u16 *)(a0 + 0xDE) = 0xC;
+        val = *(u16 *)(a0 + 2);
+        D_801E8754 = 0x1E;
+        *(u16 *)(a0 + 2) = val + 1;
+    } else {
+        func_8018483C(a0);
+    }
+}
+
 
 #include "common.h"
 
@@ -3774,9 +4105,59 @@ DEFINE_func_80185364()  /* dedup: shared engine-core @0x80185364 (src/shared) */
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018537C);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801853D4);
+#include "common.h"
+
+extern u8  D_8018B358[];
+extern s32  func_80185C48(s32 a0, s32 a1);
+extern void func_8013C9C4(s32);
+extern void func_8018623C(u16 arg0, u16 arg1);
+extern void func_80187354(s32 a0);
+
+void func_801853D4(s32 p) {
+    s32 s0;
+
+    /* head-crack: the copy must sit in bb0 so the prologue's `sw $s0`
+       gets a true-dep successor and sched2 ranks it above `sw $ra`
+       (same idiom byte-proven on func_8018483C). */
+    s0 = p;
+
+    if (func_80185C48(p, 1) == 0) {
+        return;
+    }
+
+    func_8013C9C4((s32)D_8018B358);
+
+    *(s32 *)(p + 0x14) = 0xFFE00000;
+    *(s32 *)(p + 0x18) = 0;
+    *(s32 *)(p + 0x10) = 0;
+    *(s32 *)(p + 0x44) = 0;
+    *(s32 *)(p + 0x48) = 0x40000;
+    *(s32 *)(p + 0x4C) = 0;
+
+    func_80187354(p);
+
+    func_8018623C(0x4D7, 0);
+
+    *(u16 *)(p + 0x2) += 1;
+}
+
+
+extern s32 func_80185C48(s32 a0, s32 a1);
+extern void func_8013C9C4(s32);
+extern void func_8018623C(u16 arg0, u16 arg1);
+extern void func_80187354(s32 a0);
+extern u8 D_8018B358[];
+
+void func_8018545C(s32 a0) {
+    if (func_80185C48(a0, 1) == 0) {
+        return;
+    }
+    func_8013C9C4(D_8018B358);
+    func_80187354(a0);
+    func_8018623C(0x4D7, 0);
+    *(u16 *)(a0 + 2) += 1;
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018545C);
 
 DEFINE_func_801854C4()  /* dedup: shared engine-core @0x801854C4 (src/shared) */
 
@@ -3852,7 +4233,32 @@ void func_801855D4(s32 p) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801857B0);
+extern s32 D_801E873C;
+extern s32 D_801E8750;
+extern void func_8013D164(void);
+
+void func_801857B0(s32 param_1) {
+    s16 val16;
+    u16 val;
+
+    val = *(u16 *)(param_1 + 0xDC);
+    val--;
+    *(u16 *)(param_1 + 0xDC) = val;
+    val16 = (s16)val;
+    if (val16 == 0) {
+        *(s16 *)(param_1 + 0xDC) = 0x10;
+        *(s32 *)(param_1 + 0x18) = (s32)0xFFFE0000;
+        *(s32 *)(param_1 + 0x4C) = -0x4000;
+        *(s16 *)(param_1 + 0xE2) = 2;
+        *(s16 *)(param_1 + 0xDE) = 0;
+        *(s16 *)(param_1 + 0xE0) = 0;
+        D_801E873C = 1;
+        D_801E8750 = 0;
+        func_8013D164();
+        *(s16 *)(param_1 + 0x2) = *(u16 *)(param_1 + 0x2) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185840);
 
@@ -3866,9 +4272,48 @@ void func_80185B40(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185B7C);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001CA1C(void *a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_8018F210[];
+extern u8 D_8018F288[];
+
+void func_80185B7C(void *a0) {
+    s32 v0;
+
+    v0 = ((s32 (*)(void *))func_8012C1B8)(a0);
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001CA1C((void *)v0, D_8018F210);
+    func_8012A828((s32)a0, D_8018F288);
+    *(s16 *)((s32)a0 + 0xDC) = 0xA;
+    *(s16 *)((s32)a0 + 0x2) = *(u16 *)((s32)a0 + 0x2) + 1;
+}
+
+
+extern void func_8012C218(void *a0);
+
+void func_80185BF0(int param_1) {
+    short t;
+    int obj;
+
+    t = *(s16 *)(param_1 + 0xdc) - 1;
+    *(s16 *)(param_1 + 0xdc) = t;
+    if (t == 0) {
+        func_8012C218((void *)param_1);
+    } else {
+        obj = *(int *)(param_1 + 0x20);
+        *(s16 *)(obj + 0x1c) = -0x8000;
+        *(s16 *)(obj + 0x1a) = -0x8000;
+        *(s16 *)(obj + 0x18) = -0x8000;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185BF0);
 
 #include "common.h"
 
@@ -3914,9 +4359,36 @@ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185D5
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185E00);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185E88);
+extern s32 func_8012E504(s32 a0, s32 a1);
+
+s32 func_80185E88(void) {
+    s32 v1;
+
+    v1 = func_8012E504(0, 0x29);
+    if (v1 == 0) {
+        return 0;
+    }
+    *(s16 *)(v1 + 2) = 4;
+    return 1;
+}
+
+
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012E504(s32 a0, s32 a1);
+
+void func_80185EC8(void) {
+    s32 ptr;
+
+    ptr = func_8012E504(0, 0x29);
+    if (ptr != 0) {
+        func_8002D4C8(4, 0x4DF);
+        *(s16 *)(ptr + 0xA) = -0x1B26;
+        *(s16 *)(ptr + 0xE) = 0x1C59;
+        *(s16 *)(ptr + 6) = 0;
+        *(s16 *)(ptr + 2) = 0xE;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80185EC8);
 
 DEFINE_func_80185F24()  /* dedup: shared engine-core @0x80185F24 (src/shared) */
 
@@ -3996,7 +4468,19 @@ void func_801860A8(void *a0) {
 DEFINE_func_801860E4()  /* dedup: shared engine-core @0x801860E4 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018618C);
+extern void func_8012AD80(s32 a0);
+extern void func_8012C218(void *a0);
+
+void func_8018618C(s32 param_1)
+{
+    s32 s0 = param_1;
+
+    func_8012AD80(s0);
+    if (--*(s16 *)(s0 + 0xDC) == 0) {
+        func_8012C218((void *)s0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801861D8);
 
@@ -4053,7 +4537,18 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80186A9C);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018626C();
+
+void func_80186A9C(s32 *param_1)
+{
+    if (param_1[7] != 0 && ((s32 (*)(void))func_8012BEE8)() != 0) {
+        func_8002D4C8(0xD, 0x402);
+    }
+    func_8018626C();
+}
+
 
 #include "common.h"
 
@@ -4180,7 +4675,23 @@ void func_801870DC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80187118);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801871B8);
+extern u16 D_800B99DC;
+
+void func_801871B8(s32 a0) {
+    extern void func_80187480();
+    if (*(s16 *)(*(s32 *)(a0 + 0x64) + 0xE) - 0x80 < *(s16 *)(a0 + 0xE)) {
+        *(s32 *)(a0 + 0x18) = 0xFFDBC000;
+        *(s32 *)(a0 + 0x14) = 0xFFE00000;
+        *(s32 *)(a0 + 0x44) = 0;
+        *(s32 *)(a0 + 0x48) = 0x80000;
+        *(s32 *)(a0 + 0x4C) = 0;
+        *(s16 *)(a0 + 0x12) = 0xF - (D_800B99DC & 0x1F);
+        func_80187480();
+        func_8002D4C8(0x4DA, 0);
+        *(u16 *)(a0 + 2) += 1;
+    }
+}
+
 
 extern void func_8012CBCC(s32 a0);
 extern s32 func_80143B6C(s32 a0, s32 a1);
@@ -4292,7 +4803,25 @@ void func_801876FC(void *a0) {
 DEFINE_func_80187738()  /* dedup: shared engine-core @0x80187738 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80187834);
+extern void func_8012CBCC(s32 a0);
+extern s32 func_80143B6C(s32 a0, s32 a1);
+s32 func_80187834(s32 param_1) {
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + 0x100;
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) =
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + 0x40;
+    if (((s32 (*)(void))func_8012CBCC)() != 0) {
+        *(s32 *)(param_1 + 0x18) = 0xFFE80000;
+        *(s32 *)(param_1 + 0x14) = 0xFFC80000;
+        *(s32 *)(param_1 + 0x44) = 0;
+        *(s32 *)(param_1 + 0x48) = 0x80000;
+        *(s32 *)(param_1 + 0x4C) = 0;
+        func_80143B6C(param_1, 0);
+        *(s16 *)(param_1 + 0xFC) = 0x40;
+        *(s16 *)(param_1 + 0x2) = *(u16 *)(param_1 + 0x2) + 1;
+    }
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern void func_8012C218(void *a0);
@@ -4375,7 +4904,22 @@ DEFINE_func_80188134()  /* dedup: shared engine-core @0x80188134 (src/shared) */
 DEFINE_func_8018825C()  /* dedup: shared engine-core @0x8018825C (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80188414);
+void func_80188414(void *a0) {
+    extern void func_8012CBCC(s32 a0);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_801A7604;
+    extern u8 D_801A766C;
+
+    if (((s32 (*)(s32))func_8012CBCC)((s32)a0) != 0) {
+        if (*(s16 *)((s32)a0 + 0x70) == 0) {
+            func_8012A828((s32)a0, ((u8 *)&D_801A7604));
+        } else {
+            func_8012A828((s32)a0, ((u8 *)&D_801A766C));
+        }
+        *(u16 *)((s32)a0 + 0x2) = *(u16 *)((s32)a0 + 0x2) - 1;
+    }
+}
+
 
 
 extern void func_8012C218(void*);
@@ -4387,7 +4931,18 @@ extern void func_8012C218(void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801884B8);
+extern void func_8012CBCC(s32 a0);
+
+void func_801884B8(s32 arg0) {
+    if (((s32 (*)(void))func_8012CBCC)() != 0) {
+        *(s32 *)(arg0 + 0x4C) = 0;
+        *(s32 *)(arg0 + 0x48) = 0;
+        *(s32 *)(arg0 + 0x44) = 0;
+        *(s32 *)(arg0 + 0x14) = 0;
+        *(s16 *)(arg0 + 0x2) = 4;
+    }
+}
+
 
 #include "common.h"
 
@@ -4690,7 +5245,20 @@ DEFINE_func_80188DF0()  /* dedup: shared engine-core @0x80188DF0 (src/shared) */
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80188DF8);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80188E80);
+#include "common.h"
+
+extern s16 D_800B9AB8[];
+extern s16 D_800B9ABA[];
+extern u8 D_801E8830[];
+extern s16 D_801E8832;
+extern void func_8018A2A0(void);
+
+void func_80188E80(void) {
+    (*(s16 *)D_801E8830) = -D_800B9AB8[0];
+    D_801E8832 = 16 - D_800B9ABA[0];
+    func_8018A2A0();
+}
+
 
 
 extern void (*D_8018F6C4[])(void);
@@ -5021,7 +5589,21 @@ void func_80189340(s32 p)
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80189750);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_801897E8);
+extern s32 D_801E8778;
+extern s32 D_801E877C;
+extern s16 D_800B9A0E;
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_801897E8(void) {
+    if (D_801E8778 == 0 && D_800B9A0E == 0) {
+        D_801E877C++;
+        if (D_801E877C >= 0x10) {
+            func_8002D4C8(0x106, 0);
+            D_801E8778 = 1;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80189858);
 
@@ -5040,7 +5622,20 @@ DEFINE_func_80189898()  /* dedup: shared engine-core @0x80189898 (src/shared) */
 DEFINE_func_801898C8()  /* dedup: shared engine-core @0x801898C8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80189904);
+extern void func_80189C6C(void);
+extern void func_80189D10(s32 param_1);
+extern s32 func_8012AD50(void *arg0);
+extern s16 D_8018F71E;
+
+void func_80189904(s32 param_1)
+{
+    func_80189C6C();
+    func_80189D10(param_1);
+    *(s16 *)(param_1 + 0xFC) = 0;
+    D_8018F71E = 1;
+    ((void (*)(s32))func_8012AD50)(param_1);
+}
+
 
 DEFINE_func_80189950()  /* dedup: shared engine-core @0x80189950 (src/shared) */
 
@@ -5339,9 +5934,44 @@ void func_8018A244(int param_1)
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018A2A0);
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018A3C8);
+void func_8018A3C8(void *arg0) {
+    s32 i;
+
+    ((s16 *)arg0)[1] = 0;
+    ((s16 *)arg0)[0] = 0;
+    for (i = 0; i < 8; i++) {
+        ((s16 *)arg0)[2 + i] = 0;
+        ((s32 *)arg0)[5 + i] = 0;
+    }
+}
+
+
+typedef struct {
+    s16 unk00;
+} Sub_8018A3FC;
+
+typedef struct {
+    s16 unk00;
+    s16 unk02;
+    s16 unk04[8];
+    Sub_8018A3FC *unk14[8];
+} S_8018A3FC;
+
+void func_8018A3FC(S_8018A3FC *arg0) {
+    s32 i;
+    Sub_8018A3FC *ptr;
+    arg0->unk02 = 0;
+    arg0->unk00 = 0;
+    for (i = 0; i < 8; i++) {
+        arg0->unk04[i] = 0;
+        ptr = arg0->unk14[i];
+        arg0->unk14[i] = 0;
+        if (ptr != 0) {
+            ptr->unk00 = 0;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018A3FC);
 
 INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_8018A440);
 
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 0c20e93e9..2c3d675a7 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -7353,7 +7353,32 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018317
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801834EC);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183558);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012CC40(s32 arg0, s32 arg1);
+extern void func_8012A828(s32 a0, void *a1);
+
+extern void *D_80195144;
+extern short D_801F40A4;
+
+void func_80183558(s32 a0) {
+    s32 v1;
+
+    if (func_8012BEE8(a0) != 0) {
+        v1 = ((s32 (*)(s32, s32))func_8012CC40)((int)a0, (int)&D_80195144);
+        if (v1 & 0x8000) {
+            *(s16 *)(a0 + 0x98) = 0;
+            *(s16 *)(a0 + 0x2) = 0xA;
+        } else if (v1 & 0x6000) {
+            *(s16 *)(a0 + 0x2) = 8;
+        } else if ((*(u32 *)(a0 + 0xDC) & 1) == 0 && *(s32 *)(a0 + 0x14) >= 0) {
+            ((void (*)(s32, s32))func_8012A828)((int)a0, (int)&D_801F40A4);
+            *(u32 *)(a0 + 0xDC) |= 1;
+        }
+    }
+}
+
 
 extern void func_8018452C(void);
     void func_8018360C(short *param) {
@@ -7380,7 +7405,42 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018418
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184414);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018446C);
+void func_8018446C(s32 param_1) {
+    extern s32 func_8012BEE8(s32 a0);
+    extern s32 func_80172670(s32 *a0);
+    extern s32 func_80172658(s32 *a0);
+    extern void func_801472DC(void);
+    extern s32 D_80126B58;
+    extern u16 D_80126B62;
+    extern u8 D_801954B8[];
+    extern u8 D_801952D8[];
+
+    s32 *s0 = (s32 *)param_1;
+
+    if (func_8012BEE8((s32)s0) == 0) {
+        return;
+    }
+
+    {
+        s32 *s1 = &D_80126B58;
+
+        if (func_80172670(s1) != 0) {
+            *(s16 *)((s32)s0 + 2) = 0xC;
+        } else if (func_80172658(s1) != 0) {
+            *(s16 *)((s32)s0 + 2) = 0xC;
+        } else {
+            return;
+        }
+
+        if (func_80172658(s1) != 0 && (s16)D_80126B62 < -0xA01) {
+            func_8018490C(s0, (s32)D_801954B8, 3);
+        } else {
+            func_8018490C(s0, (s32)D_801952D8, 1);
+            func_801472DC();
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018452C);
 
@@ -7467,7 +7527,42 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184C0
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184C98);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184D50);
+typedef struct { s16 a, b, c; } SV3_80184D50;
+
+extern u16 D_80126B5E;
+extern u16 D_80126B62;
+extern u16 D_80126B66;
+extern u8 D_801957EC[];
+extern void func_8012B23C(s32 a0);
+extern void func_80185098(s32 a0, s32 a1);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_8012AD80(s32 a0);
+
+void func_80184D50(s32 param_1) {
+    SV3_80184D50 pt;
+    s32 t;
+    u16 h;
+
+    t = *(s32 *)(param_1 + 0x1C) - 1;
+    *(s32 *)(param_1 + 0x1C) = t;
+    if (t == 0) {
+        h = *(u16 *)(param_1 + 0xE);
+        *(u16 *)(param_1 + 2) = 4;
+        *(u16 *)(param_1 + 0x98) = 0;
+        *(u16 *)(param_1 + 0xE) = h + 0x68;
+        func_8012B23C(param_1);
+
+        pt.a = D_80126B5E;
+        pt.b = D_80126B62;
+        pt.c = D_80126B66;
+        if (((s32 (*)(s32, s32))func_80185098)(param_1, (s32)&pt) == 1) {
+            func_8012B14C(param_1, (s32)D_801957EC);
+        }
+        func_8012AD80(param_1);
+        *(s32 *)(param_1 + 0x1C) = 0x1E;
+    }
+}
+
 
 #include "common.h"
 
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 7b71df767..97781d90e 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
@@ -5458,7 +5458,16 @@ void func_8017EC94(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8017ECD4);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8017ED50);
+void func_8017ED50(s32 a0)
+{
+    if (func_8014C088(a0, 0x16) == 0)
+    {
+        *(s32 *)(a0 + 0x44) &= ~0x20000;
+        func_8014B5C4((s32 *)a0, func_8014CB58() & 0xFF, 0x80);
+        func_80171990((u8 *)a0);
+    }
+}
+
 
 void func_8017EDB0(void) {
 }
@@ -5640,7 +5649,7 @@ void func_8017F160(void) {
 }
 
 
-    extern void func_8017F454(void);
+    extern void func_8017F454();
     extern void (*D_801905C0[])(int);
     extern void func_80162D28(s32*);
     void func_8017F1BC(int param_1)
@@ -5742,9 +5751,35 @@ void func_8017F2D0(s32 p) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8017F394);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8017F454);
+void func_8017F454(s32 param_1) {
+    s32 tbl;
+    s32 obj;
+
+    tbl = *(s32 *)(param_1 + 0x4C);
+    obj = *(s32 *)(param_1 + 0x20);
+    *(s32 *)(param_1 + 0x04) = *(s32 *)(tbl + 0x04);
+    *(s32 *)(param_1 + 0x08) = *(s32 *)(tbl + 0x08);
+    *(s32 *)(param_1 + 0x0C) = *(s32 *)(tbl + 0x0C);
+    *(u16 *)(obj + 0x12) += *(u16 *)(*(s32 *)(param_1 + 0x58) + 0x06);
+}
+
+
+extern void func_80052D90(s32 a0, void *a1);
+extern void func_80054514(s32 a0, s32 a1);
+
+void func_8017F498(s32 a0) {
+    s32 sp10[8];
+
+    func_80052D90(0, (void *)a0);
+    func_80054514(a0, (s32)sp10);
+    *(s32 *)(a0 + 0x18) = 0;
+    *(s32 *)(a0 + 0x1C) = 0;
+    *(s32 *)(a0 + 0x20) = 0;
+    *(s16 *)(a0 + 0x50) = 0;
+    *(s16 *)(a0 + 0x52) = 0;
+    *(s16 *)(a0 + 0x54) = 0;
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8017F498);
 
 extern void func_8017F510(s32 arg0, s32 arg1, s32 arg2);
     void func_8017F4EC(s32 arg0) {
@@ -6692,13 +6727,45 @@ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018145
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801814DC);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801815A8);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_800291A0(s32 a0, s32 a1);
+extern void func_8012C218(void *a0);
+extern u8 D_80190818[];
+
+void func_801815A8(s32 arg0) {
+    s32 pad;
+    s32 a0;
+    short v;
+
+    func_8012B14C(arg0, (s32)D_80190818);
+    a0 = *(s32 *)((s8 *)arg0 + 0x20);
+    v = *(short *)((s8 *)a0 + 0x12);
+    if (v < 0x800) {
+        *(short *)((s8 *)a0 + 0x12) = v + 0x100;
+    }
+    *(s32 *)((s8 *)arg0 + 0xC) += *(s32 *)((s8 *)arg0 + 0x18);
+    *(s32 *)((s8 *)arg0 + 0x4) += *(s32 *)((s8 *)arg0 + 0x10);
+    if (*(short *)((s8 *)arg0 + 0xE) < 0x104B) {
+        return;
+    }
+    func_800291A0(0xCC, 2);
+    func_8012C218((void *)arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018163C);
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80181694);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018185C);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8018185C(s32 a0) {
+    if (*(s16 *)(a0 + 0xFC) != 0) {
+        func_8002D4C8(4, 0x5A5);
+        *(s16 *)(a0 + 0xFC) = 0;
+    }
+}
+
 
 
 extern void (*D_80190844[])(void);
@@ -7080,7 +7147,16 @@ fail:
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801823B8);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801826EC);
+extern s16 func_800D0CE0(void);
+
+void func_801826EC(s32 param_1) {
+    if (*(u16 *)(param_1 + 0x34) == 0) {
+        if (((s32 (*)(void))func_800D0CE0)() != 0) {
+            *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1;
+        }
+    }
+}
+
 
 
 extern void func_800183E0(s32 a0);
@@ -7134,7 +7210,22 @@ s32 func_801827E8(s32 a0, s32 a1, s16 a2, s16 a3, s32 a4) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801828B0);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801829FC);
+extern s32 D_801F782C;
+extern s32 D_801F76CC;
+
+s32 func_801829FC(void)
+{
+    if (D_801F782C == 2) {
+        if (D_801F76CC == 2) {
+            return 1;
+        }
+    } else {
+        D_801F782C = 2;
+        D_801F76CC = 0;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80182A44);
 
@@ -7252,7 +7343,23 @@ void func_80182E0C(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80182E4C);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80182EA8);
+extern s32 func_80029178(s32 arg);
+extern void func_800D06CC(void);
+
+s32 func_80182EA8(s32 param_1) {
+    extern u8 D_80078E78[];
+    u8 *p = D_80078E78;
+
+    if (param_1 == 0x4B0 && (func_80029178(0x138) & 0xFF) == 0) {
+        func_800D06CC();
+        return 0x79;
+    }
+    if (*(u8 *)(p + 0x37) == 4) {
+        return 0x3C;
+    }
+    return 0xA;
+}
+
 
 
 extern void (*D_80190D44[])(void);
@@ -7266,7 +7373,15 @@ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80182F4
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183090);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801830D0);
+extern s32 func_80182F4C(s32 a0, s16 a1);
+
+void func_801830D0(void *arg0) {
+    if ((u8)func_80029178(0x121) != 0) {
+        func_80182F4C(-0x7FFE, 0x200);
+        func_8012C218(arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183118);
 
@@ -7411,7 +7526,22 @@ void func_80183BC8(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183C08);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80183C4C);
+extern s32 func_8012BEE8(s32 a0);
+extern u8 D_80078EAE;
+
+void func_80183C4C(s32 param_1) {
+    if (D_80078EAE != 0) {
+        if (*(u16 *)(param_1 + 0x34) == 0 && *(s32 *)(param_1 + 0x94) == 10) {
+            *(u16 *)(param_1 + 0x98) = 0;
+            *(u16 *)(param_1 + 0x34) += 1;
+        }
+    } else {
+        if (func_8012BEE8(param_1) != 0) {
+            *(u16 *)(param_1 + 2) = 7;
+        }
+    }
+}
+
 
 extern void func_8012B23C(s32 a0);
 extern s32 func_80184300(s32 a0);
@@ -7987,11 +8117,53 @@ void func_80184A94(s32 s0) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184B30);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184B90);
+extern s32 func_80185E8C(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184BF0);
+void func_80184B90(s32 s0) {
+  s32 v0;
+  s32 v1;
+
+  v0 = *(s32 *)(s0 + 0x20);
+  v1 = *(u16 *)(v0 + 0x12) + 0x40;
+  *(s16 *)(v0 + 0x12) = v1;
+  if (func_80185E8C(s0) != 1) {
+    if (func_8012BEE8(s0) != 0) {
+      *(s16 *)(s0 + 0x2) = 5;
+    }
+  }
+}
+
+
+#include "common.h"
+
+extern void func_8012B23C(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801C8CBC[];
+
+void func_80184BF0(void *a0) {
+    s32 s0 = (s32)a0;
+    *(u16 *)(s0 + 2) = 6;
+    func_8012B23C(s0);
+    func_8012B178(s0, 0xFFFE8000);
+    func_8012A828(s0, (void *)D_801C8CBC);
+    *(s32 *)(s0 + 0x1C) = 0x96;
+    *(u16 *)(s0 + 0xE6) = 0;
+}
+
+
+extern u8 D_800D3918[];
+extern s32 func_80185E8C(s32 arg0);
+
+void func_80184C4C(s32 arg0) {
+    if (func_80185E8C(arg0) != 1) {
+        if (func_80185BD4(arg0, D_800D3918) == 0) {
+            *(s16 *)(arg0 + 2) = 3;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184C4C);
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184C9C);
 
@@ -8108,7 +8280,20 @@ void func_80184DC8(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80184FDC);
+extern s32 D_801C8E8C;
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+
+void func_80184FDC(void *a0) {
+    s32 s0 = (s32)a0;
+    *(u16 *)((s32)a0 + 2) = 0xC;
+    func_8012B23C(s0);
+    func_8012A828(s0, (void *)&D_801C8E8C);
+    *(s32 *)((s32)a0 + 0x1C) = 0x1A;
+    *(u16 *)((s32)a0 + 0xE6) = 0;
+    func_8012B23C(s0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185030);
 
@@ -8177,13 +8362,76 @@ void func_801851F4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185254);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801852C8);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_80185BD4(s32 a0, s32 a1);
+extern u8 D_800D3918[];
+extern s32 D_801C8DB4;
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185304);
+void func_80185254(s32 a0) {
+    if (*(s16 *)(a0 + 0xAA) <= 0) {
+        *(u16 *)(a0 + 2) = 3;
+    } else {
+        if (func_8012BEE8(a0) != 0) {
+            func_8012A828(a0, (void *)&D_801C8DB4);
+            *(s32 *)(a0 + 0x1C) = 0x1A;
+        }
+        func_80185BD4(a0, (s32)D_800D3918);
+    }
+}
+
+
+void func_801852C8(void *a0)
+{
+    s32 a1;
+    s32 b;
+    u16 v1;
+
+    a1 = *(s32 *)((s32)a0 + 0x20);
+    v1 = *(u16 *)(a1 + 0x2C);
+    __asm__ __volatile__("" : : "r"(v1));
+    if (v1 & 0x10) {
+        *(u16 *)(a1 + 0x2C) = v1 & 0xFFEF;
+        b = *(s32 *)((s32)a0 + 0x20);
+        *(u16 *)(b + 0x1C) = 0x1000;
+        *(u16 *)(b + 0x1A) = 0x1000;
+        *(u16 *)(b + 0x18) = 0x1000;
+    }
+}
+
+
+void func_80185304(s32 a0) {
+    extern s32 func_8012B864(s32 a0);
+
+    s32 s0 = a0;
+    *(s16 *)(s0 + 2) = 0xF;
+    *(s16 *)(*(s32 *)(s0 + 0x20) + 0x12) = (func_8012B864(s0) + 0x800) & 0xFFF;
+}
+
+
+extern void func_80131B14();
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801C93D4;
+
+void func_80185344(s32 s0) {
+    s32 a0;
+    s32 v1;
+
+    a0 = *(s32 *)(s0 + 0x20);
+    v1 = *(u16 *)(a0 + 0x2C);
+    if (v1 & 0x10) {
+        *(u16 *)(a0 + 0x2C) = v1 & 0xFFEF;
+        v1 = *(s32 *)(s0 + 0x20);
+        *(u16 *)(v1 + 0x1C) = 0x1000;
+        *(u16 *)(v1 + 0x1A) = 0x1000;
+        *(u16 *)(v1 + 0x18) = 0x1000;
+    }
+    func_80131B14(s0);
+    func_8012A828(s0, (void *)&D_801C93D4);
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185344);
 
 #include "common.h"
 
@@ -8662,7 +8910,25 @@ LD44:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185E8C);
+extern s32 func_8012BCCC(s32 a0);
+extern s32 func_8012BDBC(s32 a0, s32 a1);
+
+s32 func_80185E8C(s32 obj) {
+    s32 d = func_8012BCCC(obj);
+    if (d < 0x2001) {
+        *(s16 *)(obj + 0x2) = 7;
+        return 1;
+    }
+    if (d > 0x24000) {
+        return 0;
+    }
+    if (func_8012BDBC(obj, 0x400) == 0) {
+        return 0;
+    }
+    *(s16 *)(obj + 0x2) = 7;
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80185EFC);
 
@@ -8930,7 +9196,17 @@ void func_801864C0(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801864F4);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_801864F4(void *arg0) {
+    if (func_8012BEE8((s32)arg0) != 0) {
+        func_8018654C(0, (u8 *)arg0 + 0xFD);
+        func_8018654C(1, (u8 *)arg0 + 0xFE);
+        func_8018654C(2, (u8 *)arg0 + 0xFF);
+        *(s32 *)((char *)arg0 + 0x1C) = 2;
+    }
+}
+
 
 extern u32 D_801C5988[];
 extern u32 D_801C5BB4[];
@@ -9254,7 +9530,32 @@ void func_80186D18(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80186D54);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012B2CC(s32 a0);
+
+void func_80186D54(void *a0)
+{
+    s32 v0;
+    s32 v1;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(v0, 0);
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) =
+        *(u16 *)(*(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x20) + 0x12);
+    func_8012B2CC((s32)a0);
+
+    *(u16 *)((s32)a0 + 0x108) = 1;
+    *(u16 *)((s32)a0 + 0x2) += 1;
+}
+
 
 
 extern void (*D_801C9794[])(void);
@@ -9687,7 +9988,32 @@ s32 aF8018A224(param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801875B4);
+extern s32 D_801CA170[];
+extern s32 func_8012C044(s32 a0);
+extern void func_80188A2C(void*);
+
+void func_801875B4(s32 a0) {
+    s32 *s0 = (s32 *)a0;
+    u32 v0;
+    u32 (*func_ptr)(void);
+
+    v0 = *(u16 *)((u8 *)s0 + 2);
+    v0 = v0 * 4;
+    func_ptr = (u32 (*)(void))D_801CA170[v0 / 4];
+    func_ptr();
+
+    v0 = *(u16 *)s0;
+    if (v0 == 0) {
+        return;
+    }
+
+    v0 = func_8012C044((s32)s0);
+    if (v0 != 1) {
+        return;
+    }
+    ((void (*)(s32))func_80188A2C)((s32)s0);
+}
+
 
 #include "common.h"
 
@@ -9734,7 +10060,24 @@ void func_80187628(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801876E4);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80187778);
+#include "common.h"
+
+extern s32 func_8012BCCC(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8013240C(s32 a0);
+extern s32 D_801F7730;
+
+void func_80187778(s32 a0) {
+    if (func_8012BCCC(a0) < 0x4001) {
+        *(s16 *)(a0 + 2) = 7;
+        return;
+    }
+    if (func_8012BEE8(a0) != 0) {
+        *(s16 *)(a0 + 2) = 5;
+    }
+    func_8013240C((s32)&D_801F7730);
+}
+
 
 #include "common.h"
 
@@ -9855,7 +10198,22 @@ void func_80187A9C(s32 obj) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80187C94);
+void func_80187C94(s32 a0) {
+    extern void func_80132288(s32 *param_1, s32 *param_2, s32 param_3);
+    extern void func_801888A8(s32 a0, s32 a1);
+    extern s32 D_801F7730;
+    extern s32 D_801CAE68;
+    extern s32 D_801C9F44[];
+    s32 s0 = a0;
+
+    *(s16 *)(s0 + 0x2) = 8;
+    func_80132288(&D_801F7730, D_801C9F44, D_801CAE68);
+    *(s32 *)(s0 + 0x1C) = 0x28;
+    func_801888A8(s0, 2);
+    *(s16 *)(s0 + 0xDE) = 0;
+    *(s16 *)(s0 + 0xE6) = 0;
+}
+
 
 #include "common.h"
 
@@ -10220,7 +10578,17 @@ merge2:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801886C0);
+extern void func_80132288(s32 *param_1, s32 *param_2, s32 param_3);
+extern void func_801888A8(s32 a0, s32 a1);
+extern s32 D_801F7730;
+extern s32 D_801CAE68;
+extern s32 D_801C9FD4[];
+
+void func_801886C0(s32 a0) {
+    func_80132288(&D_801F7730, D_801C9FD4, D_801CAE68);
+    func_801888A8(a0, 1);
+}
+
 
 extern void func_8013240C(s32 a0);
 extern s32 D_801F7730;
@@ -10258,7 +10626,16 @@ void func_80188738(void)
  dummy_label_648936: ;
 }
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018876C);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_8018876C(s32 a0) {
+    extern u8 D_8018C90C[];
+    *(s16 *)(a0 + 0x2) = 1;
+    func_8012A828(a0, (void *)D_8018C90C);
+    *(u16 *)(a0 + 0x5C) = 0xAA10;
+    *(s16 *)(a0 + 0xEA) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801887B0);
 
@@ -10277,9 +10654,32 @@ extern s32 rand(void);
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188978);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188A2C);
+extern void func_8012C218(void *arg0);
+
+void func_80188A2C(void *arg0) {
+    int iVar1;
+    if ((*(s16 *)((char *)arg0 + 0x70) & 0x8000) == 0) {
+        iVar1 = *(int *)((char *)arg0 + 0x68);
+        if ((iVar1 != 0) && ((*(s16 *)((char *)arg0 + 0x72) & 0x8000) != 0)) {
+            *(unsigned short *)(iVar1 + 10) = *(unsigned short *)(iVar1 + 10) & 0x7FFF;
+        }
+    }
+    func_8012C218(arg0);
+}
+
+
+extern void Square0(s32 *a0, s32 *a1);
+
+s32 func_80188A94(s32 a0) {
+    s32 v[4];
+
+    v[0] = *(s16 *)(a0 + 6) - *(s16 *)(a0 + 0x88);
+    v[1] = 0;
+    v[2] = *(s16 *)(a0 + 0xE) - *(s16 *)(a0 + 0x8C);
+    Square0(&v[0], &v[0]);
+    return (0x18FFFF < v[0] + v[2]) ^ 1;
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188A94);
 
 #include "common.h"
 
@@ -10332,7 +10732,27 @@ void func_80188AF4(s32 a0, s32 a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188C18);
+extern s32 func_80133784(s32 a0, void *a1, s32 a2);
+
+s32 func_80188C18(void *a0)
+{
+    short in[4];
+    short out[4];
+    s32 pa, pb;
+
+    in[0] = *(u16 *)((s32)a0 + 0x6);
+    in[1] = *(u16 *)((s32)a0 + 0xA);
+    in[2] = *(u16 *)((s32)a0 + 0xE);
+    pa = (s32)in;
+    pb = (s32)out;
+    __builtin_memcpy((void *)pb, (void *)pa, 8);
+    out[1] += 8;
+    if (func_80133784(1, in, pb) & 0x2000) {
+        return 1;
+    }
+    return 0;
+}
+
 
 extern s32 func_8012C044(s32 a0);
 extern u32 D_801D2B4C[];
@@ -10435,7 +10855,20 @@ void func_80188DD0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188EA0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 rand(void);
+extern u8 D_801D78A8[];
+
+void func_80188EA0(s32 a0) {
+    s32 r;
+
+    *(s16 *)(a0 + 0x2) = 4;
+    func_8012A828(a0, D_801D78A8);
+    r = rand();
+    *(s16 *)(a0 + 0x52) = 0;
+    *(s32 *)(a0 + 0x1C) = (r % 17) + 0x28;
+}
+
 
 extern s32 func_8012BEE8(s32 arg);
     void func_80188F14(void *a0) {
@@ -10445,7 +10878,31 @@ extern s32 func_8012BEE8(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188F48);
+#include "common.h"
+
+extern void func_8012B23C(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801D7998;
+extern u8 D_80078EAE;
+
+void func_80188F48(void *a0) {
+    s32 s0 = (s32)a0;
+    s32 v0;
+
+    func_8012B23C(s0);
+    func_8012B178(s0, 0xFFFE0000);
+    func_8012A828(s0, (void *)&D_801D7998);
+    *(s32 *)(s0 + 0x1C) = 0x96;
+    v0 = D_80078EAE;
+    if (v0 == 0) {
+        v0 = 7;
+    } else {
+        v0 = 6;
+    }
+    *(s16 *)(s0 + 2) = (s16)v0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80188FB0);
 
@@ -10598,9 +11055,26 @@ void func_80189498(void *a0)
   *((short *) (((char *) a0) + 0xfe)) = 0;
 }
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801894B0);
+void func_801894B0(s32 arg0) {
+    if (*(s16 *)(arg0 + 0x76) <= 0) {
+        *(s32 *)(arg0 + 0xDC) |= 2;
+    }
+    *(s16 *)(arg0 + 0x52) = -0x30;
+}
+
+
+extern void func_80189B3C(s32 a0);
+extern s32 func_80189CD4();
+
+void func_801894DC(s32 a0) {
+    if (*(s32 *)(a0 + 0x1C) == *(s32 *)(a0 + 0x1C) / 5 * 5) {
+        func_80189B3C(a0);
+    }
+    if (*(s32 *)(a0 + 0x1C) >= 0xB) {
+        ((void (*)(s32))func_80189CD4)(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801894DC);
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80189554);
 
@@ -10766,9 +11240,44 @@ void func_801897F8(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_801898E0);
+void func_801898E0(s32 param_1) {
+    extern u8 D_801D612C;
+    extern u8 D_801D7D90;
+    extern void func_8001C924(s32 a0, void *a1);
+    extern void func_8012A828(s32 a0, void *a1);
+
+    *(s32 *)(param_1 + 0x1C) = 0x37;
+    func_8001C924(*(s32 *)(param_1 + 0x20), &D_801D612C);
+    func_8012A828(param_1, &D_801D7D90);
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(u16 *)(param_1 + 0x62);
+}
+
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8002AC00(s32 arg0);
+extern void func_80130D48(s32 arg0);
+extern void func_8018A05C(s32 a0);
+
+void func_8018993C(s32 a0) {
+    if (*(s32 *)(a0 + 0x1C) < 0x11) {
+        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_8002AC00(0xB);
+        func_80130D48(a0);
+        func_8018A05C(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018993C);
 
 //   the beqz delay slot), so it is the FIRST statement, above the if; (3) both `*(s32*)(p+0x20)`
 //   reads in arm A are written as separate expressions — the intervening `sh` to 0x10 blocks CSE,
@@ -10942,7 +11451,26 @@ extern s32 rand(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80189E1C);
+extern s32 func_8014CB0C(void);
+extern s32 rand(void);
+
+void func_80189E1C(s32 a0) {
+    s32 ret;
+    s32 s0;
+
+    ret = func_8014CB0C();
+    s0 = a0;
+    if (ret != 0) {
+        *(s32 *)(s0 + 0xDC) |= 0x20;
+    } else {
+        if ((rand() & 1) != 0) {
+            *(s32 *)(s0 + 0xDC) |= 0x20;
+        } else {
+            *(s32 *)(s0 + 0xDC) &= ~0x20;
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -11018,9 +11546,33 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A124);
+extern void func_8018A168();
+extern void func_8018A3D4();
+
+void func_8018A124(s32 *a0, s32 a1) {
+    if (*(s32 *)((s32)a0 + 0xC4) & 4) {
+        func_8018A168((s32)a0, a1);
+    } else {
+        func_8018A3D4((s32)a0, a1);
+    }
+}
+
+
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern unsigned char D_801DFC6C[];
+
+void func_8018A168(int param_1)
+{
+    *(short *)(param_1 + 2) = 5;
+    *(short *)(param_1 + 0x34) = 0;
+    *(unsigned short *)(param_1 + 0x5C) = 0xAA10;
+    func_8012A828(param_1, &D_801DFC6C);
+    func_8012B23C(param_1);
+}
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A168);
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A1B4);
 
@@ -11028,7 +11580,39 @@ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A2F
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A384);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A3D4);
+#include "common.h"
+
+extern s32 rand(void);
+extern s32 func_8012B744(void *a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 func_8018A698(s32 a0);
+extern u8 D_801DFA6C[];
+
+void func_8018A3D4(s32 param_1) {
+    *(s16 *)(param_1 + 0x2) = 1;
+    *(s16 *)(param_1 + 0x34) = 0;
+    *(u16 *)(param_1 + 0x5C) = 0xAA10;
+    *(s32 *)(param_1 + 0x1C) = (rand() & 0x1F) + 0x24;
+
+    if (func_8018A698(param_1) != 0) {
+        *(s16 *)(param_1 + 0xFC) =
+            func_8012B744((void *)(param_1 + 0x4), (void *)(param_1 + 0x88));
+    } else {
+        register s32 t __asm__("$2") = rand() & 0x3FF;
+        s32 v1 = t - 0x200;
+
+        if (v1 < 0) {
+            v1 = t - 0x500;
+        } else {
+            v1 = t + 0x100;
+        }
+        *(s16 *)(param_1 + 0xFC) =
+            (*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + v1) & 0xFFF;
+    }
+
+    func_8012A828(param_1, D_801DFA6C);
+}
+
 
 
 
@@ -11049,7 +11633,30 @@ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A59
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A5C4);
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A624);
+#include "common.h"
+
+extern void func_8002A04C(s32 a0);
+extern void func_8002AC00(s32 arg0);
+extern void func_8012C098(void);
+
+void func_8018A624(s32 arg0) {
+    register u8 val __asm__("$3");
+
+    /* Check field at +0x100 */
+    if (((s16 *)arg0)[0x80] == 0) {
+        func_8002A04C(arg0);
+    }
+
+    /* Check field at +0xC1 */
+    val = ((u8 *)arg0)[0xC1];
+    if (val == 5 || val == 0xD || val == 0xB || val == 0xE) {
+        func_8002AC00(0x7);
+    }
+
+    /* Always call func_8012C098 */
+    ((void (*)(s32))func_8012C098)(arg0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A698);
 
@@ -11095,7 +11702,17 @@ void func_8018A86C(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A928);
+extern void func_8012CBF4(s32 a0);
+extern void func_8018A3D4(s32 a0);
+
+void func_8018A928(s32 a0)
+{
+    func_8012CBF4(a0);
+    if (*(u16 *)(a0 + 0x72) & 0x4000) {
+        func_8018A3D4(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018A96C);
 
@@ -11120,7 +11737,26 @@ void func_8018AC10(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018AC60);
+#include "common.h"
+
+extern void func_8012AD80(s32 a0);
+extern void func_8018A384(s16 *a0);
+extern void func_8018A598(void *a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8018A4B4(s16 *a0);
+
+void func_8018AC60(s32 a0) {
+    func_8012AD80(a0);
+    if (*(u16 *)(a0 + 0x70) & 0x2000) {
+        func_8018A384((s16 *)a0);
+        func_8018A598((void *)a0);
+    }
+    if (func_8012BEE8(a0) != 0) {
+        *(u16 *)(a0 + 0x86) |= 2;
+        func_8018A4B4((s16 *)a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018ACD0);
 
@@ -11130,7 +11766,25 @@ extern void func_8012C098(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018AD9C);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8018C090(s32 a0, u16 *a1, s16 a2);
+
+void func_8018AD9C(void *a0) {
+    s16 sp10[3];
+    u16 id;
+
+    id = *(u16 *)(a0 + 0x5E);
+    if (id == 0x23) {
+        *(u16 *)(a0 + 0xFE) = 1;
+        func_8002D4C8(0xAA1, 0);
+    } else if (id == 0x24) {
+        sp10[0] = 2;
+        sp10[1] = 0xF;
+        sp10[2] = -2;
+        func_8018C090((s32)a0, (u16 *)sp10, 0xD);
+    }
+}
+
 
 
 /* func_8018AE08 — light/colour ramp-up on the entity's attached prim block.
@@ -11375,7 +12029,21 @@ void func_8018B37C(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018B3E0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B178(s32 a0, s32 a1);
+
+void func_8018B3E0(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_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018B438);
 
@@ -11392,7 +12060,19 @@ extern s32 func_8012BEE8(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018B684);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_8018B684(s32 param_1)
+{
+    if (func_8012BEE8(param_1) == 1) {
+        if (*(s16 *)(param_1 + 0x70) & 0x8000) {
+            func_8018B104(param_1, 0x40000, 0xC4000);
+        } else {
+            func_8018B104(param_1, 0x9000, 0x24000);
+        }
+    }
+}
+
 
 
 // @class: plumbing
@@ -11831,7 +12511,27 @@ void aF8018C118(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018C154);
+extern void func_8014706C(void *a0);
+extern void func_801553A8(s32 *a0);
+extern void func_80155440(s32 *a0);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80154A74(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+
+void func_8018C154(s32 *a0) {
+    s32 *v1;
+    func_8014706C(a0);
+    func_801553A8(a0);
+    func_80155440(a0);
+    func_80154150((s32)a0, 0x26);
+    func_80154A74((s32)a0, 0x1E);
+    v1 = *(s32 **)((u8 *)a0 + 0x20);
+    *(u16 *)((u8 *)v1 + 0x10) = 0xFE9;
+    *(s32 *)((u8 *)a0 + 0x208) = 0;
+    func_80171A1C((u8 *)a0);
+    func_8018C1C4(a0);
+}
+
 
 extern void func_80171A1C(u8*);
 
@@ -11886,7 +12586,25 @@ void aF8018C2CC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018C308);
+extern void func_8014706C(void *a0);
+extern void func_801553A8(s32 *a0);
+extern void func_80155440(s32 *a0);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80154A74(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+extern s32 func_80174650(s32 a0);
+
+void func_8018C308(s32 *a0) {
+    func_8014706C(a0);
+    func_801553A8(a0);
+    func_80155440(a0);
+    *(s16 *)((u8 *)(*(s32 **)((u8 *)a0 + 0x20)) + 0x10) = 0xC00;
+    func_80154150((s32)a0, 0x27);
+    func_80154A74((s32)a0, 0x1F);
+    func_80171A1C((u8 *)a0);
+    func_80174650((s32)a0);
+}
+
 
 void func_8018C374(void) {
 }
@@ -11956,7 +12674,20 @@ void func_8018C4BC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018C4F8);
+extern void func_8014706C(void *arg0);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80154A74(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+extern void func_8018C58C();
+
+void func_8018C4F8(void *a0) {
+    func_8014706C(a0);
+    func_80154150((s32)a0, 0x24);
+    func_80154A74((s32)a0, 0x1D);
+    func_80171A1C((u8 *)a0);
+    func_8018C58C((s32)a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018C548);
 
diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
index a1aa5071a..bb05fa0e2 100644
--- a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
+++ b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
@@ -3748,7 +3748,35 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E6B
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E6E0);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E770);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017E800(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[];
+
+void func_8017E770(void) {
+    D_80126954 = 0x190;
+    D_8012695C = 0x640;
+    D_80126968 = 0;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = 0;
+    D_8012697A = 0;
+
+    func_8012A018((s32)func_8017E800, 1);
+    func_8012A094((s32)D_80126948);
+    func_8017E800(D_80126948);
+}
+
 
 
 extern void (*D_801901E0[])(void);
@@ -3760,7 +3788,23 @@ void func_8017E800(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E83C);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E8DC);
+typedef struct { s16 v[4]; } Blk8_80126940_8017E8DC;
+
+extern void func_8017E95C();
+
+void func_8017E8DC(s32 a0) {
+    extern Blk8_80126940_8017E8DC D_80126940;
+    Blk8_80126940_8017E8DC sp10a;
+    Blk8_80126940_8017E8DC sp10b;
+
+    sp10a = D_80126940;
+    sp10b = D_80126940;
+    sp10a.v[1] = -0x380;
+    sp10b.v[0] = 0;
+    sp10b.v[2] = 0;
+    func_8017E95C(a0, sp10a.v, sp10b.v, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017E95C);
 
@@ -3890,7 +3934,15 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017EF0
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017EF34);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017F300);
+void func_8017F300(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 7;
+    *(s16 *)(a0 + 0x34) = *(s16 *)(a0 + 0x100) * 4;
+    *(s32 *)(a0 + 0xEC) = 0;
+    if ((*(s32 *)(a0 + 0xE0) & 0x800) == 0) {
+        *(s16 *)(a0 + 0xFE) = 0;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017F330);
 
@@ -3901,7 +3953,16 @@ void func_8017F970(s32 arg0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017F984);
+void func_8017F984(s32 arg0) {
+    *(s16 *)(arg0 + 0x02) = 9;
+    *(s16 *)(arg0 + 0x34) = *(s16 *)(arg0 + 0x100) * 4;
+    *(u16 *)(arg0 + 0x106) = *(u16 *)(arg0 + 0x100);
+    *(s32 *)(arg0 + 0xEC) = 0;
+    if (!(*(s32 *)(arg0 + 0xE0) & 0x800)) {
+        *(s16 *)(arg0 + 0xFE) = 0;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8017F9C0);
 
@@ -4037,7 +4098,34 @@ void func_801808C4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801809D4);
+extern void func_8012BEE8(void);
+extern s32 func_8012E544(s32 arg);
+extern s32 func_80029178(s32 arg);
+extern void func_8002959C(void);
+extern s32 func_80178B18(s32 arg, s32 arg2);
+extern s16 D_801904F4[];
+extern s16 D_80190510[];
+extern void *D_80190680;
+extern u8 D_8019060C[];
+
+void func_801809D4(s32 param_1) {
+    if (((s32 (*)(void))func_8012BEE8)() == 0) {
+        return;
+    }
+    if (func_8012E544(0x2EF) != 0) {
+        return;
+    }
+    *(s16 *)(param_1 + 2) = 0xE;
+    *(s16 *)(param_1 + 0x34) = 0;
+    if ((func_80029178(0x11D) & 0xFF) == 0) {
+        D_80190680 = D_801904F4;
+        func_8002959C();
+    } else {
+        D_80190680 = D_80190510;
+    }
+    func_80178B18(param_1, (s32)D_8019060C);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80180A70);
 
@@ -4064,7 +4152,18 @@ extern s32 func_8018B20C(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80180F08);
+extern s32 D_801904D4[];
+extern s32 D_801DFD8C;
+extern s32 D_801DFD90;
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8018180C(void *a0);
+
+void func_80180F08(void) {
+    D_801DFD8C = (s32)D_801904D4;
+    D_801DFD90 = (s32)&D_801904D4[2];
+    func_8012A018((s32)&func_8018180C, 0);
+}
+
 
 extern s32 *D_80126B78;
 extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
@@ -4076,12 +4175,23 @@ void func_80180F4C(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80180F88);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+s32 func_80180F88(s32 arg0) {
+    if (0x57FFFFF < *(s32 *) (arg0 + 8)) {
+        *(s32 *) (arg0 + 8) = 0x5800000;
+        func_8002D4C8(0x9C7, 0);
+        func_8002D4C8(4, 0x9C9);
+        return 1;
+    }
+    return 0;
+}
+
 
 #include "common.h"
 
 extern s32 func_80181268(s32 a0);
-extern void *func_80185C6C(s16, s32); /* §183 SIGNATURE-adopted-TU;
+extern void *func_80185C6C(); /* §183 SIGNATURE-adopted-TU;
    calls go through a (s32,s32) function-pointer cast, the TU's own idiom */
 #define CALL_80185C6C ((void *(*)(s32, s32))func_80185C6C)
 extern void func_801856A4(s32 *a0, s32 a1); /* §183 SIGNATURE-adopted-TU */
@@ -4144,7 +4254,7 @@ s32 func_80180FE0(s32 a0, s32 a1) {
 
 #include "common.h"
 
-extern void *func_80185C6C(s16, s32); /* §183 SIGNATURE-adopted-TU;
+extern void *func_80185C6C(); /* §183 SIGNATURE-adopted-TU;
    calls go through a (s32,s32) function-pointer cast, the TU's own idiom */
 #define CALL_80185C6C ((void *(*)(s32, s32))func_80185C6C)
 extern void func_8012C218(void *a0);
@@ -4206,7 +4316,21 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018126
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801812AC);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80181334);
+extern s32 D_801DDB2C[5];
+
+s32 func_80181334(void) {
+    s32 i = 0;
+    s32 key = 1;
+    s32 *p = D_801DDB2C;
+
+    for (; i < 5; i++, p++) {
+        if (*(u16 *)(*p + 2) != key) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
 
 #include "common.h"
 
@@ -5172,7 +5296,20 @@ void func_80183534(s32 arg0, SVEC_80183534 *arg1, SVEC_80183534 *arg2, s32 *arg3
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80183848);
+s32 func_80183848(s32 a0, s32 a1, s32 a2) {
+    extern s32 *D_80126B78;
+    extern s32 *D_80126B90;
+    extern u8 D_801152A8[];
+    extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5);
+
+    if (func_80135888((s32)D_80126B78, (s32)D_80126B90, a1, a2) != 0) {
+        func_8012F568(1, 0x18, 0, 0x40, a2, (s32)D_801152A8);
+        return 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801838BC);
 
@@ -5184,11 +5321,39 @@ void func_80183A1C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80183A58);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern u16 D_801909B0;
+extern u8 D_80190970[];
+
+void func_80183A58(s32 param_1) {
+    s32 v0;
+
+    *(s32 *)(param_1 + 0x78) = (s32)&D_801909B0;
+    v0 = func_8012C1B8();
+    *(s32 *)(param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)param_1);
+        return;
+    }
+    func_8001C214(v0, 0);
+    *(s32 *)(param_1 + 0x58) = (s32)&D_80190970[(*(u16 *)(param_1 + 0x70) & 0xF) * 16] | 0x50000000;
+    if ((*(s16 *)(param_1 + 0x70) & 0x8000) == 0) {
+        *(u8 *)(param_1 + 0x75) = 0x15;
+        *(u16 *)(param_1 + 0x5C) = 0x8000;
+        *(s16 *)(param_1 + 0xAE) = -3;
+    } else {
+        *(u8 *)(param_1 + 0x75) = 0x14;
+        *(u16 *)(param_1 + 0x5C) = 0xC000;
+    }
+    *(u16 *)(param_1 + 2) += 1;
+}
+
 
 #include "common.h"
 
-extern void *func_80185C6C(s16 a0, s32 a1);
+extern void *func_80185C6C();
 extern void func_8012C218(void *a0);
 extern void func_8012E9C0(int param_1);
 extern void func_8016B3F4(s32 a0);
@@ -5279,7 +5444,7 @@ extern s32 func_8004787C(s32 a0);
 extern void func_800233CC(void *, unsigned short);
 extern void func_8001CD9C(int, void *);
 extern void func_801856A4(s32 *a0, s32 a1);
-extern void *func_80185C6C(s16, s32);
+extern void *func_80185C6C();
 
 extern u8 D_80190808[];
 extern u8 D_80190240[];
@@ -5373,9 +5538,54 @@ void func_80183D84(u8 *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80184084);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80184464);
+extern void func_80016714(void *a0, s32 a1);
+extern void func_8012C218(void *a0);
+extern s32 D_801DFD38[];
+
+void func_80184464(void *a0) {
+    if (*(s16 *)((s32)a0 + 0xFE) != -1) {
+        func_80016714((void *)D_801DFD38[*(s16 *)((s32)a0 + 0xFE)], 0x38);
+        D_801DFD38[*(s16 *)((s32)a0 + 0xFE)] = 0;
+    }
+    if (*(s32 *)((s32)a0 + 0xCC) != 0) {
+        func_80016714(*(void **)((s32)a0 + 0xCC), 0x38);
+    }
+    if (*(s32 *)((s32)a0 + 0xD0) != 0) {
+        func_80016714(*(void **)((s32)a0 + 0xD0), 0x38);
+    }
+    if (*(s32 *)((s32)a0 + 0xD4) != 0) {
+        func_80016714(*(void **)((s32)a0 + 0xD4), 0x38);
+    }
+    if (*(s32 *)((s32)a0 + 0xD8) != 0) {
+        func_80016714(*(void **)((s32)a0 + 0xD8), 0x38);
+    }
+    func_8012C218(a0);
+}
+
+
+extern s32 D_801DFD38[];
+
+s32 func_8018452C(void)
+{
+    s32 i;
+    s32 *p;
+    s32 ret;
+
+    i = 0;
+    p = D_801DFD38;
+    do {
+        if (*p == 0) {
+            ret = i;
+            goto done;
+        }
+        i++;
+        p++;
+    } while (i < 5);
+    ret = -1;
+done:
+    return ret;
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018452C);
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80184564);
 
@@ -5516,7 +5726,14 @@ void func_80184C68(u8 *v, s32 idx)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80184E6C);
+void func_80184E6C(s32 *a0, s32 *a1) {
+    if (a0 != NULL) {
+        *(u16 *)((s32)a0 + 0x8) = *(u16 *)((s32)a1 + 0x0);
+        *(u16 *)((s32)a0 + 0xA) = *(u16 *)((s32)a1 + 0x2);
+        *(u16 *)((s32)a0 + 0xC) = *(u16 *)((s32)a1 + 0x4);
+    }
+}
+
 
 void func_80184EA0(s32 arg0) {
         if (arg0 != 0) {
@@ -6080,7 +6297,15 @@ void func_801859F4(SVec_59F4 *vtx, u32 tx, u32 ty, u32 cx, u16 cy, u8 uw,
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80185C6C);
+extern u8 D_801DDB50[];
+
+void *func_80185C6C(a0, a1)
+    s32 a0;
+    s32 a1;
+{
+    return &D_801DDB50[((a0 << 2) + a1) << 3];
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80185C88);
 
@@ -6189,7 +6414,16 @@ void func_801860EC(s32 *a0) {
 void func_80186124(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018612C);
+extern s32 func_8012E544(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_8018612C(void) {
+    s32 ret = func_8012E544(0x324);
+    if (ret != 0) {
+        func_8012AD44((s32 *)ret, 1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018615C);
 
@@ -6204,11 +6438,37 @@ s32 func_8018619C(void) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801861A4);
+extern void func_8018653C(s32 *a0, s32 *a1);
+
+void func_801861A4(s32 param_1) {
+    extern void (*D_80190D64[])(void *);
+    ((void (*)(s32))D_80190D64[*(u16 *)(param_1 + 2)])(param_1);
+    if (*(u16 *)param_1 != 0) {
+        func_8018653C((s32 *)param_1, *(s32 **)(param_1 + 0xCC));
+        func_8018653C((s32 *)param_1, *(s32 **)(param_1 + 0xD0));
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186214);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801862C0);
+extern s32 func_80029178(s32);
+extern s32 func_8018656C(s32 *);
+extern void func_8018641C(s32);
+extern s32 func_8012C588(s32, s32);
+
+void func_801862C0(s32 param_1) {
+    if ((func_80029178(0x8E) & 0xFF) != 0) {
+        if (func_8018656C((s32 *)param_1) == 1) {
+            func_8012C588(0x353, param_1);
+            *(u16 *)(param_1 + 2) = 2;
+        } else {
+            *(u8 *)(*(s32 *)(param_1 + 0xCC) + 0x27) = 0xA5;
+            func_8018641C(param_1);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186334);
 
@@ -6388,7 +6648,13 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018698
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801869F8);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186A28);
+extern s32 D_801DFF74;
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80186A28(s32 param_1) {
+    func_8012A828(D_801DFF74, *(void **)(param_1 + 0xF8));
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186A58);
 
@@ -6398,7 +6664,31 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186AB
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186B00);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186B6C);
+#include "common.h"
+
+extern s32 D_801DFF6C;
+extern u8 D_8018CCE8;
+
+extern void func_8012CBCC(s32 a0);
+extern void func_8013C9C4(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+s32 func_80186B6C(void) {
+    s32 v0;
+    s32 v1;
+
+    if ((((s32 (*)(s32))func_8012CBCC)(D_801DFF6C) & 0x2000) != 0) {
+        func_8013C9C4(&D_8018CCE8);
+        v0 = -0x180;
+        v1 = D_801DFF6C;
+        *(u16 *)(v1 + 0x6) = v0;
+        *(u16 *)(v1 + 0xE) = v0;
+        func_8002D4C8(0xB96, 0);
+        return 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186BD4);
 
@@ -6422,13 +6712,63 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186C3
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186C88);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186CC4);
+extern s32 D_801DFFB8;
+extern s32 D_801BF990[];
+extern u8 D_801DFFD4[];
+extern s32 D_801DFF70;
+extern s32 D_801BF2BC;
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186D30);
+extern void func_8001C924(void *a0, s32 *a1);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186D64);
+void func_80186CC4(void) {
+    s32 off;
+
+    for (off = 0; off < 0x24; off += 4) {
+        *(s32 *)((u8 *)&D_801DFFB8 + off) = *(s32 *)((u8 *)&D_801BF2BC + off);
+    }
+    *(s32 *)&D_801DFFD4 = D_801BF990[0];
+    func_8001C924((void *)*(s32 *)(D_801DFF70 + 0x20), (s32 *)((u8 *)&D_801DFFD4 - 0x1C));
+}
+
+
+extern void func_8001C924(void *a0, s32 *a1);
+extern s32 D_801DFF70;
+extern s32 D_801BF2BC;
+
+void func_80186D30(void) {
+    func_8001C924((void *)*(s32 *)(D_801DFF70 + 0x20), &D_801BF2BC);
+}
+
+
+extern s32 D_801DFF74;
+
+s32 func_80186D64(void) {
+    if (*(s16 *)(D_801DFF74 + 0x98) == 0 || *(u16 *)(D_801DFF74 + 0x72) & 0x4000) {
+        return 1;
+    }
+    return 0;
+}
+
+
+#include "common.h"
+
+extern s32 D_801DFF70;
+extern u16 D_80191234;
+extern s32 D_801C2AA4;
+extern s32 func_8012B744(void *a0, void *a1);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80186DA0(void) {
+    *(s16 *)(*(s32 *)(D_801DFF70 + 0x20) + 0x12) = func_8012B744((void *)(D_801DFF70 + 4), &D_80191234);
+    func_8012B2CC(D_801DFF70);
+    func_8012B178(D_801DFF70, -0x100000);
+    *(s32 *)(D_801DFF70 + 0x48) = 0xC000;
+    *(s16 *)(D_801DFF70 + 0x34) = 0;
+    func_8012A828(D_801DFF70, &D_801C2AA4);
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186DA0);
 
 #include "common.h"
 
@@ -6501,9 +6841,43 @@ void func_80186F9C(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80186FC4);
+extern s32 D_801DFF7C;
+
+s32 func_80186FC4(void) {
+    u16 *obj = (u16 *)*(s32 *)(D_801DFF7C + 0x20);
+
+    obj[0xC] = obj[0xC] + 0xC0;
+    obj[0xD] = obj[0xD] + 0xC0;
+    obj[0xE] = obj[0xE] + 0xC0;
+
+    if (*(s16 *)&obj[0xC] >= 0x3000) {
+        obj[0xE] = 0x3000;
+        obj[0xD] = 0x3000;
+        obj[0xC] = 0x3000;
+        return 1;
+    }
+    return 0;
+}
+
+
+void func_8018702C(s32 a0) {
+    extern u16 D_8019122C[];
+    extern s32 D_801DFF74;
+    extern void func_8012B2CC(s32 a0);
+    s32 prim;
+    s32 tbl;
+    s32 v0;
+
+    prim = D_801DFF74;
+    tbl = (s32)D_8019122C;
+    v0 = *(s16 *)(a0 + 0x10A) << 3;
+    *(s16 *)(prim + 6) = *(u16 *)(tbl + v0);
+    *(s16 *)(prim + 0xA) = *(u16 *)(tbl + v0 + 2);
+    *(s16 *)(prim + 0xE) = *(u16 *)(tbl + v0 + 4);
+    *(s16 *)(*(s32 *)(prim + 0x20) + 0x12) = *(u16 *)(tbl + v0 + 6);
+    func_8012B2CC(prim);
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018702C);
 
 extern s32 func_8018B1E0(s32);
 void func_80187094(void) {
@@ -6519,7 +6893,25 @@ void func_801870B4(void) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801870D4);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187148);
+extern s32 D_801DFF70;
+extern s32 D_801DFF7C;
+extern s32 func_8012B6D4(s16 *a0, s16 *a1);
+extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
+
+s32 func_80187148(s32 arg0) {
+    s32 temp;
+    s32 ret;
+
+    temp = func_8012B6D4((s16 *)(D_801DFF70 + 4), (s16 *)(D_801DFF7C + 4));
+    ret = func_8012B608(*(s16 *)(*(s32 *)(D_801DFF70 + 0x20) + 0x12), temp, 0x8);
+    *(u16 *)(*(s32 *)(D_801DFF70 + 0x20) + 0x12) += ret;
+    if (ret == 0) {
+        *(s32 *)(arg0 + 0xD4) = D_801DFF7C;
+        return 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801871E8);
 
@@ -6537,7 +6929,23 @@ extern s32 func_8001AAA0(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187304);
+extern s32 D_801DFF7C;
+extern s32 D_801B25D0;
+extern s32 D_8018CCC4;
+extern void func_8013C9C4(void *a0);
+extern void func_80187D64(s32 arg0);
+
+s32 func_80187304(void) {
+    if (*(s16 *)(D_801DFF7C + 0x98) == 0) {
+        if (*(s32 *)(D_801DFF7C + 0x90) == (s32)&D_801B25D0) {
+            func_8013C9C4(&D_8018CCC4);
+            func_80187D64(D_801DFF7C);
+        }
+        return 1;
+    }
+    return 0;
+}
+
 
 extern s32 D_801DFF74;
 extern void func_8012E8A8(u8 *a0);
@@ -6547,7 +6955,28 @@ void func_8018736C(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187394);
+#include "common.h"
+
+extern s32 D_801DFF7C;
+extern u8 D_801B2B80;
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B2CC(s32 a0);
+
+void func_80187394(void)
+{
+    s32 p;
+    s32 v1;
+
+    p = D_801DFF7C;
+    v1 = *(s32 *)((u8 *)p + 0x20);
+    *(s16 *)((u8 *)p + 6) = -0x100;
+    *(s16 *)((u8 *)p + 0xA) = -0x302;
+    *(s16 *)((u8 *)p + 0xE) = -0x1C0;
+    *(s16 *)(v1 + 0x12) = 0x200;
+    func_8012A828(p, &D_801B2B80);
+    func_8012B2CC(D_801DFF7C);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801873F4);
 
@@ -6713,7 +7142,38 @@ void func_80187B58(void) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187B80);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187C2C);
+extern s32 D_801DFF74;
+extern s32 D_801DFF88;
+extern s16 D_80191254[];
+extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+
+void func_80187C2C(void) {
+    s32 mtx[8];  /* sp+0x10 */
+    u16 sv[4];   /* sp+0x30 */
+    s32 ang[3];  /* sp+0x38 */
+
+    func_8012EC04(D_801DFF74, 4, mtx);
+    func_8012F14C((s32)mtx, (s32)D_80191254, (s32)sv);
+
+    *(s16 *)(D_801DFF88 + 0x6) = sv[0];
+    *(s16 *)(D_801DFF88 + 0xA) = sv[1];
+    *(s16 *)(D_801DFF88 + 0xE) = sv[2];
+    *(s16 *)(*(s32 *)(D_801DFF88 + 0x20) + 0x10) = 0;
+    *(s16 *)(*(s32 *)(D_801DFF88 + 0x20) + 0x12) = 0;
+    func_8012B2CC(D_801DFF88);
+
+    ang[2] = 0;
+    ang[0] = 0;
+    ang[1] = -0x300000;
+    func_8012B14C(D_801DFF88, (s32)ang);
+
+    *(s32 *)(D_801DFF88 + 0x48) = 0x18000;
+    *(s16 *)(*(s32 *)(D_801DFF88 + 0x20) + 0x10) = 0x800;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187CE4);
 
@@ -6758,7 +7218,18 @@ void func_80187D64(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80187E84);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801881D8);
+extern u16 D_800B99DA;
+extern s32 D_8018CCC4;
+extern void func_8013C9C4(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_801881D8(void) {
+    if ((D_800B99DA % 60) == 0) {
+        func_8013C9C4(&D_8018CCC4);
+        func_8002D4C8(0xB5F, 0);
+    }
+}
+
 
 #include "common.h"
 
@@ -6808,9 +7279,40 @@ void func_80188240(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801883A0);
+extern s32 D_801DFF78;
+extern void func_8012EA90(s32 param_1, s32 param_2, s32 *param_3);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern s32 func_8018BFC8(s32 a0, s32 a1);
+extern s16 D_801921AC[3];
+
+void func_801883A0(void) {
+    s16 vec[3];   /* sp+0x10..0x15 */
+    s32 buf[8];   /* sp+0x18..0x37 */
+
+    func_8012EA90(*(s32 *)&D_801DFF78, 4, (s32 *)buf);
+    func_8012F14C((s32)buf, (s32)D_801921AC, (s32)vec);
+    func_8018BFC8(*(s32 *)&D_801DFF78, (s32)vec);
+}
+
+
+extern s32 D_801DFF7C;
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u8 D_801B23E8[];
+extern u8 D_801B27B8[];
+
+void func_801883FC(void)
+{
+    s32 base;
+
+    base = D_801DFF7C;
+    if ((*(s32 *)(base + 0x94) == 7 && *(s32 *)(base + 0x90) == (s32)&D_801B23E8) ||
+        ((*(s32 *)(base + 0x94) == 0xA || *(s32 *)(base + 0x94) == 0x42) &&
+         *(s32 *)(base + 0x90) == (s32)&D_801B27B8))
+    {
+        func_8002D4C8(0xBD4, 0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801883FC);
 
 extern s32 func_8017C8E4(void);
     s32 func_80188470(void) {
@@ -6897,7 +7399,22 @@ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018884
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801888A8);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80188904);
+void func_80188904(void) {
+    extern s32 D_80191424;
+    extern s32 D_801DFFE0;
+    extern s32 D_801DFFE4;
+    extern s32 D_801DFFE8;
+    extern s32 D_801DFFEC;
+    extern void func_8012A018(s32 a0, s32 a1);
+    extern void func_80188BB0();
+
+    D_801DFFE0 = (s32)&D_80191424;
+    D_801DFFE4 = (s32)&D_80191424 + 8;
+    D_801DFFE8 = (s32)&D_80191424 - 0x20;
+    D_801DFFEC = (s32)&D_80191424 - 0x18;
+    func_8012A018((s32)func_80188BB0, 1);
+}
+
 
 extern void func_8012A018(s32 a, s32 b);
     extern void func_80188BB0();
@@ -6976,9 +7493,30 @@ void func_80188D54(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80188D90);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80189148);
+extern void (*D_801922C4[])(void);
+extern void func_80188D90();
+
+void func_80189148(void *arg0) {
+    D_801922C4[*(u16 *)((s32)arg0 + 2)]();
+    if ((*(s32 *)(*(s32 *)((s32)arg0 + 0x20) + 4) >= 0) &&
+        (*(s16 *)((s32)arg0 + 0x10A) == 0) &&
+        (*(u16 *)arg0 != 0)) {
+        func_80188D90(arg0);
+    }
+}
+
+
+#include "common.h"
+
+extern void (*D_801922EC[])(void);
+
+void func_801891D0(void *a0) {
+    D_801922EC[*(u16 *)((s32)a0 + 0x2)]();
+    if (*(u16 *)((s32)a0 + 0x0) != 0) {
+        *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) + *(u16 *)(*(s32 *)((s32)a0 + 0xDC) + 0x6);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_801891D0);
 
 #include "common.h"
 
@@ -7370,7 +7908,34 @@ void func_8018A180(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A27C);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A314);
+typedef struct { u16 h0, h1, h2, h3; } Blk8_8018A314;
+
+extern void (*D_801D4D0C)();
+
+void func_8018A314(s32 arg0)
+{
+    s32 *v1;
+    s32 a0;
+    s32 v0;
+
+    v1 = *(s32 **)(arg0 + 0x64);
+    a0 = *(s32 *)(arg0 + 0x20);
+
+    *(s32 *)(arg0 + 0x4) = v1[1];
+    *(s32 *)(arg0 + 0x8) = v1[2];
+    *(s32 *)(arg0 + 0xC) = v1[3];
+
+    *(Blk8_8018A314 *)(a0 + 0x10) = *(Blk8_8018A314 *)(v1[8] + 0x10);
+
+    if (*(s32 *)(arg0 + 0x90) == (s32)&D_801D4D0C && *(s16 *)(arg0 + 0x98) == 0) {
+        *(s32 *)(arg0 + 0x48) = 0x2000;
+        *(s32 *)(arg0 + 0x1C) = 0x80;
+        v0 = *(u16 *)(arg0 + 0x2);
+        *(u16 *)(arg0 + 0x2) = v0 + 1;
+        func_8002D4C8(0xB5C, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A3CC);
 
@@ -7431,12 +7996,75 @@ void func_8018A41C(void *a0) {
 void func_8018A564(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A56C);
+void func_8018A56C(void *a0) {
+    extern s32 func_8012C1B8(void);
+    extern void func_8012CAE4(void *a0);
+    extern void func_8001C810(s32 a0, s32 a1);
+    extern void func_8001D0E8(s32 arg0, s32 arg1, s32 arg2);
+    extern void func_8012E8A8(u8 *a0);
+    extern s32 D_801D812C[];
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((u8 *)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C810(v0, (s32)D_801D812C);
+    func_8001D0E8(*(s32 *)((u8 *)a0 + 0x20), 0x7FFF, 0x7FFF);
+    func_8012E8A8((u8 *)a0);
+
+    *(u16 *)((u8 *)a0 + 2) = *(u16 *)((u8 *)a0 + 2) + 1;
+    *(s32 *)((u8 *)a0 + 0x48) = 0xC000;
+}
+
 
 void func_8018A5E8(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A5F0);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern u16 D_800DF2E0;
+extern u16 D_8019127C[];
+extern u16 D_801922CC[];
+
+void func_8018A5F0(s32 a0)
+{
+    register s32 s0 __asm__("$16");
+    register s32 s1 __asm__("$17");
+    s32 sub;
+    u32 flags;
+    u16 half;
+
+    s1 = a0;
+    sub = ((s32 (*)(void))func_8012C1B8)();
+    s0 = sub;
+    *(s32 *)(s1 + 0x20) = s0;
+    if (s0 == 0) {
+        func_8012CAE4((void *)s1);
+        return;
+    }
+
+    func_8001C810(s0, (s32)&D_800DF2E0);
+    *(s32 *)(s0 + 0x80) = (s32)&D_8019127C;
+
+    flags = *(u32 *)(s0 + 4);
+    half = *(u16 *)(s0 + 0x2C);
+    *(u16 *)(s0 + 0x1C) = 0;
+    *(u16 *)(s0 + 0x1A) = 0;
+    *(u16 *)(s0 + 0x18) = 0;
+    *(u32 *)(s0 + 4) = flags | 0x60000000;
+    *(u16 *)(s0 + 0x2C) = half | 0xB0;
+
+    sub = *(u16 *)(s1 + 2);
+    sub = sub + 1;
+    *(s32 *)(s1 + 0xDC) = (*(s16 *)(s1 + 0x70) * 8) + (s32)&D_801922CC;
+    *(u16 *)(s1 + 2) = sub;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A6A4);
 
@@ -8582,13 +9210,54 @@ void func_8018BDD8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018BE14);
+void func_8018BE14(s32 a0) {
+    extern u8 D_801D7334;
+    extern void func_8018BE68(s32 a0);
+    s32 s0 = a0;
+    *(s32 *)(s0 + 0x1B4) = (s32)&D_801D7334;
+    func_8014E934(a0);
+    func_8014CC28(s0);
+    func_8014F3E8(s0);
+    func_8018BE68(s0);
+    func_80146CA0((void *)s0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018BE68);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018BF1C);
+#include "common.h"
+
+extern void func_80149020(s32 *a0);
+extern void func_8018BF88(s32 a0);
+extern void func_80159B3C(void *a0);
+extern M2C_UNK D_800D5880;
+extern void func_801542DC(s32 *a0, s32 a1);
+extern u8 D_800D46E4[];
+extern void func_80165718(s32 a0);
+
+void func_8018BF1C(s32 arg0)
+{
+    func_80149020(arg0);
+    *(s32 *)(arg0 + 0x1B0) = 0x12C;
+    func_8018BF88(arg0);
+    func_80159B3C((void *)arg0);
+    if (*(s32 *)(arg0 + 0xB4) == (s32)&D_800D5880) {
+        ((void (*)(s32, s32, s32))func_801542DC)(arg0, (s32)D_800D46E4, 0xE);
+    }
+    func_80165718(arg0);
+}
+
+
+extern void func_8014BC44(s32 a0, s32 a1);
+extern void func_80151664(void);
+
+void func_8018BF88(s32 a0)
+{
+    func_8014BC44(a0, *(s16 *)(a0 + 0xF2));
+    *(u8 *)(a0 + 0xA8) = 0x20;
+    ((void (*)(s32))func_80151664)(a0);
+}
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018BF88);
 
 
 extern s32 D_801E2018;
diff --git a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
index e61000e82..f278532d5 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c
@@ -3938,7 +3938,27 @@ void func_8017D648(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017D684);
+#include "common.h"
+
+extern void func_8017DAE8(void *a0, void *a1);
+extern void func_8017DF04(void *a0);
+extern void func_8017DC20(void *a0, void *a1, void *a2);
+extern u8 D_801274E8[];
+extern void (*D_80186A00[])(void);
+
+void func_8017D684(s32 a0) {
+    typedef struct { s8 c[8]; } Blk8;
+    u8 *base = D_801274E8;
+    Blk8 buffer;
+
+    *(Blk8 *)base = *(Blk8 *)D_80186A00;
+    buffer = *(Blk8 *)(base + 8);
+    ((void (*)(void *, void *))func_8017DAE8)((void *)a0, &buffer);
+    *(Blk8 *)(base + 8) = buffer;
+    ((void (*)(void *))func_8017DF04)((void *)a0);
+    func_8017DC20((void *)a0, base, base + 8);
+}
+
 
 #include "common.h"
 
@@ -4063,7 +4083,18 @@ void func_8017DA10(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DAA8);
+#include "common.h"
+
+extern void func_8017DF04(void *a0);
+extern void func_8017DC20(void *a0, void *a1, void *a2);
+extern void (*D_80186A10[])(void);
+extern void (*D_80186A18[])(void);
+
+void func_8017DAA8(void *a0) {
+    func_8017DF04(a0);
+    func_8017DC20(a0, D_80186A10, D_80186A18);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DAE8);
 
@@ -4119,7 +4150,14 @@ void func_8017DD6C(s32 param_1, s16 *param_2) {
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DF04);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DF5C);
+void func_8017DF5C(s32 a0, s32 a1) {
+    extern s32 D_801C7800;
+    extern s32 D_801C7804;
+
+    D_801C7800 = a0;
+    D_801C7804 = a1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017DF74);
 
@@ -4153,7 +4191,25 @@ void func_8017E170(s32 *a0) {
 void func_8017E1D0(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E1D8);
+#include "common.h"
+
+extern s32 D_801C7808;
+
+void func_8017E1D8(void) {
+    s32 i;
+    s32 *p;
+
+    i = 0;
+    p = &D_801C7808;
+    do {
+        if (*p != 0) {
+            ((void (*)(s32 *))(*p))((s32 *)p);
+        }
+        i++;
+        p += 6;
+    } while (i < 4);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E234);
 
@@ -4179,9 +4235,38 @@ s32 func_8017E33C(void * arg0)
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E350);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E400);
+extern void (*D_80187E48[19])(void);
+
+void func_8017E400(s32 arg0) {
+    u16 var_v1;
+
+    var_v1 = *(u16 *) (arg0 + 4);
+    *(s32 *) (arg0 + 0x10) = (s32) D_80187E48;
+    *(u16 *) (arg0 + 8) = 0;
+    *(u16 *) (arg0 + 6) = 0;
+    *(u16 *) (arg0 + 4) = var_v1 + 1;
+}
+
+
+void func_8017E424(s32 s0) {
+    extern void func_80016714();
+    extern void func_80181120();
+    s32 s1;
+
+    if (*(s16 *)(s0 + 8) == 0) {
+        s1 = *(s32 *)(s0 + 0x10);
+        if (*(s32 *)s1 != 0) {
+            func_80181120(0, *(s32 *)s1);
+            *(s16 *)(s0 + 8) = *(s32 *)(s1 + 4);
+            *(s32 *)(s0 + 0x10) = *(s32 *)(s0 + 0x10) + 8;
+        } else {
+            func_80016714((void *)s0, 0x18);
+        }
+    } else {
+        *(s16 *)(s0 + 8) = *(s16 *)(s0 + 8) - 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E424);
 
 s32 func_8017E4B0(void * arg0)
 {
@@ -4196,11 +4281,37 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E51
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E544);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E568);
+extern s32 D_801151D4;
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E59C);
+void func_8017E568(void *arg0) {
+    s32 p;
+
+    p = D_801151D4;
+    *(s32 *)(p + 0x10) = 0x190;
+    *(s32 *)(p + 0x14) = 0x190;
+    *(s16 *)(p + 0x1A) = 0x200;
+    *(s16 *)(p + 0x22) = 0x200;
+    M2C_FIELD(arg0, u16 *, 4) = (u16)(M2C_FIELD(arg0, u16 *, 4) + 1);
+    M2C_FIELD(arg0, s16 *, 0x6) = 0;
+}
+
+
+extern s32 D_801151D4;
+
+void func_8017E59C(void) {
+    s32 p = D_801151D4;
+    *(u16 *)(p + 0x1A) += 2;
+    *(u16 *)(p + 0x22) = *(u16 *)(p + 0x1A);
+}
+
+
+s32 func_8017E5C0(void * arg0)
+{
+    M2C_FIELD(arg0, u16 *, 0x8) = 0;
+    M2C_FIELD(arg0, s16 *, 0x6) = 0;
+    M2C_FIELD(arg0, u16 *, 4) = (u16) (M2C_FIELD(arg0, u16 *, 4) + 1);
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E5C0);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017E5D8);
 
@@ -4413,7 +4524,22 @@ void func_8017EBCC(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017EC68);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017ED18);
+#include "common.h"
+
+extern s32 func_80180FA4(s32, s32);
+extern void func_80181494();
+extern s32 func_8012AD50(void *a0);
+
+extern u8 D_80186EA0;
+extern s16 D_80187C80[];
+
+void func_8017ED18(s32 a0) {
+    if (((s32 (*)(s32, void *, s32))func_80180FA4)(a0, (void *)&D_80186EA0, 0) != 0) {
+        ((void (*)(void *, void *, s32))func_80181494)(0, (void *)&D_80187C80, 1);
+        func_8012AD50((void *)a0);
+    }
+}
+
 
 #include "common.h"
 
@@ -4490,7 +4616,29 @@ loop_done:
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017EE90);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80180F94(s32 a0);
+extern void func_8018122C(s32 a0, void *a1);
+extern void func_80181048(void *a0, void *a1);
+extern s32 func_8012AD50(void *arg0);
+
+extern s16 D_80188C4C;
+extern void (*D_80186DB0[])();
+
+void func_8017EE90(s32 a0) {
+    s32 s0;
+
+    s0 = a0;
+    if (func_8012BEE8(a0) != 0) {
+        func_80180F94(0xF);
+        func_8018122C(s0, &D_80188C4C);
+        func_80181048((void *)s0, &D_80186DB0);
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 #include "common.h"
 
@@ -4505,7 +4653,18 @@ void func_8017EEF0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017EF34);
+#include "common.h"
+
+extern void func_80180F94(s32 a0);
+extern s32 func_8012AD50(void *a0);
+
+void func_8017EF34(s32 a0) {
+    if (*(s16 *)(a0 + 0x98) == 0) {
+        func_80180F94(0x10);
+        func_8012AD50((void *)a0);
+    }
+}
+
 
 extern s32 func_80181280(s32 a0);
 extern void func_80180F94(s32 a0);
@@ -4573,7 +4732,7 @@ void func_8017F0BC(s32 a0) {
 extern s32 func_8012BEE8(s32 a0);
 extern void func_80180F94(s32 a0);
 extern void func_8018122C(s32 a0, void *a1);
-extern void func_80181470(s32 a0, void *a1, s32 a2);
+extern void func_80181470();
 extern void func_801826B4(void *a0);
 extern s32 func_8012AD50(void *a0);
 
@@ -4972,7 +5131,23 @@ void func_8017FAC4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017FBA0);
+#include "common.h"
+
+extern s32 D_801151D4;
+extern s32 func_801815B8(s32, s32);
+extern s32 func_80181334(s32, s32);
+extern s32 func_8012AD50(void *);
+
+void func_8017FBA0(s32 a0) {
+    s32 *ptr = (s32 *)D_801151D4;
+
+    func_801815B8(a0, 0);
+    if (func_80181334(a0, 0) != 0) {
+        ptr[5] = 0x12C;
+        func_8012AD50((void *)a0);
+    }
+}
+
 
 extern s32 func_8012AD50(void * arg0);
 extern s32 func_80181280(s32 a0);
@@ -5074,7 +5249,7 @@ void func_8017FD2C(void *a0) {
 #include "common.h"
 
 extern s32 func_80181334(s32 a0, s32 a1);
-extern void func_8018141C(s32 a0, s32 a1);
+extern void func_8018141C();
 extern s32 func_80181280(s32 a0);
 extern void func_80181048(void*, void*);
 extern void func_80180F94(s32 a0);
@@ -5137,9 +5312,55 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018000
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018004C);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801800A4);
+extern s32 func_80180F84(void);
+extern void func_801813CC(s32 a0);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012AD50(void *arg0);
+
+void func_801800A4(s32 a0) {
+    s32 status;
+    s32 *s0;
+
+    status = func_80180F84();
+    s0 = (s32 *)a0;
+
+    if (status == 0xC) {
+        func_801813CC((s32)s0);
+        func_8012BF4C(s0, 0x1E);
+        func_8012AD50((void *)s0);
+    }
+}
+
+
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80180F94(s32 a0);
+extern void func_8018122C(s32 a0, void *a1);
+extern void func_80181048(void *, void *);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern void func_801325B8(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4);
+extern s32 func_8012AD50(void *a0);
+
+extern s32 D_80188C00;
+extern s32 D_80187740;
+extern s32 D_801B54FC;
+extern s32 D_801B5CB0;
+extern s32 D_801B6438;
+
+void func_801800F4(s32 a0) {
+    s32 s0 = a0;
+
+    if (func_8012BEE8(s0) != 0) {
+        func_80180F94(0xD);
+        func_8018122C(s0, &D_80188C00);
+        func_80181048((void *)s0, &D_80187740);
+        func_8012BF4C((s32 *)s0, 0);
+        func_801325B8((s32)&D_801B54FC, (s32)&D_801B5CB0, (s32)&D_801B6438, 0, 0x1000);
+        func_8012AD50((void *)s0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801800F4);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180188);
 
@@ -5297,9 +5518,30 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801804D
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180524);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180580);
+extern s32 func_80180FA4(s32, s32);
+extern s32 func_8012AD50(void *arg0);
+extern void (*D_80187AE8)();
+
+void func_80180580(s32 a0) {
+    if (((s32 (*)(s32, void *, s32))func_80180FA4)(a0, (void *)&D_80187AE8, 0x3) != 0) {
+        func_8012AD50(a0);
+    }
+}
+
+
+extern void func_80181048(void*, void*);
+extern s32 func_8012AD50(void*);
+extern void *D_80187B90;
+
+void func_801805C4(s32 a0) {
+    register s32 s0 __asm__("$16");
+    s0 = a0;
+    if (*(s16 *)((u8 *)s0 + 0x98) == 0) {
+        ((void (*)(s32, void *))func_80181048)(s0, &D_80187B90);
+        ((s32 (*)(s32))func_8012AD50)(s0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801805C4);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180610);
 
@@ -5328,7 +5570,7 @@ extern s32 func_801815B8(s32 a0, s32 a1);
 extern s32 func_80180F84(void);
 extern s32 func_80181334(s32 a0, s32 a1);
 extern void func_801813CC(s32 a0);
-extern void func_80181470(s32 a0, void *a1, s32 a2);
+extern void func_80181470();
 extern s32 func_8012AD50(void *a0);
 extern u16 D_80187C88;
 
@@ -5354,7 +5596,24 @@ void func_801806B0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180730);
+extern s32 func_80180F84(void);
+extern void func_8018122C(s32, void*);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+extern s32 D_80188CA4[];
+
+void func_80180730(s32 a0) {
+    s32 s0 = a0;
+
+    if (func_80180F84() == 0x11) {
+        func_8018122C(s0, D_80188CA4);
+        func_8012C588(0x388, s0);
+        *(s16 *)(s0 + 0xFC) = 0;
+        func_8012AD50((void *)s0);
+    }
+}
+
 
 #include "common.h"
 
@@ -5413,7 +5672,21 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018090
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801809FC);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180A48);
+extern s32 func_8012AD50(void*);
+extern s32 func_80180F84(void);
+extern s32 func_801815B8(s32, s32);
+
+void func_80180A48(s32 a0)
+{
+    s32 v0;
+
+    func_801815B8(a0, 0);
+    v0 = func_80180F84();
+    if (v0 == 0x14) {
+        ((void (*)(s32))func_8012AD50)(a0);
+    }
+}
+
 
 extern s32 func_8012AD50(void * arg0);
 extern s32 func_8012E544(s32 a0);
@@ -5451,7 +5724,11 @@ void func_80180AE4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180B38);
+void func_80180B38(s32 a0)
+{
+    func_801815B8(a0, 0);
+}
+
 
 extern s32 func_80180F84(void);
 extern void (*D_801886A4[])(int);
@@ -5517,11 +5794,77 @@ void func_80180BC0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180C6C);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180CE8);
+extern s32 func_80180F84(void);
+extern void func_801813EC(s32 a0);
+extern s32 func_8012AD50(void *arg0);
+
+void func_80180C6C(s32 param_1)
+{
+    s32 s0;
+
+    s0 = *(s32 *)(param_1 + 0x20);
+    if (func_80180F84() == 0x18) {
+        *(u16 *)(s0 + 0x12) = 0xC00;
+        *(s32 *)(s0 + 4) &= 0x7FFFFFFF;
+        *(u16 *)(s0 + 0x2C) |= 0x10;
+        func_8017D5B0();
+        func_801813EC(param_1);
+        func_8012AD50((void *)param_1);
+    }
+}
+
+
+extern s32 func_8012AD50(void *arg0);
+extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
+
+void func_80180CE8(void *a0) {
+    s32 s0;
+    s32 ret;
+
+    s0 = *(s32 *)(a0 + 0x20);
+    ret = func_8012B608(*(s16 *)(s0 + 0x12), 0x940, 4);
+    *(s16 *)(s0 + 0x1C) = 0xB33;
+    *(s16 *)(s0 + 0x1A) = 0xB33;
+    *(s16 *)(s0 + 0x18) = 0xB33;
+    *(s16 *)(s0 + 0x12) = (*(u16 *)(s0 + 0x12) + ret) & 0xFFF;
+    if ((s16)ret == 0) {
+        func_8012AD50(a0);
+    }
+}
+
+
+#include "common.h"
+
+extern s32 func_8012AD50(void *a0);
+extern void func_8018122C(s32 a0, void *a1);
+extern void func_801827A4(void *a0);
+
+extern void (*D_80188EB0)(void *);
+extern s32 D_801C7808;
+
+void func_80180D5C(s32 a0)
+{
+    void *fn_ptr;
+    s32 i;
+    void **v1;
+
+    func_8018122C(a0, &D_80188EB0);
+
+    fn_ptr = func_801827A4;
+    i = 0;
+
+    for (v1 = (void **)&D_801C7808; i < 4; i++, v1 = (void **)((char *)v1 + 0x18)) {
+        if (v1[0] == 0) {
+            v1[0] = fn_ptr;
+            break;
+        }
+    }
+
+    func_8012AD50((void *)a0);
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180D5C);
 
 #include "common.h"
 
@@ -5560,11 +5903,49 @@ void func_80180E38(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180E74);
+extern void func_8012C1B8(void);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_80180F38(void *a0);
+extern s32 func_8012AD50(void *a0);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180EC8);
+extern u16 D_801C4C44[];
+
+void func_80180E74(void *a0) {
+    s32 v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 != 0) {
+        func_8001C214(v0, (s32)D_801C4C44);
+        *(s16 *)((s32)a0 + 0xFC) = 0;
+        func_80180F38(a0);
+        func_8012AD50(a0);
+    }
+}
+
+
+extern void func_800183E0(s32 a0);
+extern void func_80180F38(void*);
+extern s32 D_801886C8[];
+
+void func_80180EC8(s32 param_1)
+{
+    s32 temp_v0;
+
+    temp_v0 = *(u16 *)(param_1 + 0xFC);
+    *(u16 *)(param_1 + 0xFC) = temp_v0 + 1;
+    if (D_801886C8[(temp_v0 << 16) >> 16] == 0) {
+        *(u16 *)(param_1 + 0xFC) = 1;
+        func_800183E0(D_801886C8[0]);
+    } else {
+        func_800183E0(D_801886C8[(temp_v0 << 16) >> 16]);
+    }
+    ((void (*)(s32))func_80180F38)(param_1);
+}
+
+
+void func_80180F38(void *a0) {
+    *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x20) + 0x12);
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80180F38);
 
 extern void func_8012C098(void*);
 extern s32 func_8012E544(s32 a0);
@@ -5633,7 +6014,16 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801811A
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018122C);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181280);
+extern s32 func_801399F0(s32 a0);
+extern s32 D_801C79CC;
+
+s32 func_80181280(s32 a0) {
+    if (D_801C79CC == 0) {
+        return func_801399F0(*(s32 *) (a0 + 0xCC)) != 0;
+    }
+    return 0;
+}
+
 
 extern void func_80029124(s32, s32);
 void func_801812BC(void) {
@@ -5650,21 +6040,82 @@ void func_801812BC(void) {
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181334);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181384);
+extern s32 func_80029178(s32 arg);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801813A8);
+s32 func_80181384(s32 a0, s32 a1)
+{
+    return (func_80029178(a1 + 0x125) & 0xFF) != 0;
+}
+
+
+extern void func_80029124(s32, s32);
+
+void func_801813A8(s32 a0, s32 a1) {
+    func_80029124(a1 + 0x125, 0);
+}
+
+
+extern void func_80142414(s32 a0, s16 a1);
+
+void func_801813CC(s32 a0) {
+    func_80142414(a0, -0x8C);
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801813CC);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801813EC);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018141C);
+#include "common.h"
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8018144C);
+extern void func_8017DF5C(s32, s32);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181470);
+void func_8018141C(s32 param_1, s32 param_2) {
+    s32 var;
+
+    if (param_1 == 0) {
+        var = 0;
+    } else {
+        var = *(u16 *) param_1;
+    }
+    ((void (*)(s32))func_8017DF5C)(var);
+}
+
+
+extern s32 func_8017DF74();
+
+void func_8018144C(void *param_1, void *param_2) {
+    func_8017DF74((s32)param_2, -1);
+}
+
+
+extern s32 func_8017DF74();
+
+void func_80181470(s32 a0, void *a1, s32 a2) {
+    ((void (*)(void *, s32))func_8017DF74)(a1, a2);
+}
+
+
+extern s32 D_80126B58;
+extern void func_80015978(s32 a0, s32 *a1);
+extern s32 func_8017DF74();
+
+void func_80181494(s32 a0, u16 *arg1, void *a2)
+{
+    u16 sp10[3];
+    s32 base;
+
+    base = (s32)&D_80126B58;
+    if (a0 == 0) {
+        a0 = base + 4;
+    } else {
+        a0 = a0 + 4;
+    }
+    func_80015978(a0, sp10);
+    sp10[0] = sp10[0] + *(u16 *)arg1;
+    sp10[1] = sp10[1] + *(u16 *)(arg1 + 1);
+    sp10[2] = sp10[2] + *(u16 *)(arg1 + 2);
+    ((void (*)(s32, s32 *))func_8017DF74)((s32)sp10, (s32 *)a2);
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181494);
 
 
 void func_80181524(s32 *a0, s32 a1) {
@@ -5719,28 +6170,160 @@ void func_801816A4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181730);
+#include "common.h"
+
+extern void func_801827E0(void);
+extern void func_80181960(s32, s32, s32);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012AD50(void *arg0);
+
+extern s32 D_801C7A08;
+
+void func_80181730(void *a0)
+{
+    s32 *s1;
+    s32 v0;
+    void *s0;
+
+    v0 = D_801C7A08;
+    s1 = *(s32 **)(a0 + 0x20);
+    s0 = a0;
+
+    if (v0 == 0x19) {
+        func_801827E0();
+        *(u16 *)(s0 + 0x72) |= 0x1000;
+        s1[4 / 4] &= 0x7FFFFFFF;
+        func_80181960(0xFFFFFF, 2, 0);
+        func_8012BF4C((s32 *)s0, 0x3C);
+        D_801C7A08 = 0x1A;
+        func_8012AD50(s0);
+    }
+}
+
+
+#include "common.h"
+
+extern void func_80181960();
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+void func_801817D0(s32 a0) {
+    func_80181960(0xFFFFFF, 2, 0);
+    if (func_8012BEE8(a0) != 0) {
+        func_8012BF4C((s32 *)a0, 0x1E);
+        func_8012AD50((void *)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801817D0);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181828);
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181878);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181960);
+#include "common.h"
+
+extern void func_80017254(void *);
+
+void func_80181960(s32 arg0, s32 arg1, s32 arg2)
+{
+    struct {
+        u32 f00;
+        u16 f04;
+        u16 pad06;
+        u32 f08;
+        u32 pad0C;
+        u32 f10;
+        u32 pad14;
+        u32 f18;
+        u32 pad1C;
+        void *f20;
+        void *f24;
+    } st;
+
+    st.f20 = (void *)arg0;
+    st.f00 = 0xFF10FEC0;
+    st.f08 = 0xFF100140;
+    st.f10 = 0x00F0FEC0;
+    st.f18 = 0x00F00140;
+    st.f04 = arg1;
+    st.f24 = (void *)arg2;
+    func_80017254(&st);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_801819BC);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181AA8);
+void func_80181AA8(s32 *a0) {
+    extern s32 D_801C7870;
+    extern s32 D_801C7A08;
+    extern s32 D_801C7868;
+    extern s32 D_801C79A4;
+    extern s32 D_801C79B0;
+    extern s32 D_800B9A18;
+    extern void func_800146B0(s32 a0);
+    extern s32 func_8012AD50(void *arg0);
+
+    register s32 one __asm__("$2");
+    u16 flags;
+    s32 v0;
+
+    one = 1;
+    flags = *(u16 *)((s32)a0 + 0x72);
+    D_801C7870 = one;
+    *(u16 *)((s32)a0 + 0x72) = flags | 0x1000;
+
+    v0 = D_801C7A08;
+    D_801C7868 = 0;
+    D_801C79A4 = 0;
+    D_801C79B0 = 0;
+
+    if (v0 == 0x1B) {
+        func_800146B0(7);
+        D_800B9A18 = 0;
+        func_8012AD50((void *)a0);
+    }
+}
+
+
+#include "common.h"
+
+extern s32 func_80181B8C(void);
+extern void func_800146B0(s32 a0);
+extern void func_800D1724(s32 a0);
+extern s32 func_8012AD50(void * arg0);
+
+extern s32 D_800B9A18;
+extern u8 D_80186940[];
+
+void func_80181B28(s32 a0) {
+    s32 s0 = a0;
+
+    if (func_80181B8C() != 0) {
+        func_800146B0(1);
+        D_800B9A18 = 2;
+        func_800D1724((s32)D_80186940);
+        func_8012AD50((void *)s0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181B28);
 
 void func_80181B84(void) {
 }
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181B8C);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181DFC);
+void func_80181DFC(s32 arg0) {
+    extern s32 D_801C7868;
+    extern s32 D_801C786C;
+    extern s32 D_801C7870;
+
+    if (D_801C7870 != 0) {
+        D_801C7868 = 1;
+        D_801C786C = arg0;
+    }
+}
+
 
 
 
@@ -5751,7 +6334,12 @@ s32 func_80181E28(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80181E38);
+extern s32 D_801C7994[];
+
+void func_80181E38(s32 a0) {
+    D_801C7994[a0] = 0;
+}
+
 
 #include "common.h"
 
@@ -5991,9 +6579,36 @@ void func_80182AD4(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80182B10);
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80182B50);
+extern s32 func_80180F84(void);
+extern void func_80171A80(s32 *a0, s32 a1);
+extern void func_80171928(void *a0);
+extern s32 func_80171D1C(void *a0, void *a1, s32 a2);
+
+void func_80182B50(s32 a0) {
+    extern u8 D_801A35A4;
+
+    if (func_80180F84() == 0x17) {
+        func_80171A80((s32 *)a0, 0xA);
+        func_80171928((void *)a0);
+    }
+
+    func_80171D1C((void *)a0, &D_801A35A4, 0x50);
+}
+
+
+extern s32 func_80171A88(s32 a0);
+extern void func_80180F94(s32 a0);
+extern void func_80171928(void *a0);
+
+void func_80182BA8(s32 a0) {
+    u8 *p = *(u8 **)(a0 + 0x20);
+    *(u16 *)(p + 0x12) = *(u16 *)(p + 0x12) - 0x2D;
+    if (func_80171A88(a0) != 0) {
+        func_80180F94(0x18);
+        func_80171928((void *)a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_80182BA8);
 
 
 
diff --git a/src/shared/engine_core.h b/src/shared/engine_core.h
index cb6379bb6..575c2a820 100644
--- a/src/shared/engine_core.h
+++ b/src/shared/engine_core.h
@@ -61132,7 +61132,7 @@
 #define DEFINE_func_8018AD3C() \
     extern s32 D_801E0260; \
     extern s32 D_801E7980; \
-    extern void func_8018A168(s32 arg0, s32 arg1); \
+    extern void func_8018A168(); \
     void func_8018AD3C(void) { \
         D_801E7980 = &D_801E0260; \
         func_8018A168(0x474, 0x4B0); \
@@ -62006,7 +62006,7 @@
     extern void func_8016F094(s32 *a0); \
     extern s32 func_800CF854(void); \
     extern void func_800D1744(s32 *a0); \
-    extern void func_80183B64(s32 *a0); \
+    extern void func_80183B64(); \
     extern void func_80181CE0(void); \
     extern void func_80183C94(void*); \
     extern s32 D_8018EA90; \
@@ -90130,7 +90130,7 @@
     }
 
 #define DEFINE_func_80188F08() \
-    extern void func_8018A3FC(s32 *a0); \
+    extern void func_8018A3FC(); \
     extern u8 D_801E8830[]; \
     void func_80188F08(void) { \
         func_8018A3FC(D_801E8830); \
@@ -90834,7 +90834,7 @@
 #define DEFINE_func_8018AF00() \
     extern s32 D_801E03E0; \
     extern s32 D_801E7980; \
-    extern void func_8018A168(s32 arg0, s32 arg1); \
+    extern void func_8018A168(); \
     void func_8018AF00(void) { \
         D_801E7980 = &D_801E03E0; \
         func_8018A168(0x474, 0x4B0); \
@@ -156530,7 +156530,7 @@
 #define DEFINE_func_8018AD3C() \
     extern s32 D_801E0260; \
     extern s32 D_801E7980; \
-    extern void func_8018A168(s32 arg0, s32 arg1); \
+    extern void func_8018A168(); \
     void func_8018AD3C(void) { \
         D_801E7980 = &D_801E0260; \
         func_8018A168(0x474, 0x4B0); \
@@ -157404,7 +157404,7 @@
     extern void func_8016F094(s32 *a0); \
     extern s32 func_800CF854(void); \
     extern void func_800D1744(s32 *a0); \
-    extern void func_80183B64(s32 *a0); \
+    extern void func_80183B64(); \
     extern void func_80181CE0(void); \
     extern void func_80183C94(void*); \
     extern s32 D_8018EA90; \