From 28d1160ef915dc851f3dd96a0259fa151bd5a388 Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Sun, 23 Aug 2026 10:20:17 -0600
Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20ag=20=E2=80=94=2016?=
 =?UTF-8?q?1=20banked\n\nCard-fuelled=20ox=20drafts,=20reloc=5Fidentity=20?=
 =?UTF-8?q?pre-filtered,=20gated=20via=20sweep=5Fparallel.\nfunc=5F8017EF8?=
 =?UTF-8?q?8=20func=5F8017F1A4=20func=5F8017F590=20func=5F8017FA2C=20func?=
 =?UTF-8?q?=5F8017FC50=20func=5F8017FDB4=20func=5F80180250=20func=5F801809?=
 =?UTF-8?q?04=20func=5F80180B44=20func=5F80180E94=20func=5F80181598=20func?=
 =?UTF-8?q?=5F801817D8=20func=5F801818EC=20func=5F80182360=20func=5F801825?=
 =?UTF-8?q?80=20func=5F80182958=20func=5F80183154=20func=5F801831B4=20func?=
 =?UTF-8?q?=5F80183214=20func=5F80183600=20func=5F80183878=20func=5F801839?=
 =?UTF-8?q?28=20func=5F80183968=20func=5F801844B0=20func=5F80184B18=20func?=
 =?UTF-8?q?=5F80184D34=20func=5F80185378=20func=5F80185D08=20func=5F80185F?=
 =?UTF-8?q?38=20func=5F80186CE4=20func=5F80186D90=20func=5F80186F9C=20func?=
 =?UTF-8?q?=5F801870B8=20func=5F8018723C=20func=5F8017DE5C=20func=5F8017E4?=
 =?UTF-8?q?54=20func=5F8017E4F8=20func=5F8017F118=20func=5F8017F244=20func?=
 =?UTF-8?q?=5F8017F748=20=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c | 325 ++++++++++-
 src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c | 290 +++++++++-
 src/ov_SC02_027/ov_SC02_027_jr_8017D898.c | 611 ++++++++++++++++++--
 src/ov_SC02_027/ov_SC02_027_jr_8018A564.c |   2 +-
 src/ov_SC03_011/ov_SC03_011_jr_8017C730.c | 537 ++++++++++++++++--
 src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c | 648 ++++++++++++++++++++--
 src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c | 618 ++++++++++++++++++++-
 7 files changed, 2863 insertions(+), 168 deletions(-)

diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
index 96f17067f..3aee18f5b 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c
@@ -3188,7 +3188,39 @@ void func_8017CF90(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017DE5C);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017E97C(void *a0);
+
+
+void func_8017DE5C(void) {
+    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every
+       LATER function in this TU, which blocks a byte-true decl of a different type.
+       Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */
+    extern u8 D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_80126950;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    D_80126954 = 0x12C;
+    D_80126950 = 0x12C;
+    D_8012695C = 0x28A;
+    D_80126968 = 0x238;
+    D_8012696A = 0x600;
+    D_8012696C = 0;
+    D_80126976 = -0x80;
+    D_80126978 = 0;
+    D_8012697A = -0x80;
+    ((void (*)(void *, s32))func_8012A018)((void *)func_8017E97C, 0);
+    func_8012A094((s32)D_80126948);
+    func_8017E97C((void *)D_80126948);
+}
+
 
 extern void func_8012A018(s32 a, s32 b);
     extern void func_8017E97C();
@@ -3423,9 +3455,78 @@ void func_8017E348(void)
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E424);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E454);
+#include "common.h"
+
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8012A0E0(void);
+extern void func_8017E97C(void *a0);
+
+void func_8017E454(void) {
+    extern u8 D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    D_80126954 = 0x224;
+    D_8012695C = 0x3A0;
+    D_80126968 = 0x75;
+    D_8012696A = 0x800;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x35;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017E97C, 1);
+    func_8012A094((s32)D_80126948);
+    func_8017E97C(D_80126948);
+    func_8012A0E0();
+}
+
+
+extern s32 D_80126E60[];
+extern void func_8012A048(void *a0, s32 a1, u8 a2);
+extern void func_8012A094(s32 a0);
+extern void func_8017E97C(void *a0);
+extern void func_8012A100(s8 a0);
+
+s32 func_8017E4F8(void)
+{
+    extern s32 D_80126E6C;
+    extern s32 D_80126E74;
+    extern s16 D_80126E80;
+    extern s16 D_80126E82;
+    extern s16 D_80126E84;
+    extern s16 D_80126E8E;
+    extern s16 D_80126E90;
+    extern s16 D_80126E92;
+    extern s16 D_80126F00;
+
+    s32 *s0 = (s32 *)D_80126E60;
+
+    D_80126E6C = 0x12C;
+    D_80126E74 = 0x21C;
+    D_80126E80 = -0x71;
+    D_80126E82 = 0xA00;
+    {
+        s32 temp_func = (s32)func_8017E97C;
+        s32 temp_v0 = -0xA0;
+        D_80126E84 = 0;
+        D_80126E8E = 0;
+        D_80126E90 = temp_v0;
+        D_80126E92 = 0;
+
+        func_8012A048(s0, temp_func, 0x7);
+        D_80126F00 = -0x5;
+        func_8012A094((s32)s0);
+        func_8017E97C((void *)s0);
+        func_8012A100(0x1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E4F8);
 
 extern void func_8012A0E0(void);
     void func_8017E5AC(void) {
@@ -3609,7 +3710,28 @@ s32 func_8017F0FC(u8 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F118);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8001BFD0(void);
+extern void func_800D0C48(s32 a0);
+extern void func_800167B8(s32 a0);
+
+s32 func_8017F118(void *a0) {
+    s32 v0;
+    s32 v1 = -1;
+    v0 = *(s32 *)(a0 + 0x28);
+    v0 += -1;
+    *(s32 *)(a0 + 0x28) = v0;
+    if (v0 == v1) {
+        func_8002D4C8(0x1C, 0);
+        func_8001BFD0();
+        func_8002D4C8(0x1D, 0);
+        func_800D0C48(2);
+        func_800167B8(4);
+        *(u8 *)(a0 + 0x15) = *(u8 *)(a0 + 0x15) + 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F194);
 
@@ -3628,7 +3750,26 @@ extern void func_80171B44(s32 *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F244);
+extern s32 func_80171B4C(s32 a0, s32 a1);
+extern s32 func_800CF854(void);
+extern void func_80154274(s32 *a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+extern u8 D_800D5A34[];
+
+void func_8017F244(int param_1)
+{
+    if (func_80171B4C(param_1, 0x1E) != 0) {
+        if (func_800CF854() != 0) {
+            *(unsigned char *)(param_1 + 0x214) = 3;
+        } else {
+            func_80154274((s32 *)param_1, (s32)&D_800D5A34);
+            *(unsigned char *)(param_1 + 0x4D) += 1;
+            *(s32 *)(param_1 + 0x198) = func_8013767C(*(s32 *)(param_1 + 0x198));
+            *(unsigned char *)(param_1 + 0x214) += 1;
+        }
+    }
+}
+
 
 extern s32 func_801399F0(s32);
 extern void func_80139914(s32 a0);
@@ -3727,13 +3868,47 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F6A
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F6E8);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F748);
+#include "common.h"
+
+void func_8017F748(void *a0) {
+    typedef struct { u8 b[8]; } Blk8x;
+    extern Blk8x D_801E2DD0;
+    extern s32 func_80171D78(s32 a0, s32 a1);
+    extern void func_80142454(s32 a0);
+    extern s32 D_801270C8;
+    Blk8x buffer;
+
+    buffer = D_801E2DD0;
+    if (func_80171D78((s32)a0, (s32)&buffer)) {
+        D_801270C8 = 8;
+        func_80142454(-0x80);
+        *(s32 *)((s32)a0 + 0x204) = 0x20;
+        *(u8 *)((s32)a0 + 0x214) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F7CC);
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F898);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F924);
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_80154274(s32 *a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+extern u16 D_801943B0[];
+extern s32 D_8019727C;
+
+void func_8017F924(s32 arg0) {
+    s32 s0 = arg0;
+    if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(s0 + 0x198));
+        func_80154274((s32 *)s0, (s32)D_801943B0);
+        *(s32 *)(s0 + 0x198) = func_8013767C((s32)&D_8019727C);
+        *(u8 *)(s0 + 0x214) = *(u8 *)(s0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F998);
 
@@ -3755,7 +3930,24 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FB1
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FB80);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FC64);
+extern void func_80175454(void);
+
+void func_8017FC64(u8 *a0) {
+    u16 var;
+    if ((*(u16 *)((s32)a0 + 0xB8) & 0x8000) != 0) {
+        if (*(s16 *)((s32)a0 + 0x20E) < 0x1000) {
+            var = *(u16 *)((s32)a0 + 0x210) + 0xA;
+            *(u16 *)((s32)a0 + 0x210) = var;
+            *(u16 *)((s32)a0 + 0x20E) += var;
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)((s32)a0 + 0x20C) + *(u16 *)((s32)a0 + 0x20E);
+        } else {
+            *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x12) = *(u16 *)((s32)a0 + 0x20C);
+            func_80175454();
+            *(u8 *)((s32)a0 + 0x214) += 1;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FCFC);
 
@@ -3772,11 +3964,46 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FF8
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FFF0);
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180060);
+#include "common.h"
+
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_8014706C(void *arg0);
+extern u8 D_800D5A34[];
+extern s32 D_801270C8;
+
+void func_80180060(void *arg0) {
+    extern s16 D_80126968;
+
+    if (D_801270C8 == 0x15) {
+        func_80154274((s32 *)arg0, (s32)D_800D5A34);
+        func_8014706C(arg0);
+        D_80126968 = -0x71;
+        *(s32 *)((s32)arg0 + 0x204) = 0x12;
+        (*(u8 *)((s32)arg0 + 0x214))++;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801800CC);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8018016C);
+extern s32 func_801399F0(s32);
+extern void func_80139914(s32);
+extern void func_80147060(u8 * a0);
+extern void func_801903DC(void *arg0);
+extern s32 func_8017E4F8();
+
+void func_8018016C(s32 a0) {
+    s32 s0 = a0;
+    if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(s0 + 0x198));
+        func_80147060((u8 *)s0);
+        func_801903DC(0);
+        func_8017E4F8();
+        *(s32 *)(s0 + 0x204) = 0xA0;
+        *(u8 *)(s0 + 0x214) = *(u8 *)(s0 + 0x214) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801801DC);
 
@@ -3851,7 +4078,20 @@ void func_80180AE0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180B18);
+
+
+void func_80180B18(u32 arg0) {
+    extern Blk8 D_801E2E00;
+    extern s16 D_8012696A;
+    Blk8 buffer;
+
+    buffer = D_801E2E00;
+    if (func_80171D78(arg0, &buffer)) {
+        D_8012696A = 0x400;
+        *(u8 *)((s32)arg0 + 0x214) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180B90);
 
@@ -3899,7 +4139,29 @@ void func_80181028(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181060);
+extern void func_8017E898();
+extern void func_80181270(s32 a0);
+
+void func_80181060(s32 param_1)
+{
+    extern s32 D_80126958;
+    extern s32 D_8012695C;
+    extern u16 D_80126970;
+    extern s16 D_80126976;
+
+    if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(param_1 + 0x198));
+        func_8017E898();
+        *(s32 *)(param_1 + 0x204) = 0x30;
+        func_80181270(param_1);
+        D_80126970 = 0;
+        D_80126976 = 0;
+        D_80126958 = 0x190;
+        D_8012695C = 0x190;
+        *(unsigned char *)(param_1 + 0x214) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801810F0);
 
@@ -3942,7 +4204,25 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8018141
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801814B4);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181570);
+void func_80181570(s32 a0) {
+    extern s32 D_800D5C00[];
+    extern s32 D_800D6004[];
+    extern s32 D_80194370;
+    s32 v1;
+    s32 v0;
+
+    func_801816CC(a0, 0xC000);
+    v1 = *(s32 *)((s32)a0 + 0x20);
+    v0 = *(s16 *)(v1 + 0x10);
+    if (v0 < 0xC00) {
+        *(s16 *)(v1 + 0x10) = 0xC00;
+        func_80154274((s32 *)a0, (s32)D_800D5C00);
+        func_80154B4C((u8 *)a0, (s32)D_800D6004);
+        func_800D1724((s32)&D_80194370);
+        *(u8 *)((s32)a0 + 0x214) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801815FC);
 
@@ -3974,7 +4254,24 @@ s32 func_801816CC(s32 a0, s32 a1) {
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801816FC);
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181900);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80186304(u8 *a0, s32 a1, s32 a2);
+extern void func_801844D4(s32 a0);
+
+void func_80181900(s32 a0) {
+    func_8012AD44((s32 *)a0, 3);
+    func_80186304((u8 *)a0, 7, 2);
+    if (*(s16 *)((s32)a0 + 0xE0) >= 0) {
+        *(s32 *)((s32)a0 + 0x1C) = 0x1F;
+    } else {
+        *(s32 *)((s32)a0 + 0x1C) = 0x2F;
+    }
+    if (*(s32 *)((s32)a0 + 0xE8) & 0x2000) {
+        *(s32 *)((s32)a0 + 0x1C) -= 0x10;
+    }
+    func_801844D4(*(s32 *)((s32)a0 + 0xD0));
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80181984);
 
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 2c3d675a7..e1c19c74f 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -5325,7 +5325,10 @@ void func_8017E72C(int a, s16 *b, SVECTOR_8017E72C *c, SVECTOR_8017E72C *d,
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017EAC0);
+void func_8017EAC0(void *a0, s32 a1, s32 a2) {
+    func_80146A6C(0x2C, a0, 0, (s16)a1, 0, a2, 0);
+}
+
 
 
 extern void (*D_80194C98[])(void);
@@ -5810,7 +5813,17 @@ void func_8017F578(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017F5B4);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8017F630);
+extern void func_80146E90(s32 *a0, s32 a1);
+extern s32 func_80146E98(s32 a0);
+
+void func_8017F630(void *a0) {
+    if (func_80146E98((s32)a0) != 0) {
+        func_80146E90((s32 *)a0, 8);
+        *(s16 *)((u8 *)a0 + 0x28) = 0x20;
+        *(u16 *)((u8 *)a0 + 2) = *(u16 *)((u8 *)a0 + 2) + 1;
+    }
+}
+
 
     typedef struct { s16 vx; u16 vy; s16 vz, pad; } SVec_8017F67C;
 typedef struct {
@@ -7147,9 +7160,29 @@ void func_801820B8(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801820F4);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182148);
+void func_80182148(s32 a0) {
+    s16 buf[3];
+
+    buf[0] = -0xE0;
+    buf[2] = 0x3D2;
+    buf[1] = *(s16 *)(a0 + 0xA);
+    if (func_80171D78(a0, (s32)buf) != 0) {
+        func_801722CC((s32 *)a0);
+        func_80171990((u8 *)a0);
+    }
+    func_80182344(a0);
+}
+
+
+void func_801821AC(s32 param_1) {
+    func_80172304((s32 *)param_1);
+    func_80171EC8(param_1);
+    if (func_80172664((s32 *)param_1) == 0) {
+        func_80171990((u8 *)param_1);
+    }
+    func_80182344((u8 *)param_1);
+}
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801821AC);
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801821FC);
 
@@ -7157,7 +7190,12 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018226
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801822F4);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182344);
+extern s32 func_80012F74(s32 a0, s32 a1, s32 a2, s32 a3);
+
+void func_80182344(s32 param_1) {
+    *(s16 *)(param_1 + 6) = func_80012F74(*(s16 *)(param_1 + 6), -0xE0, 10, 1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182380);
 
@@ -7324,11 +7362,24 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182AF
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182B88);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182D60);
+void func_80182D60(void *a0) {
+    extern void (*D_801955B0[])(void *);
+    if (func_80182DB8(a0) == 1) {
+        D_801955B0[*(u16 *)((s32)a0 + 0x2)](a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182DB8);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182E68);
+void func_80182E68(void *a0) {
+    if ((func_800291B4(0xCD) & 0xFF) == 0 || (func_80029178(0x9E) & 0xFF) != 0) {
+        func_8012CAE4(a0);
+    } else {
+        *(u16 *)((s32)a0 + 2) = 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80182EC8);
 
@@ -7347,7 +7398,15 @@ extern void func_8012A828(s32, void*);
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183080);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018312C);
+void func_8018312C(s32 a0) {
+    extern s16 D_80195198;
+    *(s16 *)(a0 + 2) = 7;
+    func_80178CBC(a0, (s32)&D_80195198);
+    func_8012B23C(a0);
+    *(s16 *)(a0 + 0x34) = 9;
+    func_80184A54();
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80183178);
 
@@ -7444,15 +7503,44 @@ void func_8018446C(s32 param_1) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018452C);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184590);
+void func_80184590(s32 param_1) {
+    extern u8 D_80126B5C;
+    extern s32 func_8012C588(s32 a0, s32 a1);
+
+    *(s32 *)(param_1 + 4) = *(s32 *)&D_80126B5C;
+    func_8012C588(0xBA, param_1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801845C0);
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801845F4);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184738);
+void func_80184738(s32 a0) {
+    extern u8 D_801202A0[];
+    u8 *p;
+    s32 i;
+
+    p = D_801202A0;
+    for (i = 0; i < 0x60; i++, p += 0x10C) {
+        if (*(u16 *)p == 0xB0) {
+            if ((*(u16 *)(p + 0x70) & 0xF) == 0) {
+                *(s16 *)(p + 0xFC) = a0;
+                *(u16 *)(p + 0x70) |= 0x800;
+            }
+        }
+    }
+}
+
+
+void func_8018479C(void) {
+    extern u16 D_80126B66;
+    extern u16 D_80126B5E;
+    extern s32 D_80195414;
+
+    D_80195414 = ((u32)D_80126B5E | (((s32)(s16)D_80126B66 - 0x180) << 16));
+}
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018479C);
 
 extern void func_8012A568(void (*a0)(void));
     extern s32 func_8018263C();
@@ -7494,7 +7582,15 @@ void func_8018490C(s32 *a0, s32 a1, s16 a2) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184918);
+extern void func_800D0C48(s32 a0);
+
+void func_80184918(s32 arg0, s32 arg1) {
+    func_800D0C48(1);
+    *(s16 *)((s32)arg0 + 0x104) = 1;
+    *(s32 *)((s32)arg0 + 0xE4) = 0x1E;
+    *(s32 *)((s32)arg0 + 0xE0) = arg1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184964);
 
@@ -7523,7 +7619,21 @@ void func_80184ACC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184B08);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184C0C);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801F432C;
+extern s32 D_80195744;
+
+void func_80184C0C(s32 param_1) {
+    *(u16 *)(param_1 + 6) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 6);
+    *(u16 *)(param_1 + 0xE) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xE);
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12);
+    if (*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x90) == (s32)&D_801F432C) {
+        *(s16 *)(param_1 + 2) = 3;
+        func_8012A828(param_1, &D_80195744);
+        *(s32 *)(param_1 + 0x1c) = 0xe;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80184C98);
 
@@ -8079,7 +8189,16 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018618
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801861FC);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186250);
+void func_80186250(s32 arg0) {
+    extern void func_80186548(s32 *a0);
+    extern void func_8012AD44(s32 *a0, s16 a1);
+    extern s8 D_801959A8[];
+
+    *(s32 *)((s32)arg0 + 0x58) = (s32)&D_801959A8;
+    func_80186548((s32 *)arg0);
+    func_8012AD44((s32 *)arg0, 6);
+}
+
 
 s32 func_80186290(s32 arg0) {
         return *(u16*)(arg0 + 0x2) == 0x6;
@@ -8221,7 +8340,18 @@ void func_80186548(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80186558);
+void func_80186558(s32 a0) {
+    s32 v;
+
+    func_8012AD80(a0);
+    v = *(s32 *)(a0 + 0x14);
+    if (v > 0x14000) {
+        *(s32 *)(a0 + 0x48) = -0x1400;
+    } else if (v < -0x14000) {
+        *(s32 *)(a0 + 0x48) = 0x1400;
+    }
+}
+
 
 void func_801865B0(s32 arg0) {
         s32 *p = *(s32 **)((s32)arg0 + 0xcc);
@@ -8489,7 +8619,20 @@ void func_80186F74(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80187018);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018707C);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern void func_8012C218(void *a0);
+
+void func_8018707C(s32 a0)
+{
+    extern s16 D_801EBA08;
+
+    if (func_80178970() == 0) return;
+    if (D_801EBA08 != 0) return;
+    ((void (*)(s32))func_80178D18)(a0);
+    ((void (*)(s32))func_8012C218)(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801870D0);
 
@@ -8997,7 +9140,19 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801883EC);
+#include "common.h"
+
+extern void func_8002A04C(void);
+extern void func_8012C098(void);
+
+void func_801883EC(s32 a0) {
+    if (*(s16 *)(a0 + 0x102) == 0) {
+        func_8002A04C();
+    }
+
+    ((void (*)(s32))func_8012C098)(a0);
+}
+
 
 #include "common.h"
 #include "/home/musashi/bfm-decomp/src/shared/engine_core.h"
@@ -9180,7 +9335,19 @@ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188A1
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188D54);
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188D80);
+extern void func_80188DC8(void*);
+extern void func_80188DF4();
+extern short D_801D4494;
+
+void func_80188D80(s32 a0) {
+    s32 a1 = 4;
+    if (*(s16 *)((s32)a0 + 0x100) == 0) {
+        ((void (*)(s32))func_80188DC8)(a0);
+    } else {
+        ((void (*)(s32, s32, s32, s32))func_80188DF4)(a0, a1, 0x1E, (s32)&D_801D4494);
+    }
+}
+
 
 
 extern void func_8012A828(s32, void*);
@@ -9191,7 +9358,15 @@ extern void func_8012A828(s32, void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188DF4);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80188DF4(s32 arg0, s32 arg1, s32 arg2, void *arg3) {
+    *(short *)((char *)arg0 + 0x34) = arg1;
+    *(short *)((char *)arg0 + 0x2) = 4;
+    func_8012A828(arg0, arg3);
+    *(s32 *)((char *)arg0 + 0x1C) = arg2;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80188E3C);
 
@@ -9377,7 +9552,19 @@ extern void func_8012A828(s32, void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801895CC);
+void func_801895CC(s32 a0) {
+    s32 v0;
+    if (*(s16 *)(a0 + 0x100) == 0) {
+        v0 = 0xB;
+    } else {
+        if (func_8012BD3C(a0, 0x400, 0x40000) == 0) {
+            return;
+        }
+        v0 = 0xD;
+    }
+    *(s16 *)(a0 + 0x2) = v0;
+}
+
 
 
 extern void func_8012A828(s32, void*);
@@ -9388,7 +9575,13 @@ extern void func_8012A828(s32, void*);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018964C);
+void func_8018964C(void *arg0) {
+    if (*(u16 *)((s32)arg0 + 0x72) & 0x4000) {
+        *(u16 *)((s32)arg0 + 0x2) = 9;
+        *(u16 *)((s32)arg0 + 0x100) = 3;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_80189674);
 
@@ -9431,7 +9624,18 @@ void func_801896B4(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018974C);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern u8 D_801D3ACC[];
+
+void func_8018974C(s32 a0) {
+    s32 s0 = a0;
+    func_8012A828(a0, D_801D3ACC);
+    *(u16 *)(s0 + 2) = 0x10;
+    func_8012B23C(s0);
+    *(s32 *)(*(s32 *)(s0 + 0x20) + 4) |= 0x80000000;
+}
+
 
 #include "common.h"
 
@@ -9778,7 +9982,20 @@ extern s32 func_8012AD50(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018A640);
+extern s32 D_80126B58;
+extern s32 func_80172688(s32 *a0);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+void func_8018A1A4(void *a0);
+
+void func_8018A640(s32 *a0) {
+    if (func_80172688(&D_80126B58)) {
+        func_8018A1A4(a0);
+        func_8012BF4C(a0, 0x20);
+        func_8012AD50(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018A698);
 
@@ -11097,7 +11314,18 @@ void func_8018BD70(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018BDB8);
+extern void func_8002AC00(s32 arg0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8018BDB8(s32 *arg0) {
+    func_8002AC00(8);
+    if (*(u16 *)((u8 *)arg0 + 0x5E) == 0x1D) {
+        func_8002D4C8(0x440, 0);
+    } else {
+        func_8002D4C8(0x43F, 0);
+    }
+}
+
 
 
 extern void func_8012A828(s32 a0, void *a1);
@@ -11256,7 +11484,19 @@ void func_8018C388(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_8018C3C0);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_8018C3C0(s32 param_1)
+{
+    if (func_8012BEE8(param_1) == 1) {
+        if (*(s16 *)(param_1 + 0x70) & 0x8000) {
+            func_8018BE40(param_1, 0x40000, 0xC4000);
+        } else {
+            func_8018BE40(param_1, 0x9000, 0x24000);
+        }
+    }
+}
+
 
 
 // @class: plumbing
diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8017D898.c b/src/ov_SC02_027/ov_SC02_027_jr_8017D898.c
index 758d3305a..5cda2918a 100644
--- a/src/ov_SC02_027/ov_SC02_027_jr_8017D898.c
+++ b/src/ov_SC02_027/ov_SC02_027_jr_8017D898.c
@@ -3273,7 +3273,22 @@ void func_8017E8C4(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8017E904);
+extern int func_8017FAB0(int param_1);
+
+void func_8017E904(void)
+{
+
+    extern u16 D_8018FCEC[];
+    extern u8 D_8018FD8C;
+    extern u8 *D_801274C8;
+    extern void *D_801274CC;
+    extern s32 D_8012704C;
+    D_801274C8 = (u8 *)D_8018FCEC;
+    D_801274CC = (void *)&D_8018FD8C;
+    func_8017FAB0(6);
+    D_8012704C = 1;
+}
+
 
 
 extern void (*D_8018F044[])(void);
@@ -3831,7 +3846,32 @@ extern void func_801806FC(void * arg0);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80180088);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80180538);
+extern void func_8012931C(struct vec *a0);
+extern void func_80143BDC(u16 *a0);
+
+void func_80180538(void *a0) {
+    u16 sp10[3];
+    u16 sp18[3];
+
+    sp10[0] = *(u16 *)((s32)a0 + 0x6);
+    sp10[1] = *(u16 *)((s32)a0 + 0xA);
+    sp10[2] = *(u16 *)((s32)a0 + 0xE);
+
+    *(s32 *)((s32)a0 + 0x14) += 0x18000;
+
+    func_8012931C((struct vec *)a0);
+
+    sp18[0] = *(u16 *)((s32)a0 + 0x6);
+    sp18[1] = *(u16 *)((s32)a0 + 0xA);
+    sp18[2] = *(u16 *)((s32)a0 + 0xE);
+
+    if (func_80133784(1, &sp10, (s32)&sp18) != 0) {
+        sp18[1] -= 8;
+        func_80143BDC(&sp18[0]);
+        func_801292C8((u8 *)a0);
+    }
+}
+
 
 #include "common.h"
 
@@ -3982,7 +4022,20 @@ void func_801808CC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80180908);
+typedef struct { s32 w[8]; } Blk32_80180908;
+
+void func_80180908(s32 *a0) {
+    extern u8 D_801DA130[];
+    extern Blk32_80180908 D_800AE620;
+    extern Blk32_80180908 D_801DA730;
+    extern u16 D_801DA740;
+
+    func_80016714(D_801DA130, 0x600);
+    D_801DA730 = D_800AE620;
+    D_801DA740 = 0x1000;
+    *(u16 *)((u8 *)a0 + 0x2) += 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801809A8);
 
@@ -4182,7 +4235,7 @@ tail:
 
 extern code_fn D_801AB590[];
 
-extern s32 func_80182204(s32 a0);
+extern s32 func_80182204();
 
 void func_801820BC(int param_1)
 {
@@ -4192,11 +4245,41 @@ void func_801820BC(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018210C);
+extern u16 D_801AB580[];
+extern void func_8001C924(void *a0, s32 *a1);
+extern void func_8018218C(void *a0);
+
+void func_8018210C(void *a0) {
+    *(u8 *)((s32)a0 + 0xC1) = 0;
+    *(s16 *)((s32)a0 + 0x5E) = 0;
+    *(s16 *)((s32)a0 + 0x5C) = 0;
+    func_80029124(D_801AB580[*(s16 *)((s32)a0 + 0x70)], 1);
+    if (*(s32 *)((s32)a0 + 0xDC) != 0) {
+        s32 t = *(s32 *)(*(s32 *)((s32)a0 + 0xDC) + 4);
+        if (t != 0) {
+            func_8001C924((void *)*(s32 *)((s32)a0 + 0x20), (s32 *)t);
+        }
+    }
+    func_8018218C(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018218C);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182204);
+s32 func_80182204(u8 *a0)
+{
+    s32 *p;
+    void (*fp)(u8 *, u8 *);
+
+    p = *(s32 **)(a0 + 0xDC);
+    if (p != 0) {
+        fp = (void (*)(u8 *, u8 *))p[3];
+        if (fp != 0) {
+            fp(a0, a0 + 0x24);
+        }
+    }
+}
+
 
 
 /* 8-byte, align-4 pair record: the per-index slot pair at D_801DA750/D_801DA754 */
@@ -4357,7 +4440,20 @@ extern void func_8012AD44(s32 *a0, s16 a1);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801825D8);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182610);
+extern void (*D_8018B99C)(void *);
+
+void func_80182610(s32 a0)
+{
+    s32 s0 = a0;
+
+    func_80153C30();
+    func_8012DB84();
+    func_8013C9C4(&D_8018B99C);
+    func_8012AD44((s32 *)s0, 3);
+    func_8002D4C8(4, 0x675);
+    func_8002D4C8(0xAAE, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182674);
 
@@ -4370,13 +4466,32 @@ void func_801826FC(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182724);
+void func_80182724(void *arg0)
+{
+    *(s32 *)((char *)arg0 + 0x44) = 0x4000;
+    func_8012AD44((s32 *)arg0, 2);
+    func_8002D4C8(0x684, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182758);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801827C8);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182828);
+extern u16 D_80126B5E;
+
+void func_80182828(void) {
+    extern u16 D_80126B62;
+    s32 tmp;
+
+    if (*(s16 *)&D_80126B5E < 0x281) {
+        if (*(s16 *)&D_80126B62 < -0x658) {
+            tmp = -0x658;
+            *(u16 *)&D_80126B62 = (u16)tmp;
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -4467,9 +4582,37 @@ void func_80182868(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182A44);
+extern s32 func_80029178(s32 arg0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80182A44(void *arg0) {
+    if (((func_80029178(0xAE) & 0xFF) != 0) || (*(s16 *)((s32)arg0 + 0x70) == 0)) {
+        func_8012AD44((s32 *)arg0, 3);
+    } else {
+        func_8012AD44((s32 *)arg0, 1);
+    }
+}
+
+
+
+
+void func_80182AA4(void *a0) {
+    extern Stride8_s16_80182868 D_801AB676[];
+    extern void func_8012AD44(s32 *a0, s16 a1);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+    s32 v0;
+
+    v0 = D_801AB676[*(s16 *)((s32)a0 + 0x70)].v;
+    if (v0 == 0) {
+        v0 = 0x8000;
+    } else {
+        v0 = -0x8000;
+    }
+    *(s32 *)((s32)a0 + 0x44) = v0;
+    func_8012AD44((s32 *)a0, 2);
+    func_8002D4C8(0x686, 0);
+}
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182AA4);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80182AFC);
 
@@ -4684,7 +4827,16 @@ void func_80182FC8(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018309C);
+extern void func_80182724(void*);
+
+void func_8018309C(void *a0) {
+    if ((func_80029178(0xAE) & 0xFF) == 0) {
+        if (func_8012BEE8((s32)a0)) {
+            ((void (*)(s32))func_80182724)((s32)a0);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801830EC);
 
@@ -4692,7 +4844,13 @@ INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018315
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801831F4);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801832B0);
+void func_801832B0(u8 *a0)
+{
+    extern void func_80182D4C(u8 *a0, u8 *a1, s32 a2);
+    extern s32 D_801AB660[];
+    func_80182D4C(a0, (u8 *)D_801AB660, -1);
+}
+
 
 extern void func_8012AD44(s32 *a0, s16 a1);
     void func_801832D8(s32 a0) {
@@ -4701,11 +4859,49 @@ extern void func_8012AD44(s32 *a0, s16 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801832FC);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012AD44(s32 *a0, s16 a1);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80183344);
+void func_801832FC(s32 a0) {
+    *(s16 *)((s32)a0 + 0xFE) = 1;
+    func_8012C658(0x156, *(s16 *)((s32)a0 + 0x70), (s32)a0);
+    ((void (*)(void *, s32))func_8012AD44)((void *)a0, 2);
+}
+
+
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80183344(s32 a0) {
+    *(s16 *)((s32)a0 + 0x100) = 1;
+    *(s16 *)(*(s32 *)((s32)a0 + 0x20) + 0x1A) = 0x100;
+    *(s16 *)((s32)a0 + 0xFE) = 1;
+    func_8012C658(0x156, *(s16 *)((s32)a0 + 0x70), (s32)a0);
+    func_8012AD44((s32 *)a0, 2);
+}
+
+
+void func_8018339C(s32 s0) {
+    typedef void (*FuncPtr)(void);
+    extern s32 D_801AB72C[];
+    extern u16 D_80126B96;
+    extern s16 D_80126B98;
+    extern s32 func_80183418(s32 a0);
+    FuncPtr fn;
+    s16 v0;
+
+    fn = (FuncPtr)D_801AB72C[*(u16 *)(s0 + 2)];
+    fn();
+
+    v0 = *(s16 *)(s0 + 0x100);
+    if (v0 == 0) {
+        if (func_80183418(s0) != 0) {
+            D_80126B96 = 0xC00B;
+            D_80126B98 = 0x18;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018339C);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80183418);
 
@@ -4785,7 +4981,24 @@ extern void func_8012AD44(s32 *a0, s16 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801836B0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_80178D18(void);
+
+void func_801836B0(void *arg0)
+{
+    if (*(s16 *)((s32)arg0 + 0xFE) != 0) {
+        func_80178D18();
+        *(s16 *)((s32)arg0 + 0xFE) = 0;
+        *(s16 *)((s32)arg0 + 0x102) = 0;
+    }
+    __asm__ __volatile__("");
+    ((void (*)(void *, s32))func_8012AD44)(arg0, 3);
+    if (*(s16 *)((s32)arg0 + 0xFC) == 0) {
+        *(u16 *)((s32)arg0 + 0x34) = 2;
+        *(s32 *)((s32)arg0 + 0x1C) = 0x40;
+    }
+}
+
 
 #include "common.h"
 
@@ -4926,9 +5139,36 @@ extern void func_8012AD44(s32 *a0, s16 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80183938);
+extern void (*D_801AB778[])(void);
+extern void func_8012C218(void *a0);
+extern void func_8012E014(s32 arg0);
+
+void func_80183938(void *a0)
+{
+    D_801AB778[*(u16 *)((s32)a0 + 2)]();
+    if (*(s32 *)((s32)a0 + 0x64) != 0 &&
+        *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0xFE) == 0) {
+        func_8012C218(a0);
+    } else if (*(u8 *)((s32)a0 + 0x74) != 0) {
+        func_8012E014((s32)a0);
+    }
+}
+
+
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+void func_801839C8(s32 a0) {
+    s32 i;
+
+    *(u16 *)(a0 + 0xFC) = 0;
+    for (i = 0; i < 10; i++) {
+        if (func_8012C658(0x16F, i, a0) != 0) {
+            (*(u16 *)(a0 + 0xFC))++;
+        }
+    }
+    *(u16 *)(a0 + 0x106) = *(u16 *)(a0 + 0xFC);
+}
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801839C8);
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80183A40);
 
@@ -5941,7 +6181,22 @@ extern void func_8012A828(s32 a0, s32 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80185960);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012E778(s32 param_1, s32 param_2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80185960(s32 a0) {
+    if (func_8012BD3C(a0, 0x400, *(s32 *)(a0 + 0xDC)) != 0) {
+        *(s16 *)(a0 + 0x2) = 3;
+    }
+
+    if ((*(u16 *)(a0 + 0x72) & 0x4000) != 0) {
+        if (func_8012E778(a0, 0x8C00B4) == 1) {
+            func_8002D4C8(0x64A, 0);
+        }
+    }
+}
+
 
 void func_801859D0(void *a0) {
         M2C_FIELD(a0, s16 *, 0x2) = 4;
@@ -5950,7 +6205,33 @@ void func_801859D0(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801859DC);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80185BC0);
+void func_80185BC0(s32 a0)
+{
+    s32 v0;
+    register s32 v1 __asm__("$3");
+
+    if (func_8012BEE8(a0)) {
+        if (func_8012BD14(a0) > 0x18FFF) {
+            v1 = *(s32 *)(a0 + 0x20);
+            *(u16 *)(a0 + 0x2) = 6;
+            *(s32 *)(a0 + 0x1C) = 0x20;
+            *(s32 *)(v1 + 4) &= 0x7FFFFFFF;
+            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) |= 0x10;
+            v1 = *(s32 *)(a0 + 0x20);
+            *(u16 *)(v1 + 0x1C) = 1;
+            *(u16 *)(v1 + 0x1A) = 1;
+            *(u16 *)(v1 + 0x18) = 1;
+            v0 = *(s32 *)(a0 + 0x20);
+            *(u16 *)(v0 + 0x14) = 0;
+            *(u16 *)(v0 + 0x10) = 0;
+            v0 = *(s32 *)(a0 + 0x68);
+            v1 = *(s32 *)(a0 + 0x20);
+            *(u16 *)(v1 + 0x12) = *(u16 *)(v0 + 0xC);
+            func_8012B2CC(a0);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80185C84);
 
@@ -6070,7 +6351,35 @@ INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80185F0
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80185FB0);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186018);
+extern u8 D_801AF758;
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8018633C();
+
+void func_80186018(s32 self) {
+    s32 p;
+    s32 q;
+    s32 e;
+
+    p = *(s32 *)(self + 0xCC);
+    q = *(s32 *)(self + 0x20);
+    *(u16 *)(q + 0x10) = *(u16 *)(p + 0);
+    *(u16 *)(q + 0x14) = *(u16 *)(p + 4);
+    p += 8;
+    if (*(s16 *)(p + 6) == 0x7FFF) {
+        *(s32 *)(self + 0xCC) = (s32)&D_801AF758;
+    } else {
+        *(s32 *)(self + 0xCC) = p;
+    }
+    if (func_8012BEE8(self) != 0) {
+        *(u8 *)(self + 0xC1) = 0;
+        *(u16 *)(self + 0x5E) = 0;
+        e = *(s32 *)(self + 0x20);
+        *(u16 *)(e + 0x14) = 0;
+        *(u16 *)(e + 0x10) = 0;
+        func_8018633C(self);
+    }
+}
+
 
 void func_801860A8(void *a0) {
         *(short *)((char *)a0 + 0x5c) = 0;
@@ -6147,13 +6456,126 @@ void func_801860B8(s32 arg0_)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801861E8);
+void func_801861E8(s32 a0) {
+    s32 var_s0;
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186248);
+    var_s0 = 0x10000;
+    *(s16 *)(a0 + 0x5C) = 0;
+    *(s32 *)(a0 + 0x1C) = 0x1E;
+    if ((*(u16 *)(a0 + 0x70) & 1) == 0) {
+        var_s0 = 0x6400;
+    }
+    if (func_8012BD14(a0) < var_s0) {
+        func_8002D4C8(0x64B, 0);
+    } else {
+        func_8002D4C8(0x652, 0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801862A8);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018633C);
+extern void func_8002AC00(s32 arg0);
+extern void func_80130D48(s32 a0);
+extern s32 func_801862A8();
+extern s32 func_8012BEE8(s32 a0);
+
+void func_80186248(void *a0) {
+    s32 *ent = *(s32 **)((s32)a0 + 0x20);
+    ent[1] ^= 0x80000000;
+    if (func_8012BEE8((s32)a0)) {
+        func_8002AC00(0xF);
+        func_80130D48((s32)a0);
+        func_801862A8(a0);
+    }
+}
+
+
+extern void func_8012C098(void *param_1);
+
+s32 func_801862A8(s32 arg0)
+{
+    s32 temp;
+
+    func_8002A04C(arg0);
+    if ((*(s16 *)(arg0 + 0x70) & 0xC000) != 0) {
+        func_8012C098((void *)arg0);
+    } else {
+        temp = *(s32 *)(arg0 + 0x20);
+        *(s16 *)(arg0 + 0x2) = 5;
+        *(s8 *)(arg0 + 0xC1) = 0;
+        *(s32 *)(arg0 + 0x1C) = 0x78;
+        *(s16 *)(arg0 + 0x5E) = 0;
+        *(s16 *)(arg0 + 0x5C) = 0;
+        *(s32 *)(temp + 0x4) |= 0x80000000;
+        *(u16 *)(arg0 + 0xAA) = 0;
+        *(s16 *)(arg0 + 0x6) = *(u16 *)(arg0 + 0x88);
+        *(s16 *)(arg0 + 0xA) = *(u16 *)(arg0 + 0x8A);
+        *(s16 *)(arg0 + 0xE) = *(u16 *)(arg0 + 0x8C);
+    }
+}
+
+
+typedef struct {
+    u8  pad00[0x02];
+    u16 f02;
+    u8  pad04[0x02];
+    u16 f06;
+    u8  pad08[0x02];
+    u16 f0A;
+    u8  pad0C[0x02];
+    u16 f0E;
+    u8  pad10[0x08];
+    u16 f18;
+    u16 f1A;
+    u16 f1C;
+    u8  pad1E[0x02];
+    void *f20;
+    u8  pad24[0x08];
+    u16 f2C;
+    u8  pad2E[0x2E];
+    u16 f5C;
+    u8  pad5E[0x12];
+    u16 f70;
+    u8  pad72[0x06];
+    void *f78;
+    u8  pad7C[0x0C];
+    u16 f88;
+    u16 f8A;
+    u16 f8C;
+    u8  pad8E[0x72];
+    u16 f100;
+} Str_8018633C;
+
+void func_8018633C(Str_8018633C *arg0) {
+    u16 a;
+    u16 b;
+    u16 c;
+    u16 d;
+    u16 e;
+    void *t;
+    void *p;
+
+    arg0->f02 = 1;
+    t = arg0->f78;
+    a = *(u16 *)((u8 *)t + 2);
+    b = arg0->f88;
+    c = arg0->f8A;
+    d = arg0->f8C;
+    e = arg0->f70;
+    arg0->f06 = b;
+    arg0->f0A = c;
+    arg0->f0E = d;
+    arg0->f5C = a;
+    if (e & 1) {
+        p = arg0->f20;
+        *(u16 *)((u8 *)p + 0x2C) |= 0x10;
+        p = arg0->f20;
+        *(u16 *)((u8 *)p + 0x1C) = 0x1666;
+        *(u16 *)((u8 *)p + 0x1A) = 0x1666;
+        *(u16 *)((u8 *)p + 0x18) = 0x1666;
+        arg0->f100 = 0x1666;
+    }
+}
+
 
 
 extern void (*D_801AF89C[])(void);
@@ -6163,7 +6585,34 @@ void func_801863B0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801863EC);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern u8 D_801B30B0;
+
+typedef struct {
+    u16 a, b, c, d;
+} Rec8_801863EC;
+
+void func_801863EC(s32 a0)
+{
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+    } else {
+        func_8001C214(v0, (s32)&D_801B30B0);
+        *(s16 *)(a0 + 0xFC) = *(u16 *)(*(s32 *)(a0 + 0x64) + 0x36);
+        *(Rec8_801863EC *)(*(s32 *)(a0 + 0x20) + 0x18) =
+            *(Rec8_801863EC *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x18);
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) =
+            *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x2C);
+        *(s16 *)(a0 + 0x2) = 1;
+    }
+}
+
 
 extern void func_8012C218(void *a0);
     void func_801864A4(s32 arg0) {
@@ -6181,11 +6630,39 @@ void func_801864E0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_8018651C);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8012E8A8(u8 *a0);
+
+void func_8018651C(void *a0) {
+
+    extern u8 D_801AF8B4[];
+    s32 ptr;
+    unsigned short v1;
+    unsigned short v0;
+
+    if (func_8012C354((s32)a0, (s32)D_801AF8B4) == 0) {
+        return;
+    }
+
+    ptr = *(s32 *)((s32)a0 + 0x64);
+    v1 = *(unsigned short *)(ptr + 0x36);
+    v0 = *(unsigned short *)((s32)a0 + 0x70);
+    *(unsigned short *)((s32)a0 + 0xFC) = v1;
+
+    if (!(v0 & 1)) {
+        func_8012E8A8((u8 *)a0);
+    }
+
+    ptr = *(s32 *)((s32)a0 + 0x64);
+    v1 = *(unsigned short *)(ptr + 0xFC);
+    *(unsigned short *)((s32)a0 + 0x2) = 1;
+    *(unsigned short *)((s32)a0 + 0x104) = v1;
+}
+
 
 #include "common.h"
 
-extern s32 func_80186A30(s32 a0);
+extern s32 func_80186A30();
 extern u8 D_801B4380;
 
 void func_80186594(s32 a0) {
@@ -6244,7 +6721,7 @@ typedef struct {
 extern void func_8012F14C(s32 a0, s32 a1, s32 a2);  /* TU:329 file scope, verbatim */
 extern s32  func_8012BEE8(s32 a0);                  /* TU:4993/5216/7272, verbatim */
 extern void func_8012CC1C(s32 arg0, s32 arg1);      /* fleet-canonical void; $v0 used -> cast */
-extern s32  func_80186A30(s32 a0);
+extern s32  func_80186A30();
 extern void func_80186B68(s32 a0, s32 a1);
 extern void func_80186AAC(s32 a0);
 extern void func_801869C0(s32 a0);
@@ -6325,11 +6802,53 @@ void func_801867AC(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_801869C0);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186A30);
+extern void func_80186A70(void);
+
+s32 func_80186A30(void *a0) {
+    u8 *a0_byte = (u8 *)a0;
+    s32 *v0 = *(s32 **)(a0_byte + 0x64);
+    s16 v1 = *(s16 *)((u8 *)v0 + 0x36);
+    s16 v2 = *(s16 *)(a0_byte + 0xFC);
+
+    if (v1 == v2) {
+        return 0;
+    }
+    func_80186A70();
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186A70);
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186AAC);
+void func_80186AAC(s32 a0) {
+    s32 *s1;
+    s32 *s0;
+    s16 *v1;
+
+    s1 = (s32 *)a0;
+    s0 = *(s32 **)((u8 *)s1 + 0x64);
+    func_8002D59C(4, 0x64E, *(u16 *)((u8 *)s1 + 0x104));
+    *(s32 *)((u8 *)s1 + 0x4) = *(s32 *)((u8 *)s0 + 0x4);
+    *(s32 *)((u8 *)s1 + 0x8) = *(s32 *)((u8 *)s0 + 0x8) - 0x260000;
+    *(s32 *)((u8 *)s1 + 0xC) = *(s32 *)((u8 *)s0 + 0xC);
+    *(u16 *)((u8 *)s1 + 0x70) = 1;
+    v1 = *(s16 **)((u8 *)s1 + 0x20);
+    if (*(u16 *)((u8 *)s0 + 0x70) & 1) {
+        *(u16 *)((u8 *)v1 + 0x14) = 0;
+        *(u16 *)((u8 *)v1 + 0x12) = 0;
+        *(u16 *)((u8 *)v1 + 0x10) = 0;
+        *(u16 *)((u8 *)v1 + 0x1C) = 1;
+        *(u16 *)((u8 *)v1 + 0x1A) = 1;
+        *(u16 *)((u8 *)v1 + 0x18) = 1;
+    } else {
+        *(u16 *)((u8 *)v1 + 0x14) = 0;
+        *(u16 *)((u8 *)v1 + 0x12) = 0;
+        *(u16 *)((u8 *)v1 + 0x10) = 0;
+        *(u16 *)((u8 *)v1 + 0x2C) = *(u16 *)((u8 *)v1 + 0x2C) & 0xFFEF;
+    }
+    *(u16 *)((u8 *)s1 + 0x2) = 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80186B68);
 
@@ -8749,7 +9268,33 @@ void func_80189E74(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80189EB0);
+extern void func_8018A090(void *a0);
+extern s32 rand(void);
+extern s32 func_8012AD50(void *a0);
+extern u8 D_801DA8CC[];
+
+void func_80189EB0(void *a0)
+{
+    u8 *p;
+    s32 i;
+
+    i = 4;
+    if (*(s16 *)((s32)a0 + 0xDE) != 0) {
+        func_8018A090((void *)a0);
+        return;
+    }
+
+    p = D_801DA8CC;
+    do {
+        *p = 0;
+        p--;
+        i--;
+    } while (i >= 0);
+
+    *(s32 *)((s32)a0 + 0x1C) = (rand() & 0x7F) + 0x40;
+    func_8012AD50((void *)a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8017D898", func_80189F28);
 
diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8018A564.c b/src/ov_SC02_027/ov_SC02_027_jr_8018A564.c
index 9a8f13893..39c96bca7 100644
--- a/src/ov_SC02_027/ov_SC02_027_jr_8018A564.c
+++ b/src/ov_SC02_027/ov_SC02_027_jr_8018A564.c
@@ -2739,7 +2739,7 @@ extern s32 func_8012BEE8(s32 a0);
 extern void func_8012C218(void*);
 extern void func_80181E50(s32 a0);
 extern code_fn D_801AB590[];
-extern s32 func_80182204(s32 a0);
+extern s32 func_80182204();
 extern void func_801820BC(int param_1);
 extern void (*D_801AB5EC[])(void);
 extern void func_80182460(void *a0);
diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c b/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
index 98ca29bb2..d26b5f9e8 100644
--- a/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
+++ b/src/ov_SC03_011/ov_SC03_011_jr_8017C730.c
@@ -3197,7 +3197,19 @@ void func_8017D690(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017D6CC);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017D718);
+extern void func_800167B8(s32 a0);
+
+s32 func_8017D718(s32 a0) {
+    s32 temp_v0;
+    func_800167B8(0);
+    temp_v0 = *(s32 *)(a0 + 0x28) - 1;
+    *(s32 *)(a0 + 0x28) = temp_v0;
+    if (temp_v0 == -1) {
+        *(u8 *)(a0 + 0x15) += 1;
+    }
+    return 0;
+}
+
 
 
 extern s32 func_800167F0(s32 a0);
@@ -3263,7 +3275,33 @@ void func_8017D930(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017D96C);
+extern s32 func_80029178(s32 a0);
+extern void func_80029124(s32 a0, s32 a1);
+extern void func_800D0C48(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8001BFD0(void);
+extern void func_800D1E28(void);
+extern s32 D_801A23FC;
+
+s32 func_8017D96C(s32 a0) {
+    s32 t;
+
+    t = *(s32 *)(a0 + 0x28) - 1;
+    *(s32 *)(a0 + 0x28) = t;
+    if (t == -1) {
+        if ((func_80029178(0x90) & 0xFF) == 0 || D_801A23FC != 0) {
+            func_80029124(0x90, 0x1);
+            func_800D0C48(0x1);
+            func_8002D4C8(0x1C, 0);
+            func_8001BFD0();
+            func_8002D4C8(0x1D, 0);
+        }
+        func_800D1E28();
+        *(u8 *)(a0 + 0x15) += 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DA1C);
 
@@ -3277,7 +3315,26 @@ void func_8017DA54(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DA90);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DAC8);
+extern void func_8016F2A8(void);
+extern void func_8016F2EC(void);
+extern s32 func_8012DB84(void);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017DAC8(s32 *a0) {
+    s32 v0;
+    s32 v1;
+    v0 = a0[0x80];
+    v1 = v0 - 1;
+    a0[0x80] = v1;
+    if (v1 != -1) {
+        return;
+    }
+    func_8016F2A8();
+    func_8016F2EC();
+    func_8012DB84();
+    func_80171990((u8 *)a0);
+}
+
 
 void func_8017DB20(void) {
 }
@@ -3317,7 +3374,17 @@ void func_8017DCA0(void) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DCC8);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DD30);
+extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
+void func_8017DD30(void) {
+
+    extern s32 D_801A2238;
+    extern s32 D_801A23FC;
+    extern s32 D_801850B0(void *a0);
+    D_801A2238 = 0;
+    D_801A23FC = 0;
+    ((void (*)(void *, s32))func_8016EE40)((void *)D_801850B0, 0x1000000);
+}
+
 
 extern void func_8017FB78(s32);
     extern void func_80171928(void *a0);
@@ -3355,9 +3422,35 @@ void func_8017DE98(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DED4);
+extern s32 D_80185EC8;
+extern s32 func_8013767C(s32 a0);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017DED4(u8 *a0) {
+    *(s32 *)(a0 + 0x198) = func_8013767C((s32)&D_80185EC8);
+    func_80171990(a0);
+}
+
+
+extern s32 D_80185F04;
+
+extern s32 func_801399F0(s32 a0);
+extern void func_80139914(s32 a0);
+extern void func_80029124(s32 a0, s32 a1);
+extern s32 func_8013767C(s32 a0);
+extern s32 func_80171990(u8 *a0);
+
+void func_8017DF14(s32 param_1)
+{
+    if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(param_1 + 0x198));
+        *(s32 *)(param_1 + 0x198) = 0;
+        func_80029124(0xBD, 1);
+        *(s32 *)(param_1 + 0x198) = func_8013767C((s32)&D_80185F04);
+        func_80171990((u8 *)param_1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DF14);
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017DF84);
 
@@ -3397,9 +3490,44 @@ void func_8017E214(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E248);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E2F0);
+
+extern Vec8_8017E0B4 D_801A0E34;
+extern Vec8_8017E0B4 D_801A0E3C;
+extern s32 D_80126984;
+extern s32 D_80126988;
+extern s32 D_8012698C;
+extern s32 D_80126990;
+extern s32 D_80126994;
+extern s32 D_80126998;
+
+void func_8017E248(void)
+{
+    Vec8_8017E0B4 a;
+    Vec8_8017E0B4 b;
+
+    a = D_801A0E34;
+    b = D_801A0E3C;
+
+    D_80126984 = a.vx;
+    D_80126988 = a.vy;
+    D_8012698C = a.vz;
+    D_80126990 = b.vx;
+    D_80126994 = b.vy;
+    D_80126998 = b.vz;
+}
+
+
+extern s32 func_80175014(u8 *a0, u8 *a1, s32 a2);
+extern void func_80129FF4(void);
+extern u8 D_80126948[];
+extern s32 D_80197608;
+
+void func_8017E2F0(void) {
+    func_80175014(D_80126948, &D_80197608, 0);
+    func_80129FF4();
+}
+
 
 extern s32 D_80197608;
 extern s32 D_80126950;
@@ -3411,7 +3539,13 @@ void func_8017E328(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E35C);
+extern u8 D_80126948[];
+extern s32 D_80197608;
+void func_8017E35C(void) {
+    func_80175014(D_80126948, (u8 *)&D_80197608, 0xC7);
+    func_80129FF4();
+}
+
 
 
 extern void (*D_801851FC[])(void);
@@ -3611,11 +3745,76 @@ void func_8017E65C(s32 a0) {
 void func_8017E7C8(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E7D0);
+extern u16 D_800B99DC;
+extern u8 D_801819E8[];
+extern u8 D_80185200[];
+extern void func_8013C9C4(void *a0);
+extern void func_8017E92C(void *a0);
+extern void func_8017E884(s32, s32);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E884);
+void func_8017E7D0(void *a0)
+{
+    s16 t;
+    u16 y;
+    u32 i;
+    u8 *p;
+
+    t = *(s16 *)((u8 *)a0 + 0xE4);
+    if (t != 0) {
+        y = *(u16 *)((u8 *)a0 + 0xE2);
+        *(s16 *)((u8 *)a0 + 0xE4) = t - 1;
+        y = y - 1;
+        *(u16 *)((u8 *)a0 + 0xE2) = y;
+        if ((y << 0x10) == 0) {
+            *(u16 *)((u8 *)a0 + 0xE2) = (D_800B99DC & 0x3) + 7;
+            func_8013C9C4((void *)D_801819E8);
+        }
+    }
+    func_8017E92C(a0);
+    i = 0;
+    p = D_80185200;
+    do {
+        ((void (*)(void *, void *))func_8017E884)(a0, p);
+        i = i + 1;
+        p = p + 0x10;
+    } while (i < 8);
+}
+
+
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_8017E884(s32 a0, s32 a1) {
+    s32 s0;
+    s32 v0;
+    s32 v1;
+
+    s0 = a1;
+    *(s32 *)(s0 + 8) -= 1;
+    if (*(s32 *)(s0 + 8) != 0) {
+        return;
+    }
+    *(s32 *)(s0 + 8) = 4;
+    a0 = func_80132EF4(a0, 0x26);
+    if (a0 == 0) {
+        return;
+    }
+    v0 = *(s32 *)(s0 + 0xC);
+    v1 = *(s32 *)(a0 + 0x20);
+    v0 = v0 << 12;
+    *(s16 *)(v1 + 0x18) = v0;
+    *(s16 *)(v1 + 0x1A) = v0;
+    *(s16 *)(v1 + 0x18) = v0;
+    *(u16 *)(a0 + 6) = *(u16 *)(s0 + 0);
+    *(u16 *)(a0 + 0xA) = *(u16 *)(s0 + 2);
+    *(u16 *)(a0 + 0xE) = *(u16 *)(s0 + 4);
+    *(s32 *)(a0 + 0x14) = 0xFFE40000;
+}
+
+
+void func_8017E918(s32 a0) {
+    *(u16 *)(a0 + 0x6) = *(u16 *)(*(s32 *)(a0 + 0x64) + 0xDE);
+}
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E918);
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017E92C);
 
@@ -3627,7 +3826,26 @@ void func_8017EA24(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017EA60);
+extern u8 D_800D387C[];
+extern u8 D_800D3888[];
+
+extern void func_80128EA8(s32 a0, s32 a1, s32 a2);
+
+void func_8017EA60(s32 param_1)
+{
+    *(u32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = (u32)&D_800D387C;
+
+    *(u32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x50000000;
+
+    *(u8 *)(*(s32 *)(param_1 + 0x20) + 0x27) = 0x9C;
+
+    func_80128EA8(*(u32 *)(param_1 + 0x20), param_1 + 0x24, (s32)&D_800D3888);
+
+    *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+    *(u32 *)(param_1 + 0x10) = 0;
+    *(u32 *)(param_1 + 0x18) = 0;
+}
+
 
 extern s32 func_80128ED8(s32 param_1, s32 *param_2);
 extern void func_801292C8(u8 *a0);
@@ -3793,7 +4011,13 @@ void func_8017ECD4(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017EF28);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F0D0);
+void func_8017F0D0(s32 a0) {
+    if (*(s16 *)(a0 + 0xFC) != 0) {
+        func_8002D4C8(4, 0x645);
+        *(s16 *)(a0 + 0xFC) = 0;
+    }
+}
+
 
 
 extern void (*D_80185458[])(void);
@@ -3859,7 +4083,7 @@ void func_8017F240(void *a0) {
 #include "common.h"
 
 extern u8 *func_8012913C(s32 a0);
-extern void func_8017F370(void);
+extern void func_8017F370();
 extern void func_801292C8(u8 *a0);
 extern void func_8012931C(void *);
 extern s32 D_801269B4;
@@ -3897,7 +4121,33 @@ void func_8017F27C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F370);
+#include "common.h"
+
+extern s32 ratan2(s32 a0, s32 a1);
+extern void func_80049CAC(s32 a0, s32 a1);
+extern void func_800484EC(s32 a0, s32 a1, s32 a2);
+
+/* Local stack-frame shapes declared under this function's own address (law 1b).
+ * sp+0x10: 0x20-byte matrix block, filled by func_80049CAC, consumed by func_800484EC.
+ * sp+0x30: 12-byte vector block -- the target emits word stores only, so s32 members. */
+typedef struct { s32 w[8]; } Mtx_8017F370;         /* 0x20 */
+typedef struct { s32 f0, f4, f8; } Vec12_8017F370; /* 0x0C */
+
+void func_8017F370(s32 arg0) {
+    Mtx_8017F370 m;    /* sp+0x10 */
+    Vec12_8017F370 v;  /* sp+0x30 */
+
+    v.f0 = 0;
+    v.f4 = *(s32 *)(arg0 + 0x2C);
+    v.f8 = *(s32 *)(arg0 + 0x30);
+
+    *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12) =
+        (ratan2(-(s32)*(s16 *)(arg0 + 0xE), (s32)*(s16 *)(arg0 + 6)) + 0x400) & 0xFFF;
+
+    func_80049CAC(*(s32 *)(arg0 + 0x20) + 0x10, (s32)&m);
+    func_800484EC((s32)&m, (s32)&v, arg0 + 0x10);
+}
+
 
 #include "common.h"
 
@@ -3952,9 +4202,57 @@ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F71
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F790);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F84C);
+#include "common.h"
+
+extern s32 ratan2(s32 a0, s32 a1);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B14C(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+
+void func_8017F84C(void *a0)
+{
+    register void *s0 __asm__("$16") = a0;
+    s32 r;
+    s32 v0;
+    s32 buf[4];
+
+    r = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((u8 *)s0 + 0x20) = r;
+    if (r == 0) {
+        func_8012CAE4(s0);
+    } else {
+        func_8001C2C4(r);
+        v0 = ratan2( -*(s16 *)((u8 *)s0 + 0xE), *(s16 *)((u8 *)s0 + 0x6) );
+        *(s16 *)(*(s32 *)((u8 *)s0 + 0x20) + 0x12) = (v0 + 0x400) & 0xFFF;
+        *(s16 *)(*(s32 *)((u8 *)s0 + 0x20) + 0x10) = *(u16 *)((u8 *)s0 + 0x70);
+        func_8012B2CC((s32)s0);
+        buf[1] = 0;
+        buf[0] = 0;
+        buf[2] = 0x180000;
+        func_8012B14C((s32)s0, (s32)buf);
+        ((void (*)(void *))func_8012AD50)(s0);
+        v0 = func_80132EF4((s32)s0, 0x23);
+        if (v0 != 0) {
+            *(s16 *)(v0 + 0x34) = 0x4000;
+            *(s32 *)((u8 *)s0 + 0x1C) = 8;
+        }
+    }
+}
+
+
+extern s32 func_8012BEE8(s32 arg0);
+
+void func_8017F910(s32 arg0) {
+    if (func_8012BEE8(arg0) != 0) {
+        func_8012AD50((void *)arg0);
+        *(s32 *)(arg0 + 0x1C) = 0x40;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F910);
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017F950);
 
@@ -4036,7 +4334,31 @@ void func_8017FD28(void) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FD30);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FE30);
+void func_8017FE30(s32 a0) {
+    u8 *p;
+    s16 val;
+
+    p = *(u8 **)(a0 + 0x20);
+    *(u16 *)(p + 0x10) &= 0xFFF;
+
+    val = *(s16 *)(*(u8 **)(a0 + 0x20) + 0x10);
+    if (val == 0 || val < 0x101) {
+        *(s16 *)(a0 + 0x2) = 1;
+        *(u16 *)(*(u8 **)(a0 + 0x20) + 0x10) = 0;
+        *(s16 *)(a0 + 0x84) = 0;
+        return;
+    }
+    if (val < 0xF81) {
+        *(u16 *)(*(u8 **)(a0 + 0x20) + 0x10) = val + 0x10;
+        return;
+    }
+    if (*(s16 *)(a0 + 0x84) == 0 && val >= 0xF88) {
+        func_8002D4C8(0x550, 0);
+        *(s16 *)(a0 + 0x84) = 1;
+    }
+    *(u16 *)(*(u8 **)(a0 + 0x20) + 0x10) += 4;
+}
+
 
 
 // @class: struct
@@ -4044,7 +4366,7 @@ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FE3
 
 extern code_fn D_8018550C[];
 
-extern s32 func_801800F8(s32 a0);
+extern s32 func_801800F8();
 
 void func_8017FEF8(int param_1)
 {
@@ -4059,9 +4381,38 @@ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FF4
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8017FFF0);
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8018009C);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_80127058;
+
+void func_8018009C(u8 *a0) {
+    u8 *p = *(u8 **)(a0 + 0x20);
+    *(u16 *)(p + 0x14) = (*(u16 *)(p + 0x14) - 0x71) & 0xFFF;
+    if (func_8012BEE8(a0) == 0) {
+        return;
+    }
+    *(u8 *)&D_80127058 = 0;
+    func_8012AD44((s32 *)a0, 1);
+}
+
+
+typedef struct { u32 w0; u32 w1; } __attribute__((packed, aligned(1))) Blk8_801800F8;
+extern Blk8_801800F8 D_801A0E64;
+extern void func_8012F214(s32 a0, s32 a1, s32 a2);
+extern void func_80015954(s32 a0, s32 a1);
+
+s32 func_801800F8(s32 *a0)
+{
+    Blk8_801800F8 buf;
+    void *out;
+
+    buf = D_801A0E64;
+    func_8012F214(a0[0x19], (s32)&buf, (s32)&out);
+    func_80015954((s32)&out, (s32)(a0 + 1));
+    *(u16 *)((u8 *)*(u32 **)((u8 *)a0 + 0x20) + 0x10) = *(u16 *)((u8 *)*(u32 **)((u8 *)(*(u32 **)((u8 *)a0 + 0x64)) + 0x20) + 0x10);
+    *(u16 *)((u8 *)*(u32 **)((u8 *)a0 + 0x20) + 0x12) = *(u16 *)((u8 *)*(u32 **)((u8 *)(*(u32 **)((u8 *)a0 + 0x64)) + 0x20) + 0x12);
+}
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801800F8);
 
 
 extern void (*D_80185568[])(void);
@@ -4121,14 +4472,35 @@ void func_801803A0(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801803B0);
+extern s32 D_801A2278;
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_801803B0(void) {
+    D_801A2278++;
+    if (D_801A2278 == D_801A2278 / 10 * 10) {
+        func_8002D4C8(0xB3D, 0);
+    }
+}
+
 
 void func_80180414(void) {
 }
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8018041C);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180470);
+extern int func_80178970(void);
+extern void func_80029124(s32, s32);
+extern void func_80178D18(void);
+void func_80180358(void *a0);
+
+void func_80180470(void *a0) {
+    if (func_80178970() != 0) {
+        func_80029124(0xF2, 1);
+        ((void (*)(s32))func_80178D18)(a0);
+        func_80180358(a0);
+    }
+}
+
 
 void func_801804B8(void) {
 }
@@ -4142,7 +4514,21 @@ s32 func_80180598(void) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801805A0);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180604);
+extern void func_8012E88C(u8 *a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern s32 D_80185818;
+extern s32 D_8019EC70;
+
+void func_80180604(void *a0) {
+    void *s0 = a0;
+    *(u16 *)((s32)a0 + 2) = 4;
+    *(u16 *)((s32)a0 + 0x34) = 0;
+    func_8012E88C((u8 *)s0);
+    func_8012A828((s32)s0, &D_8019EC70);
+    func_8012E8E0((s32)s0, (s32)&D_80185818);
+}
+
 
 
 extern void (*D_801859A8[])(void);
@@ -4166,9 +4552,48 @@ extern void func_80162120(void);
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801806D4);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180734);
+extern void func_80178D18(void);
+extern void func_80180604(void *a0);
+
+void func_80180734(void *arg0) {
+    if (func_80178970()) {
+        ((void (*)(void *))func_80178D18)(arg0);
+        func_80180604(arg0);
+    }
+}
+
+
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern void func_80178CBC(int arg0, int arg1);
+extern void func_8012E88C(unsigned char *a0);
+extern void func_8012A828(int a0, void *a1);
+extern void func_8012E8E0(int a0, int a1);
+extern int D_80185818;
+extern int D_8019EC70;
+extern void (*D_80185948)(void);
+
+void func_80180774(void *a0) {
+    switch (*(u16 *)((s32)a0 + 0x34)) {
+    case 0:
+        break;
+    case 1:
+        func_80178CBC((s32)a0, (s32)&D_80185948);
+        *(s16 *)((s32)a0 + 0x34) = (s16)(*(u16 *)((s32)a0 + 0x34) + 1);
+        break;
+    case 2:
+        if (((s32 (*)(s32))func_80178970)((s32)a0) != 0) {
+            ((void (*)(s32))func_80178D18)((s32)a0);
+            *(s16 *)((s32)a0 + 0x2) = 4;
+            *(s16 *)((s32)a0 + 0x34) = 0;
+            func_8012E88C((u8 *)a0);
+            func_8012A828((s32)a0, &D_8019EC70);
+            func_8012E8E0((s32)a0, (s32)&D_80185818);
+        }
+        break;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180774);
 
 #include "common.h"
 
@@ -4235,7 +4660,17 @@ void func_80180830(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8018094C);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801809CC);
+extern void func_8012E88C(u8 *a0);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void (*D_80185BDC[])(void);
+
+void func_801809CC(void *a0) {
+    *(s16 *)((u8 *)a0 + 0x2) = 3;
+    *(s16 *)((u8 *)a0 + 0x34) = 0;
+    func_8012E88C((u8 *)a0);
+    func_80178B18((s32)a0, (s32)&D_80185BDC);
+}
+
 
 #include "common.h"
 
@@ -4340,7 +4775,17 @@ void func_80180D38(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180D74);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180DBC);
+extern void func_8012A828(s32, void *);
+extern s32 D_801A2284;
+extern void *D_801A2280;
+extern u8 D_801859BC;
+extern u8 D_80185ABC;
+
+void func_80180DBC(void) {
+    func_8012A828(D_801A2284, &D_801859BC);
+    func_8012A828((s32)D_801A2280, &D_80185ABC);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180E04);
 
@@ -4359,7 +4804,18 @@ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180EF
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180F08);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180F18);
+extern s32 D_801A2288;
+extern s16 D_80185BD8;
+extern s16 D_80185BDA;
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80180F18(void) {
+    D_801A2288 += 1;
+    if (D_801A2288 % D_80185BD8 == D_80185BDA) {
+        func_8002D4C8(0xB3D, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80180F90);
 
@@ -4367,7 +4823,26 @@ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_8018107
 
 INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_801810EC);
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8017C730", func_80181194);
+extern u8 D_80078EAF;
+extern void func_800D06CC(void);
+
+s32 func_80181194(void) {
+    if ((func_80029178(0x95) & 0xFF) != 0) {
+        return 0x25;
+    }
+    if ((func_800291B4(0xCE) & 0xFF) == 9) {
+        func_800D06CC();
+        return 0x23;
+    }
+    if ((func_80029178(0x90) & 0xFF) != 0) {
+        if (D_80078EAF == 4) {
+            return 0x3C;
+        }
+        return 0xA;
+    }
+    return 0x20;
+}
+
 
 
 
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c b/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
index 0d5367a6d..dd34f223f 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8017DC70.c
@@ -3360,7 +3360,24 @@ void func_8017EF4C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017EF88);
+s32 func_8017EF88(s32 a0) {
+    s32 v = func_80029504();
+    s32 t = *(s32 *)(a0 + 0x28) - 1;
+
+    *(s32 *)(a0 + 0x28) = t;
+    if (t == -1) {
+        if (v < 200 && (u32)(v - 150) < 50) {
+            func_800D0C48(1);
+        }
+        func_8002D4C8(0x1C, 0);
+        func_8001BFD0();
+        func_8002D4C8(0x1D, 0);
+        func_800D1E28();
+        *(u8 *)(a0 + 0x15) += 1;
+    }
+    return 0;
+}
+
 
 
 extern void (*D_8018B5A8[])(void);
@@ -3431,7 +3448,19 @@ void func_8017F168(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F1A4);
+extern u8 D_801C8570[];
+extern u8 D_801C8610[];
+extern s32 func_80171990(u8 *a0);
+
+void func_8017F1A4(u8 *a0) {
+    *(u32 *)(a0 + 0xB0) = (u32)D_801C8570;
+    *(u32 *)(a0 + 0xCC) = (u32)D_801C8610;
+    *(u16 *)(a0 + 0x20C) = 0;
+    *(u16 *)(a0 + 0x20E) = 0;
+    *(u16 *)(a0 + 0x210) = 0;
+    func_80171990(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F1E4);
 
@@ -3509,7 +3538,40 @@ void func_8017F49C(void) {
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F4C4);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F590);
+extern u8 D_80126948[];
+extern void func_8012A018(s32 a, s32 b);
+extern void func_8012A094(s32 a0);
+extern void func_8017F724(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 s16 D_80126940;
+extern s16 D_801274E8;
+
+typedef struct {
+    s16 x0, x1, x2, x3;
+} UnalignedShortBlock;
+
+void func_8017F590(void) {
+    D_80126954 = 0x190;
+    D_8012695C = 0x384;
+    D_80126968 = 0x38E;
+    D_8012696A = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x80;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017F724, 1);
+    func_8012A094((s32)D_80126948);
+    *(UnalignedShortBlock *)&D_801274E8 = *(UnalignedShortBlock *)&D_80126940;
+    func_8017F724((void *)D_80126948);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F658);
 
@@ -3523,17 +3585,56 @@ void func_8017F724(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017F760);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FA2C);
+extern void func_8017FA84(s32 a0, s16 *a1, u32 a2);
+
+void func_8017FA2C(s32 a0)
+{
+    extern s16 D_80126940;
+    extern s16 D_80126944;
+    s16 *p = &D_80126940;
+
+    func_8017FA84(a0, p, ratan2(*p, D_80126944) & 0xFFF);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FA84);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FC50);
+extern void (*D_8018B754[])(void *);
+extern void (*D_8018B768[])(void *);
+
+void func_8017FC50(void *param_1) {
+    extern void func_8017FF7C(void);
+    extern void func_801800D0();
+
+    if (*(u16 *)((s32)param_1 + 0x5C) & 1) {
+        func_8017FF7C();
+    }
+    func_801800D0(param_1);
+    if (*(u16 *)((s32)param_1 + 0x34) == 0) {
+        D_8018B754[*(u16 *)((s32)param_1 + 2)](param_1);
+    } else {
+        D_8018B768[*(u16 *)((s32)param_1 + 0x34)](param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FCE0);
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FD74);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FDB4);
+extern s32 func_8012BCCC(s32 a0);
+extern void func_8013240C(s32 a0);
+extern s32 D_801D9740;
+
+void func_8017FDB4(s32 a0) {
+    s32 v0 = func_8012BCCC(a0);
+    if (v0 <= 0x11000) {
+        *(s16 *)(a0 + 0x2) = 3;
+    } else {
+        func_8013240C((s32)&D_801D9740);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8017FE08);
 
@@ -3557,7 +3658,22 @@ void func_80180234(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180250);
+void func_80180250(void *arg0) {
+    s32 *ptr;
+
+    if ((*(s16 *)((s32)arg0 + 0x70) & 0x8000) == 0) {
+        ptr = *(s32 **)((s32)arg0 + 0x68);
+        if (ptr != NULL) {
+            if ((*(s16 *)((s32)arg0 + 0x72) & 0x8000) != 0) {
+                *(u16 *)((s32)ptr + 0xA) &= 0x7FFF;
+            }
+        }
+    }
+
+    func_8012C218(arg0);
+    func_80029124(0x9D, 1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801802C4);
 
@@ -3569,7 +3685,40 @@ INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8018044
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801804A0);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180904);
+void func_80180904(s32 arg0) {
+    register s32 base __asm__("$2");
+    register s32 cst __asm__("$3");
+    register s32 b2 __asm__("$3");
+    register s32 c2 __asm__("$2");
+    register s32 r6 __asm__("$2");
+    register s32 rA __asm__("$3");
+    register s32 rE __asm__("$6");
+
+    base = *(s32 *)(arg0 + 0x20);
+    cst = 0x1800;
+    *(s16 *)(arg0 + 0xAA) = 0;
+    *(s16 *)(arg0 + 0x5C) = 0;
+    *(s16 *)(base + 0x18) = cst;
+    base = *(s32 *)(arg0 + 0x20);
+    *(s16 *)(base + 0x1C) = cst;
+    b2 = *(s32 *)(arg0 + 0x20);
+    c2 = 0x100;
+    *(s16 *)(b2 + 0x1A) = c2;
+    b2 = *(s32 *)(arg0 + 0x20);
+    *(u16 *)(b2 + 0x2C) |= 0x10;
+    *(s16 *)(arg0 + 0x34) = 0;
+    *(s32 *)(arg0 + 0x1C) = 0x1E;
+    *(s16 *)(arg0 + 0x98) = 0;
+    func_8002D4C8(0x526, 0);
+    r6 = *(u16 *)(arg0 + 0x6);
+    rA = *(u16 *)(arg0 + 0xA);
+    rE = *(u16 *)(arg0 + 0xE);
+    *(s16 *)(arg0 + 0x7C) = r6;
+    *(s16 *)(arg0 + 0x7E) = rA;
+    *(s16 *)(arg0 + 0x80) = rE;
+    func_8016AA50(arg0, 0xA);
+}
+
 
 #include "common.h"
 
@@ -3626,13 +3775,31 @@ void func_801809A4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180B44);
+void func_80180B44(void *a0) {
+    s32 v1 = *(s32 *)((s32)a0 + 0x20);
+
+    *(s32 *)(v1 + 0x4) = *(s32 *)(v1 + 0x4) & 0x7FFFFFFF;
+    *(u16 *)((s32)a0 + 0xFC) = 0;
+    func_800291C8(0xA, 0x3065);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180B84);
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180D3C);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80180E94);
+extern void (*D_8018B8FC[])(void *);
+
+void func_80180E94(void *a0) {
+    s16 count = *(s16 *)((s32)a0 + 0xFC);
+    if (count != 0) {
+        s32 ptr = *(s32 *)((s32)a0 + 0x20);
+        *(s16 *)((s32)a0 + 0xFC) = count - 1;
+        *(s32 *)(ptr + 4) = *(s32 *)(ptr + 4) ^ 0x80000000;
+    }
+    D_8018B8FC[*(u16 *)((s32)a0 + 0x2)](a0);
+}
+
 
 
 extern void (*D_8018B92C[])(void);
@@ -3826,7 +3993,28 @@ void func_8018155C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80181598);
+extern s32 func_8012C1B8(void);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_80181708(void *a0);
+extern s32 func_8012AD50(void *a0);
+
+extern s32 D_801D2038[];
+extern s32 D_8118B93C[];
+
+void func_80181598(void *a0)
+{
+    s32 s0;
+
+    s0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = s0;
+    if (s0 != 0) {
+        func_8001C214(s0, (s32)D_801D2038);
+        *(s32 *)((s32)s0 + 0x20) = (s32)D_8118B93C;
+        func_80181708(a0);
+        func_8012AD50(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80181600);
 
@@ -3843,7 +4031,18 @@ void func_801816C8(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80181708);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801817D8);
+void func_801817D8(u8 *a0, u8 *a1) {
+    u16 sp0[3];
+
+    sp0[0] = *(u16 *)(a0 + 6);
+    sp0[1] = *(u16 *)(a0 + 0xA);
+    sp0[2] = *(u16 *)(a0 + 0xE);
+
+    sp0[0] += *(u16 *)(a1 + 0);
+    sp0[1] += *(u16 *)(a1 + 2);
+    sp0[2] += *(u16 *)(a1 + 4);
+}
+
 
 
 extern void (*D_8018B9B8[])(void);
@@ -3875,7 +4074,21 @@ extern s32 func_800D0CE0(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801818EC);
+extern s32 func_8012E544(s32);
+extern void func_800D0C48(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+
+void func_801818EC(void) {
+    s32 *s0;
+    s0 = (s32 *)func_8012E544(0x116);
+    if (s0 != 0) {
+        func_800D0C48(1);
+        func_8012AD44(s0, 1);
+        func_8012BF4C(s0, 0x30);
+    }
+}
+
 
 
 extern void (*D_8018BB08[])(void);
@@ -4152,7 +4365,27 @@ void func_80182324(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80182360);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern u8 D_8018BC0C[];
+
+void func_80182360(void *a0) {
+    s32 ret;
+
+    ret = func_8012C1B8();
+    *(s32 *)((u8 *)a0 + 0x20) = ret;
+    if (ret == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(ret, 0);
+    *(u16 *)((u8 *)a0 + 0x2) = 1;
+    *(u16 *)((u8 *)a0 + 0x5C) = 0x40;
+    *(s32 *)((u8 *)a0 + 0x58) = (u32)D_8018BC0C;
+}
+
 
 void func_801823C8(void) {
 }
@@ -4195,7 +4428,40 @@ void func_80182544(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80182580);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern s32 func_800291B4(s32 arg);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern void func_8012A828(s32, void*);
+extern u8 D_801C0B48[];
+extern s32 D_8018BCB4[];
+extern u8 D_80187B3C[];
+
+void func_80182580(void *a0) {
+    register void *s0 __asm__("$16");
+    register s32 v0 __asm__("$2");
+    s32 r;
+
+    s0 = a0;
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)s0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(s0);
+        return;
+    }
+
+    func_8001C214(v0, (s32)D_801C0B48);
+
+    r = func_800291B4(D_8018BCB4[*(u16 *)((s32)s0 + 0x70) & 0xF]) & 0xFF;
+    if (r != 3) {
+        func_8012C658(0x15A, *(s16 *)((s32)s0 + 0x70), (s32)s0);
+    }
+
+    *(u16 *)((s32)s0 + 2) = 1;
+    ((void (*)(s32 *, s32))func_8012A828)((s32 *)s0, (s32)D_80187B3C);
+}
+
 
 void func_80182628(void) {
 }
@@ -4305,7 +4571,25 @@ void func_801828C8(void) {
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801828F8);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80182958);
+void func_80182958(void *a0) {
+    extern s32 D_801D5BC8;
+    extern s32 D_8018BD04;
+    extern s32 D_801D3318;
+    s32 v0;
+
+    v0 = func_80029504();
+    if ((u32)(v0 - 0xD2) >= 0x14 ||
+        (v0 = func_8012C1B8(), (*(s32 *)((s32)a0 + 0x20) = v0), v0 == 0)) {
+        func_8012CAE4(a0);
+    } else {
+        func_8001C214(v0, (s32)&D_801D5BC8);
+        *(u16 *)((s32)a0 + 0x2) = 1;
+        func_8012E8E0((s32)a0, (s32)&D_8018BD04);
+        func_8012A828((s32)a0, (s32)&D_801D3318);
+        *(s16 *)(*(s32 *)((s32)a0 + 0x68) + 0xC) = 0x7FFF;
+    }
+}
+
 
 
 
@@ -4531,11 +4815,53 @@ void func_801830B8(s32 s0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183154);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801C7AA4[];
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801831B4);
+void func_80183154(s32 param_1) {
+    *(s16 *)(param_1 + 2) = 4;
+    *(u16 *)(param_1 + 0x5C) = 0xAA10;
+    func_8012A828(param_1, D_801C7AA4);
+    *(s32 *)(param_1 + 0x1C) = 0x20;
+    if (*(s32 *)(param_1 + 0xE0) != 0) {
+        *(s32 *)(param_1 + 0xE0) = 0;
+        *(s16 *)(param_1 + 0xA) = *(s16 *)(param_1 + 0xA) + 0x30;
+    }
+}
+
+
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_801844B0(s32 a0);
+
+void func_801831B4(s32 a0) {
+    u8 *p = *(u8 **)(a0 + 0x20);
+    *(u16 *)(p + 0x12) = *(u16 *)(p + 0x12) + 0x40;
+    if (func_801844B0(a0) == 1) {
+        return;
+    }
+    if (func_8012BEE8(a0) != 0) {
+        *(s16 *)(a0 + 2) = 5;
+    }
+}
+
+
+#include "common.h"
+
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012B23C(s32 a0);
+extern u8 D_801C7AA4[];
+
+void func_80183214(void *a0) {
+    s32 s0 = (s32)a0;
+    *(u16 *)((s32)a0 + 2) = 6;
+    func_8012B23C(s0);
+    func_8012B178(s0, 0xFFFE8000);
+    func_8012A828(s0, (void *)&D_801C7AA4);
+    *(s32 *)((s32)a0 + 0x1C) = 0x96;
+    *(u16 *)((s32)a0 + 0xE6) = 0;
+}
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183214);
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183270);
 
@@ -4654,7 +4980,20 @@ void func_801833EC(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183600);
+extern s32 D_801C7C74;
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+
+void func_80183600(void *a0) {
+    s32 s0 = (s32)a0;
+    *(u16 *)((s32)a0 + 2) = 0xC;
+    func_8012B23C(s0);
+    func_8012A828(s0, (void *)&D_801C7C74);
+    *(s32 *)((s32)a0 + 0x1C) = 0x1A;
+    *(u16 *)((s32)a0 + 0xE6) = 0;
+    func_8012B23C(s0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183654);
 
@@ -4721,13 +5060,57 @@ void func_80183818(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183878);
+#include "common.h"
+
+extern u8 D_800D3918[];
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern s32 D_801C7B9C;
+extern s32 func_801841F8(s32 a0, s32 a1);
+
+void func_80183878(void *a0) {
+    if (*(s16 *)((s32)a0 + 0xAA) <= 0) {
+        *(s16 *)((s32)a0 + 2) = 3;
+    } else {
+        if (func_8012BEE8((s32)a0) != 0) {
+            func_8012A828((s32)a0, (void *)&D_801C7B9C);
+            *(s32 *)((s32)a0 + 0x1C) = 0x1A;
+        }
+        func_801841F8((s32)a0, (s32)D_800D3918);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801838EC);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183928);
+void func_80183928(s32 a0) {
+    s32 s0 = a0;
+    *(s16 *)(s0 + 0x2) = 0xF;
+    *(s16 *)(*(s32 *)(s0 + 0x20) + 0x12) = (func_8012B864(s0) + 0x800) & 0xFFF;
+}
+
+
+extern void func_80131B14();
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801C81BC[];
+
+void func_80183968(void *a0) {
+    s32 s0;
+    s32 v1;
+    __asm__ __volatile__("" : "=r"(s0) : "0"(a0));
+
+    if (*(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) & 0x10) {
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) &= ~0x10;
+        v1 = *(s32 *)(s0 + 0x20);
+        *(u16 *)(v1 + 0x1C) = 0x1000;
+        *(u16 *)(v1 + 0x1A) = 0x1000;
+        *(u16 *)(v1 + 0x18) = 0x1000;
+    }
+
+    func_80131B14(s0);
+    func_8012A828(s0, D_801C81BC);
+}
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80183968);
 
 extern u8 D_801C4934[];
 extern u8 D_801C4940[];
@@ -5190,7 +5573,20 @@ LD44:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801844B0);
+extern s32 func_8012BCCC(s32 a0);
+extern s32 func_8012BDBC(s32 a0, s32 a1);
+
+s32 func_801844B0(s32 obj) {
+    s32 dist;
+
+    dist = func_8012BCCC(obj);
+    if (dist < 0x2001 || (dist <= 0x24000 && func_8012BDBC(obj, 0x400))) {
+        *(s16 *)(obj + 0x2) = 7;
+        return 1;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80184520);
 
@@ -5370,7 +5766,20 @@ void func_80184AE4(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80184B18);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80184B70(s32 a0, u8 *a1);
+
+void func_80184B18(void *a0) {
+    s32 s0 = (s32)a0;
+
+    if (func_8012BEE8(s0) != 0) {
+        func_80184B70(0, (u8 *)(s0 + 0xFD));
+        func_80184B70(1, (u8 *)(s0 + 0xFE));
+        func_80184B70(2, (u8 *)(s0 + 0xFF));
+        *(s32 *)(s0 + 0x1C) = 2;
+    }
+}
+
 
 extern u32 D_801C4770[];
 extern u32 D_801C499C[];
@@ -5450,7 +5859,30 @@ void func_80184C48(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80184D34);
+extern s32 rand(void);
+extern s32 func_8012BEE8(s32 a0);
+
+extern s32 D_801C49DC[];
+
+void func_80184D34(s32 a0) {
+    s32 *p;
+    s32 s0;
+    s32 r;
+    u16 h;
+
+    if (func_8012BEE8(a0) == 0) {
+        return;
+    }
+    s0 = a0;
+    *(u16 *)(s0 + 0x2) += 1;
+    r = rand();
+    h = *(u16 *)(s0 + 0x70);
+    p = D_801C49DC;
+    *(s32 *)(s0 + 0x48) = p[h & 0xF] + r % 1024;
+    *(s32 *)(s0 + 0x1C) = 0x100;
+    *(s32 *)(s0 + 0xE0) = rand();
+}
+
 
 #include "common.h"
 
@@ -5691,7 +6123,32 @@ void func_8018533C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185378);
+#include "common.h"
+
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32 a0, s32 a1);
+extern void func_8012B2CC(s32 a0);
+
+void func_80185378(void *a0)
+{
+    s32 ret;
+
+    ret = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = ret;
+    if (ret == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C214(ret, 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_801C89CC[])(void);
@@ -6130,7 +6587,23 @@ INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185BD
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185C4C);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185D08);
+#include "common.h"
+
+extern s32 rand(void);
+extern void func_80132288(s32 *param_1, s32 *param_2, s32 param_3);
+extern void func_80186ECC(s32 a0, s32 a1);
+
+extern s32 D_801D98C8;
+extern s32 D_801C9124[];
+extern s32 D_801CA0A0;
+
+void func_80185D08(s32 a0) {
+    *(s16 *)(a0 + 2) = 2;
+    func_80132288(&D_801D98C8, D_801C9124, D_801CA0A0);
+    *(s32 *)(a0 + 0x1C) = (rand() % 31) + 30;
+    func_80186ECC(a0, 1);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185D9C);
 
@@ -6171,7 +6644,38 @@ void func_80185DFC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185F38);
+extern s32 D_801D98C8;
+
+extern void func_8012B178(s32 a0, s32 a1);
+extern s32  func_8012BCCC(s32 a0);
+extern s32  func_8012BEE8(s32 a0);
+extern void func_8013240C(s32 a0);
+extern s32  func_80186DD4(s32 a0);
+
+void func_80185F38(s32 arg0) {
+    s32 v0;
+    s32 v1;
+
+    v0 = *(s16 *)(arg0 + 0xE0);
+    v1 = *(s32 *)(arg0 + 0x20);
+    *(u16 *)(v1 + 0x12) += v0 * 34;
+
+    if (*(s16 *)(arg0 + 0xEA) == 0) {
+        func_8012B178(arg0, 0xFFFE0000);
+        if (func_80186DD4(arg0) == -1) {
+            return;
+        }
+    }
+    if (func_8012BCCC(arg0) < 0x4001) {
+        *(s16 *)(arg0 + 2) = 7;
+        return;
+    }
+    if (func_8012BEE8(arg0) != 0) {
+        *(s16 *)(arg0 + 2) = 5;
+    }
+    func_8013240C((s32)&D_801D98C8);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80185FE8);
 
@@ -6611,7 +7115,17 @@ merge2:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80186CE4);
+extern void func_80132288(s32 *param_1, s32 *param_2, s32 param_3);
+extern void func_80186ECC(s32 a0, s32 a1);
+extern s32 D_801D98C8;
+extern s32 D_801C920C[];
+extern s32 D_801CA0A0;
+
+void func_80186CE4(s32 a0) {
+    func_80132288(&D_801D98C8, &D_801C920C, D_801CA0A0);
+    func_80186ECC(a0, 1);
+}
+
 
 extern void func_8013240C(s32 a0);
 extern s32 D_801D98C8;
@@ -6653,7 +7167,14 @@ void func_80186D5C(void)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80186D90);
+void func_80186D90(s32 a0) {
+    extern u8 D_80187B3C[];
+    *(s16 *)(a0 + 0x2) = 1;
+    func_8012A828(a0, D_80187B3C);
+    *(u16 *)(a0 + 0x5C) = 0xAA10;
+    *(s16 *)(a0 + 0xEA) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80186DD4);
 
@@ -6670,15 +7191,74 @@ extern s32 rand(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80186F9C);
+#include "common.h"
+
+extern void func_8012B23C(s32 a0);
+extern void func_80132288(s32 *param_1, s32 *param_2, s32 param_3);
+extern void func_800183E0(s32 a0);
+
+extern s32 D_801D98C8;
+extern s32 D_801CA0A0;
+extern s32 D_801CA248;
+
+void func_80186F9C(s32 a0, s32 a1, s32 a2) {
+    register s32 s1 __asm__("$17") = a0;
+    register s32 s0 __asm__("$16");
+    register s32 s2 __asm__("$18") = a2;
+    s32 p;
+
+    __asm__("" :: "r"(s1));
+    s0 = a1;
+
+    func_8012B23C(s1);
+    func_80132288(&D_801D98C8, (s32 *)s0, D_801CA0A0);
+    s0 = 1;
+    if (*(u16 *)(s1 + 0xDC) & 2) {
+        func_800183E0((s32)&D_801CA248);
+        *(u16 *)(s1 + 0xDC) = s0;
+    }
+    *(u16 *)(s1 + 0x5C) &= 0xFFFE;
+    *(s32 *)(s1 + 0x1C) = s2;
+    *(u16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(s1 + 0x62) + 0x800) & 0xFFF;
+    p = *(s32 *)(s1 + 0x20);
+    *(s16 *)(p + 0x14) = 0;
+    *(s16 *)(p + 0x10) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80187050);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_801870B8);
+extern void Square0(s32 *a0, s32 *a1);
+
+s32 func_801870B8(s32 a0) {
+    s32 sp10[4];
+
+    sp10[0] = *(s16 *)((s32)a0 + 6) - *(s16 *)((s32)a0 + 0x88);
+    sp10[1] = 0;
+    sp10[2] = *(s16 *)((s32)a0 + 0xE) - *(s16 *)((s32)a0 + 0x8C);
+    Square0(&sp10[0], &sp10[0]);
+    return 0x18FFFF >= (sp10[0] + sp10[2]);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_80187118);
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017DC70", func_8018723C);
+s32 func_8018723C(void *a0) {
+    short a[4];
+    short b[4];
+    s32 pa, pb;
+    s32 r;
+    a[0] = *(u16 *)((s32)a0 + 0x6);
+    a[1] = *(u16 *)((s32)a0 + 0xA);
+    a[2] = *(u16 *)((s32)a0 + 0xE);
+    pa = (s32)a;
+    pb = (s32)b;
+    __builtin_memcpy((void *)pb, (void *)pa, 8);
+    b[1] += 8;
+    r = func_80133784(1, pa, pb) & 0x2000;
+    return r != 0;
+}
+
 
 
 /* func_801872B4 — tiny matrix wrapper.
diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
index e850648bf..916428a08 100644
--- a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
+++ b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
@@ -5400,7 +5400,23 @@ void func_8017EFF4(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017F07C);
+void func_8017F07C(s32 a0)
+{
+    register s32 s0 asm("$16") = a0;
+    u8 v1;
+
+    func_80149020((s32 *)s0);
+    v1 = *(u8 *)(s0 + 0xDE);
+    *(u8 *)(s0 + 0xDE) = v1 + 0xFF;
+    if (v1 == 0) {
+        func_8017F0E0(s0);
+        func_80159B3C((void *)s0);
+        func_80165718(s0);
+    } else {
+        func_80172630((u8 *)s0);
+    }
+}
+
 
 extern u8 D_80062C04[];
 extern void func_80019064(void *a0);
@@ -5503,7 +5519,23 @@ void func_8017F5C4(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017F5E0);
+void func_8017F5E0(s32 *a0)
+{
+    register s32 t1 asm("$6");
+    register s32 t2 asm("$2");
+    register s32 t3 asm("$3");
+    s32 x;
+
+    t1 = a0[4];
+    x = a0[13];
+    t2 = a0[5];
+    t3 = a0[6];
+    a0[1] = t1;
+    a0[2] = t2;
+    a0[3] = t3;
+    func_80149374(x, (s32)(a0 + 1));
+}
+
 
 
 extern void (*D_801883E8[])(void);
@@ -5627,7 +5659,23 @@ void func_8017F65C(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017F930);
+extern void func_8017F9F4(void);
+extern void func_8017FB78(s32*);
+extern s32 func_80146E98(s32 a0);
+extern void func_80146E90(s32 *a0, s32 a1);
+
+void func_8017F930(s32 *a0) {
+    func_8017F9F4();
+    ((void (*)(void *))func_8017FB78)(a0);
+    if (func_80146E98((s32)a0) != 0) {
+        *(s32 *)(a0 + 4) >>= 2;
+        *(s32 *)(a0 + 5) >>= 2;
+        *(s32 *)(a0 + 6) >>= 2;
+        func_80146E90(a0, 0x40);
+        *(u16 *)((s32)a0 + 2) = *(u16 *)((s32)a0 + 2) + 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017F9AC);
 
@@ -5635,7 +5683,18 @@ INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017F9F
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017FA1C);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8017FB78);
+void func_8017FB78(s32 *a0) {
+    s16 *p;
+
+    a0[1] += a0[4];
+    a0[2] += a0[5];
+    a0[3] += a0[6];
+    p = (s16 *)a0[8];
+    p[8] += a0[19];
+    p[9] += a0[20];
+    p[10] += a0[21];
+}
+
 
 void func_8017FBEC(s32 *a0) {
         *(s32 *)((s32)a0 + 0x0) = 0x80404080;
@@ -5962,15 +6021,51 @@ void func_801800C0(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801801AC);
+void func_801801AC(s32 a0) {
+    extern M2C_UNK D_8019972C;
+    extern s32 D_801997A4;
+    s32 *v1;
+
+    func_8012A8B0((u8 *)a0, (s32)&D_8019972C);
+    v1 = *(s32 **)(a0 + 0x20);
+    *(s32 *)(a0 + 0x94) = 0xF;
+    *(s32 *)((s32)v1 + 0x20) = D_801997A4;
+    func_8012B23C(a0);
+    func_8012AD44((s32 *)a0, 2);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180208);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180274);
+extern s32 D_8019979C;
+extern void func_8012B23C(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_80180274(s32 param_1, u16 param_2)
+{
+    *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = D_8019979C;
+    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = param_2;
+    func_8012B23C(param_1);
+    *(s32 *)(param_1 + 0x1C) = 8;
+    *(s16 *)(param_1 + 0x98) = 0;
+    func_8012AD44((s32 *)param_1, 4);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801802D0);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801804CC);
+void func_801804CC(void *arg0) {
+    s32 *s0 = (s32 *)arg0;
+
+    extern M2C_UNK D_80199904;
+    func_8012A8B0((u8 *)arg0, (s32)&D_80199904);
+    *(u16 *)((u8 *)s0 + 0x102) = 8;
+    *(u16 *)((u8 *)s0 + 0x104) = 3;
+    *(u16 *)((u8 *)s0 + 0x106) = (rand() & 0x20) - 0x10;
+    s0[7] = 0x60;
+    func_8012AD44(s0, 5);
+}
+
 
 
 
@@ -5985,7 +6080,29 @@ void func_80180530(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8018056C);
+typedef struct {
+    u8  pad0[0x2];
+    u16 unk2;
+    u8  pad2[0x1C];
+    s32 *unk20;
+    u8  pad3[0xDA];
+    u16 unkFE;
+    u16 unk100;
+} S_8018056C;
+
+extern void func_8012A8B0(u8 *a0, s32 a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_80199644;
+
+void func_8018056C(S_8018056C *s0) {
+    s0->unk100 = 0;
+    s0->unkFE = ((u16 *)s0->unk20)[9] + 0x200;
+    if (s0->unk2 != 1) {
+        func_8012A8B0((u8 *)s0, (s32)&D_80199644);
+    }
+    func_8012AD44((s32 *)s0, 0x8);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801805D0);
 
@@ -6014,15 +6131,74 @@ void func_80180878(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801808B4);
+extern void (*D_80192E38[])(void);
+
+void func_801808B4(s32 arg0) {
+    s32 *s0 = (s32 *)arg0;
+    s32 v1;
+
+    D_80192E38[*(u16 *)((u8 *)s0 + 2)]();
+
+    if ((*(u16 *)s0 == 0x1FC) && (*(s16 *)((u8 *)s0 + 0xAA) == 0)) {
+        v1 = *(s32 *)((u8 *)s0 + 0x20);
+        *(u16 *)(v1 + 0x2C) |= 0x10;
+        v1 = *(s32 *)((u8 *)s0 + 0x20);
+        *(u16 *)(v1 + 0x18) = *(u16 *)(v1 + 0x1A) = *(u16 *)(v1 + 0x1C) = 0x1800;
+    }
+}
+
+
+void func_80180948(s32 arg0) {
+    extern void func_80181248(s32 a0, s32 a1);
+    s32 pe;
+
+    if (*(u8 *)(arg0 + 0xC2) == 0x2) {
+        *(s16 *)(arg0 + 0x52) = -0x18;
+    }
+    pe = func_80180C74(arg0);
+    if (pe != 0) {
+        *(s32 *)(arg0 + 0x10) = 0;
+        *(s32 *)(arg0 + 0x18) = 0;
+        *(s32 *)(arg0 + 0x04) = *(s32 *)(arg0 + 0x38);
+        *(s32 *)(arg0 + 0x0C) = *(s32 *)(arg0 + 0x40);
+        func_80181248(arg0, pe);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180948);
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801809B0);
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180A30);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180AF0);
+extern void func_8012B2CC(s32 a0);
+extern void func_8012B178(s32 a0, s32 a1);
+extern void func_8012CBA4(s32);
+extern s32 func_80180C74(s32 arg0);
+extern void func_8012ADE4(u8 *a0);
+extern void func_8012A8B0(u8 *a0, s32 a1);
+extern void func_8012B23C(s32 a0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_80199644;
+
+s32 func_80180AF0(s32 a0, s32 a1, s32 *a2) {
+    s32 cba4;
+
+    func_8012B2CC(a0);
+    func_8012B178(a0, a1);
+    cba4 = ((s32 (*)(s32))func_8012CBA4)(a0);
+    if ((*a2 = func_80180C74(a0)) != 0) goto fail;
+    if (cba4 == 0x2000) goto zeroret;
+fail:
+    func_8012ADE4((u8 *)a0);
+    *(s32 *)(a0 + 0x1C) = 8;
+    func_8012A8B0((u8 *)a0, (s32)&D_80199644);
+    func_8012B23C(a0);
+    func_8012AD44((s32 *)a0, 1);
+    return 1;
+zeroret:
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180BA4);
 
@@ -6095,7 +6271,31 @@ s32 func_80180C74(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180D94);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180E30);
+extern u8 D_80195254[0x20];
+extern s32 D_801B3A80[8];
+extern s32 D_801B3A90;
+extern void func_8002D4C8(s32 arg0, s32 arg1);
+extern s32 func_8012C588(s32 a0, s32 a1);
+
+void func_80180E30(s32 param_1) {
+    s32 i;
+
+    if ((*(u16 *)(param_1 + 0x86) & 1) == 0) {
+        if (*(s16 *)(param_1 + 0x76) < 0xB5) {
+            if (((s32 (*)(s32, s32))func_8012C588)(0x22D, param_1) != 0) {
+                *(u16 *)(param_1 + 0x86) |= 1;
+                for (i = 0; i < 0x20; i += 4) {
+                    *(s32 *)((s32)D_801B3A80 + i) = *(s32 *)((s32)D_80195254 + i);
+                }
+                *(s32 *)D_801B3A80 = 0x1000000;
+                D_801B3A90 = 0x1000000;
+                *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x24) = (s32)D_801B3A80;
+                ((void (*)(s32, s32))func_8002D4C8)(0x83B, 0);
+            }
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180EEC);
 
@@ -6131,7 +6331,26 @@ void func_80180F74(s32 target, u16 *cur, s32 step)
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180FF8);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181130);
+extern u8 D_80192E6C[];
+extern u8 D_80192E6E[];
+extern u8 D_80192E70[];
+extern s16 D_80126B98;
+s32 func_8012DEB8(s32 a0, s32 a1, s32 a2);
+
+void func_80181130(s32 a0, s32 a1) {
+    u16 buf[4];
+
+    if ((*(u16 *)(a0 + 0x86) & 1) == 0) {
+        s32 off = a1 << 3;
+        buf[0] = *(u16 *)(D_80192E6C + off);
+        buf[1] = *(u16 *)(D_80192E6E + off);
+        buf[2] = *(u16 *)(D_80192E70 + off) - 0x14;
+        if (func_8012DEB8(a0, (s32)(D_80192E6C + off), (s32)buf) != 0) {
+            D_80126B98 = 0x14;
+        }
+    }
+}
+
 
 extern void func_8002D4C8(s32 arg0, s32 arg1);
 extern void func_8002AC00(int arg0);
@@ -6142,7 +6361,23 @@ void func_801811BC(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801811E8);
+extern void func_801437D8(s32 a0, s32 a1, s32 a2, s32 a3);
+extern u8 D_80192E84;
+
+void func_801811E8(u8 *a0)
+{
+    u16 buf[4];
+
+    if (*(u16 *)a0 != 0x1FC) {
+        return;
+    }
+    buf[0] = *(u16 *)(a0 + 6);
+    buf[1] = *(u16 *)(a0 + 0xA) - 0x20;
+    buf[2] = *(u16 *)(a0 + 0xE);
+    buf[3] = 0x1800;
+    func_801437D8((s32)(a0 + 0x102), (s32)buf, (s32)&D_80192E84, 0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181248);
 
@@ -6224,7 +6459,7 @@ INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8018167
 
 extern M2C_UNK D_80199644;
 extern s32 func_8012BEE8(s32 arg);
-extern s32 func_80180AF0(s32 a0, s32 a1, s32 *a2);
+extern s32 func_80180AF0();
 extern void func_8012A8B0(u8 *a0, s32 a1);
 extern void func_8012AD44(s32 *a0, s16 a1);
 extern void func_8012ADE4(u8 *a0);
@@ -6280,11 +6515,55 @@ void func_80181744(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181850);
+extern M2C_UNK D_80199644;
+extern void func_8012A8B0(u8 *a0, s32 a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8012B23C(s32 a0);
+
+void func_80181850(s32 arg0) {
+    if (*(s16 *)(arg0 + 0x98) == 0) {
+        *(s32 *)(arg0 + 0x1C) = 8;
+        func_8012A8B0((u8 *)arg0, (s32)&D_80199644);
+        func_8012B23C(arg0);
+        func_8012AD44((s32 *)arg0, 1);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801818A8);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181968);
+#include "common.h"
+
+extern s32 func_8012BEE8(s32 a0);
+extern s32 func_80180750(s32 a0);
+extern void func_80180878(s32 a0);
+extern void func_80181130(s32, s32);
+
+void func_80181968(s32 arg0) {
+    s32 state;
+
+    if (*(s16 *)(arg0 + 0xAA) == 0) {
+        switch (*(u16 *)(arg0 + 0x34)) {
+        case 0:
+            if (func_8012BEE8(arg0) != 0) {
+                if (func_80180750(arg0) != 0) {
+                    *(s32 *)(arg0 + 0x1C) = 0x30;
+                    *(u16 *)(arg0 + 0x34) = *(u16 *)(arg0 + 0x34) + 1;
+                } else {
+                    *(s32 *)(arg0 + 0x1C) = 0x10;
+                }
+            }
+            break;
+        case 1:
+            if (func_8012BEE8(arg0) != 0) {
+                func_80180878(arg0);
+            }
+            break;
+        }
+        ((s32 (*)(s32, s32))func_80181130)(arg0, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181A20);
 
@@ -6334,7 +6613,20 @@ INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80181EE
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182014);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182170);
+void func_80182170(s32 a0, s32 a1)
+{
+    s16 *s0 = (s16 *)a1;
+    u16 flags;
+
+    flags = *(u16 *)(s0 + 0x2E);
+    if ((flags & 0x8000) != 0 && *(u16 *)(s0 + 0x2F) != 0x1D) {
+        *(u16 *)(s0 + 0x2E) = flags | 1;
+        *(u16 *)(s0 + 0x30) = 0x14;
+        *(u16 *)(s0 + 0x31) = func_8012B6D4(s0 + 2, (s16 *)a0 + 2);
+        *(u16 *)(s0 + 0x2F) = 0x1D;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801821E0);
 
@@ -6345,7 +6637,46 @@ INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801823F
 void func_801824A8(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801824B0);
+extern void func_8012CBF4(s32);
+extern s32 func_80181D1C(s32);
+extern s32 func_80181DAC(s32);
+extern void func_80181EE8(void *);
+extern void func_80182170(s32, s32);
+extern void func_801439C0(void *);
+extern void func_8012C218(void *);
+
+void func_801824B0(s32 a0) {
+    s32 result;
+    s16 field_a;
+    void *d0;
+    void *t;
+
+    result = ((s32 (*)(s32))func_8012CBF4)(a0);
+    field_a = *(s16 *)(a0 + 0xA);
+    if (field_a >= 0x81) {
+        d0 = *(void **)(a0 + 0xD0);
+        if (d0 != NULL) {
+            ((void (*)(void *))func_801439C0)(d0);
+        }
+        ((void (*)(void *))func_8012C218)((void *)a0);
+        return;
+    }
+    if ((result & 0x2000) != 0) {
+        if ((result & 0xC000) == 0) {
+            if (((s32 (*)(s32))func_80181D1C)(a0) != 0) {
+                ((void (*)(void *))func_80181EE8)(a0);
+            } else {
+                t = (void *)((s32 (*)(s32))func_80181DAC)(a0);
+                if (t != NULL) {
+                    if (*(u16 *)t == 0x1FC) {
+                        ((void (*)(void *, void *))func_80182170)((void *)a0, t);
+                    }
+                }
+            }
+        }
+    }
+}
+
 
 
 // @class: struct
@@ -6669,9 +7000,34 @@ void func_80182CAC(s32 a0) {
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182DC4);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182E34);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80182E34(void *a0) {
+    extern u8 D_801A8898;
+    extern u8 D_801A8A58;
+
+    if (*(s32 *)((char *)a0 + 0x90) == (s32)&D_801A8898) {
+        func_8012A828((s32)a0, &D_801A8A58);
+        *(u16 *)((char *)a0 + 0x5C) = 0xAA10;
+    } else {
+        *(u16 *)((char *)a0 + 0x98) = 0;
+        *(u16 *)((char *)a0 + 0x5C) = 0xAA10;
+    }
+    *(u16 *)((char *)a0 + 0x2) = 1;
+    *(u16 *)((char *)a0 + 0xFC) = 0xF;
+}
+
+
+void func_80182E9C(s32 a0) {
+    *(s16 *)(a0 + 0x52) = 0;
+    if (*(u8 *)(a0 + 0x5E) == 0x1D) {
+        if (*(s16 *)(a0 + 0x10A) == 0) {
+            *(s32 *)(a0 + 0xC4) |= 1;
+            *(s16 *)(a0 + 0x10A) = 0x3C;
+        }
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182E9C);
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182ED4);
 
@@ -6699,15 +7055,101 @@ void func_80182FA8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80182FF0);
+void func_80182FF0(s32 a0) {
+    extern u8 D_8019DB0C[];
+    extern s32 D_8019DBA8;
+    extern s32 D_8019DB40;
+    extern u8 D_801A82F8[];
+    extern s32 func_80143970(s32 a0);
+    extern s32 func_8012C354(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern void func_8012B23C(s32 a0);
+
+    if (func_8012C354(a0, (s32)D_8019DB0C) == 0) {
+        return;
+    }
+
+    *(u8 *)(a0 + 0xC0) = 1;
+    *(s32 *)(a0 + 0xB4) = -1;
+    func_80143970(a0);
+    func_8012A828(a0, (void *)&D_801A82F8);
+    *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1;
+    func_8012B23C(a0);
+
+    if (*(s16 *)(a0 + 0x70) == 3) {
+        *(s32 *)(a0 + 0xBC) = (s32)&D_8019DBA8;
+    } else {
+        *(s32 *)(a0 + 0xBC) = (s32)&D_8019DB40;
+    }
+}
+
+
+extern s32 func_8012BCCC(s32 a0);
+extern void func_8012A828(s32, void*);
+extern u8 D_801A82F8[];
+extern u8 D_801A8380[];
+
+void func_8018308C(s32 a0) {
+    if (*(s16 *)(a0 + 0x98) == 0) {
+        func_8012A828(a0, D_801A82F8);
+    }
+    if (*(s16 *)(a0 + 0xFE) != 0) {
+        *(s16 *)(a0 + 0xFE) = 0;
+    } else if (*(s16 *)(a0 + 0xFC) != 0) {
+        *(s16 *)(a0 + 0xFC) -= 1;
+    } else if (func_8012BCCC(a0) <= 0x40000) {
+        *(s16 *)(a0 + 0x2) = 2;
+        func_8012A828(a0, D_801A8380);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_8018308C);
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183130);
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801831FC);
+void func_801831FC(s32 a0) {
+    extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern s32 func_8012CBCC(s32 a0);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u16 D_80126B96;
+    extern u8 D_8019DC24[];
+    extern u8 D_8019DC2C[];
+    extern u8 D_801A8428[];
+    extern u8 D_8019DAEC[];
+
+    if (*(s32 *)(a0 + 0x94) < 0x3D) {
+        if (func_8012D5E4(a0, (s32)D_8019DC24, (s32)D_8019DC2C, 0x20) == 1) {
+            D_80126B96 = 4;
+        }
+    }
+    if (func_8012CBCC(a0) & 0x6000) {
+        *(s16 *)(a0 + 0x2) = 5;
+        func_8012A828(a0, D_801A8428);
+        *(s16 *)(a0 + 0xFC) = 0;
+        *(s32 *)(a0 + 0x58) = ((s32)D_8019DAEC | 0x40000000) | 0x20000000;
+    }
+}
+
+
+extern void func_8002A04C(s32 a0);
+extern void func_8012C098(void);
+extern void func_8012E8A8(u8 *a0);
+
+void func_801832A8(s32 arg0) {
+    register s32 s0 __asm__("$16") = arg0;
+    *(s16 *)(s0 + 0x76) = 0;
+    if (*(s16 *)(s0 + 0x100) == 0) {
+        func_8002A04C(s0);
+    }
+    if (*(s16 *)(s0 + 0xFE) == 0) {
+        ((void (*)(void *))func_8012C098)(s0);
+    } else {
+        *(s16 *)(s0 + 0x2) = 6;
+        func_8012E8A8((u8 *)s0);
+        *(s16 *)(s0 + 0x5C) = 0;
+        *(u8 *)(s0 + 0xC1) = 0;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801832A8);
 
 
 // @class: plumbing
@@ -6726,7 +7168,36 @@ void func_80183318(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183360);
+extern void func_8012EFB8(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80183360(void *a0) {
+    u16 in[3];
+    s16 out[2];
+
+    in[0] = *(u16 *)((char *)a0 + 0x6);
+    in[1] = *(u16 *)((char *)a0 + 0xA);
+    in[2] = *(u16 *)((char *)a0 + 0xE);
+
+    ((void (*)(u16 *, s16 *))func_8012EFB8)(in, out);
+
+    {
+        s32 v = out[0];
+        if (v < 0) {
+            v = -v;
+        }
+        if (v < 0xB5) {
+            v = out[1];
+            if (v < 0) {
+                v = -v;
+            }
+            if (v < 0xA1) {
+                func_8002D4C8(0x98A, 0);
+            }
+        }
+    }
+}
+
 
 
 extern void func_8012A828(s32 a0, void *a1);
@@ -6901,7 +7372,19 @@ void func_8018359C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183750);
+extern void func_80184614(s32 a0, u16 *a1, s16 a2);
+
+void func_80183750(u8 *a0) {
+    s16 sp10[3];
+
+    if (*(u16 *)(a0 + 0x5E) == 0x24) {
+        sp10[0] = 2;
+        sp10[1] = 0xF;
+        sp10[2] = -2;
+        func_80184614((s32)a0, (u16 *)sp10, 0xD);
+    }
+}
+
 
 
 /* Fresh mass-lane crack (Phase-31 wave T). No banked twin was found for this
@@ -6972,7 +7455,20 @@ void func_801838E4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183920);
+extern void (*D_801A8CA4[])(void);
+
+void func_80183920(void *a0) {
+    D_801A8CA4[*(u16 *)((s32)a0 + 0x2)]();
+    if (*(u16 *)((s32)a0 + 0x0) != 0) {
+        void *ptr = *(void **)((s32)a0 + 0xCC);
+        *(u16 *)((s32)ptr + 0x8) = *(u16 *)((s32)a0 + 0x6);
+        ptr = *(void **)((s32)a0 + 0xCC);
+        *(u16 *)((s32)ptr + 0xA) = *(u16 *)((s32)a0 + 0xA);
+        ptr = *(void **)((s32)a0 + 0xCC);
+        *(u16 *)((s32)ptr + 0xC) = *(u16 *)((s32)a0 + 0xE);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801839A8);
 
@@ -6993,7 +7489,29 @@ void func_80183A80(u8 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183AD8);
+extern void func_8012CBF4(s32 a0);
+extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_80183B64(s32 param_1);
+
+extern u16 D_80126B96;
+extern s32 D_801A8CB0;
+
+void func_80183AD8(s32 param_1)
+{
+    s32 p;
+
+    p = *(s32 *)(param_1 + 0xCC);
+    *(u16 *)(p + 0x14) = *(u16 *)(p + 0x14) + 0x80;
+    if (((s32 (*)(s32))func_8012CBF4)(param_1) == 0) {
+        if (func_8012D5E4(param_1, (s32)&D_801A8CB0, (s32)((u8 *)&D_801A8CB0 + 8), 0x10) == 0 &&
+            --*(s32 *)(param_1 + 0x1C) != 0) {
+            return;
+        }
+        D_80126B96 = 0x13;
+    }
+    func_80183B64(param_1);
+}
+
 
 
 extern void func_80016714(void *a0, s32 a1);
@@ -7044,7 +7562,47 @@ void func_80183CA4(int param_1)
 void func_80183CFC(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183D04);
+extern void func_8012CAE4(void *a0);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012E504(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80183D04(s32 s0) {
+    s32 v0;
+    s32 a1v;
+
+    extern s32 D_801A8B80;
+    extern s32 D_801A8BB4;
+    extern u8 D_801B0B30;
+
+    v0 = func_8012C354(s0, (s32)&D_801A8B80);
+    if (v0 == 0) {
+        return;
+    }
+
+    *(u8 *)(s0 + 0xC0) = 1;
+    *(s32 *)(s0 + 0xB4) = -1;
+    *(s32 *)(s0 + 0xBC) = (s32)&D_801A8BB4;
+    *(s32 *)(s0 + 0xC4) = 1;
+
+    a1v = *(s16 *)(s0 + 0x70);
+    *(u16 *)(s0 + 0xAE) = 8;
+
+    v0 = func_8012C658(0x23F, a1v, s0);
+    *(s32 *)(s0 + 0x6C) = v0;
+
+    if (v0 == 0) {
+        func_8012CAE4((void *)s0);
+    } else {
+        if (func_8012E504(s0, 0x23D) == 0) {
+            *(u16 *)(s0 + 0xFE) = 1;
+        }
+        *(u16 *)(s0 + 0x2) = 1;
+        func_8012A828(s0, (void *)&D_801B0B30);
+    }
+}
+
 
 extern s32 D_801AA6D0;
 extern void func_8001C214(s32 a0, s32 a1);