diff --git a/config/overlays.mk b/config/overlays.mk
index 5ec49dc29..0fdd40b37 100644
--- a/config/overlays.mk
+++ b/config/overlays.mk
@@ -2450,7 +2450,7 @@ build/src/ov_SC03_108/ov_SC03_108_jr_80154C24.o: JTBL_PADS := 0,0  # §8e pads (
 build/src/ov_SC03_108/ov_SC03_108_jr_801588CC.o: JTBL_PADS := 0,4,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x28,+0x48
 build/src/ov_SC03_108/ov_SC03_108_jr_80159C84.o: JTBL_PADS := 0,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC03_108/ov_SC03_108_jr_8015AE2C.o: JTBL_PADS := 0,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
-build/src/ov_SC03_108/ov_SC03_108_jr_8016AB6C.o: JTBL_PADS := 0  # §8e pads — 1 table(s), byte-proven by jtbl_pads_fix
+build/src/ov_SC03_108/ov_SC03_108_jr_8016AB6C.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC03_108/ov_SC03_108_jr_80178D40.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x178
 build/src/ov_SC03_108/ov_SC03_108_jr_8017F83C.o: JTBL_PADS := 0,4,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x18,+0xe0
 build/src/ov_SC03_108/ov_SC03_108_o0c.o: JTBL_PADS := 0,4,4,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x38,+0xa8,+0x118
@@ -4171,7 +4171,7 @@ build/src/ov_SC06_011/ov_SC06_011_jr_80159C84.o: JTBL_PADS := 0,4  # §8e pads (
 build/src/ov_SC06_011/ov_SC06_011_jr_8015AE2C.o: JTBL_PADS := 0,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC06_011/ov_SC06_011_jr_8016AB6C.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC06_011/ov_SC06_011_jr_80178D40.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x178
-build/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
+build/src/ov_SC06_011/ov_SC06_011_jr_8017BEBC.o: JTBL_PADS := 0,0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20,+0x3c
 build/src/ov_SC06_011/ov_SC06_011_o0c.o: JTBL_PADS := 0,4,4,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x38,+0xa8,+0x118
 ov_SC06_011_CHECK_SHA  := config/check.ov_SC06_011.sha
 ov_SC06_011_SYMBOLS    := config/symbols.ov_SC06_011.txt
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_8013F350.c b/src/ov_MAIN_012/ov_MAIN_012_jr_8013F350.c
index 697209df2..b4aaa6b4d 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_8013F350.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_8013F350.c
@@ -5118,7 +5118,12 @@ DEFINE_func_8014CB9C()  /* dedup: shared engine-core @0x8014cb9c (src/shared) */
 DEFINE_func_8014CBD8()  /* dedup: shared engine-core @0x8014cbd8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8013F350", func_8014CBE8);
+extern u16 D_80126CC4;
+
+void func_8014CBE8(void) {
+    D_80126CC4 = 0;
+}
+
 
 DEFINE_func_8014CBF8()  /* dedup: shared engine-core @0x8014cbf8 (src/shared) */
 
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_8015A3C8.c b/src/ov_MAIN_012/ov_MAIN_012_jr_8015A3C8.c
index 3baf8efe5..383a3786d 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_8015A3C8.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_8015A3C8.c
@@ -3897,7 +3897,13 @@ DEFINE_func_8015D480()  /* dedup: shared engine-core @0x8015d480 (src/shared) */
 DEFINE_func_8015D4B4()  /* dedup: shared engine-core @0x8015d4b4 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8015A3C8", func_8015D4E8);
+extern void (*D_80180C54[])(void);
+
+s32 func_8015D4E8(void *a0)
+{
+    D_80180C54[*(u16 *)((s32)a0 + 0x2)]();
+}
+
 
 DEFINE_func_8015D524()  /* dedup: shared engine-core @0x8015d524 (src/shared) */
 
@@ -4244,7 +4250,13 @@ DEFINE_func_8015E150()  /* dedup: shared engine-core @0x8015e150 (src/shared) */
 DEFINE_func_8015E184()  /* dedup: shared engine-core @0x8015e184 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8015A3C8", func_8015E1B8);
+extern void (*D_80180CD4[])(void);
+
+func_8015E1B8(a0)
+{
+    D_80180CD4[*(u16 *)((s32)a0 + 0x2)]();
+}
+
 
 DEFINE_func_8015E1F4()  /* dedup: shared engine-core @0x8015e1f4 (src/shared) */
 
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_80171B4C.c b/src/ov_MAIN_012/ov_MAIN_012_jr_80171B4C.c
index f8bafa442..435a56af2 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_80171B4C.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_80171B4C.c
@@ -3356,7 +3356,12 @@ DEFINE_func_80172760()  /* dedup: shared engine-core @0x80172760 (src/shared) */
 DEFINE_func_80172780()  /* dedup: shared engine-core @0x80172780 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801727D0);
+s32 func_801727D0(void *a0)
+{
+    extern void (*D_80181900[])(void);
+    D_80181900[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_8017280C()  /* dedup: shared engine-core @0x8017280c (src/shared) */
 
@@ -3370,7 +3375,12 @@ void func_8017288C(void) {
 DEFINE_func_80172894()  /* dedup: shared engine-core @0x80172894 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801728E4);
+s32 func_801728E4(void *a0) {
+
+    extern void (*D_8018190C[])(void);
+    D_8018190C[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172920()  /* dedup: shared engine-core @0x80172920 (src/shared) */
 
@@ -3384,7 +3394,12 @@ void func_801729A8(void) {
 DEFINE_func_801729B0()  /* dedup: shared engine-core @0x801729b0 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801729F0);
+s32 func_801729F0(void *a0) {
+
+    extern void (*D_80181918[])();
+    D_80181918[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172A2C()  /* dedup: shared engine-core @0x80172a2c (src/shared) */
 
@@ -3401,7 +3416,12 @@ void func_80172B0C(void) {
 DEFINE_func_80172B14()  /* dedup: shared engine-core @0x80172b14 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_80172B44);
+s32 func_80172B44(void *a0) {
+
+    extern void (*D_80181928[])(void);
+    D_80181928[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172B80()  /* dedup: shared engine-core @0x80172b80 (src/shared) */
 
@@ -3436,7 +3456,12 @@ void func_80172D60(void) {
 DEFINE_func_80172D68()  /* dedup: shared engine-core @0x80172d68 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_80172DAC);
+s32 func_80172DAC(void *a0) {
+
+    extern u8 D_80181940[];
+    ((void (**)())D_80181940)[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80172DE8()  /* dedup: shared engine-core @0x80172de8 (src/shared) */
 
@@ -3471,7 +3496,12 @@ DEFINE_func_80172FEC()  /* dedup: shared engine-core @0x80172fec (src/shared) */
 DEFINE_func_8017303C()  /* dedup: shared engine-core @0x8017303c (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_80173078);
+s32 func_80173078(void *a0)
+{
+    extern void (*D_8018194C[])(void);
+    D_8018194C[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801730B4()  /* dedup: shared engine-core @0x801730b4 (src/shared) */
 
@@ -3485,7 +3515,16 @@ void func_8017316C(void) {
 DEFINE_func_80173174()  /* dedup: shared engine-core @0x80173174 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_8017319C);
+extern void func_80174684(void *);
+extern s32 func_8017319C();
+
+extern void (*D_80181958[])(void);
+
+s32 func_8017319C(void *a0)
+{
+    D_80181958[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801731D8()  /* dedup: shared engine-core @0x801731d8 (src/shared) */
 
@@ -3596,7 +3635,11 @@ void func_801736A8(void) {
 DEFINE_func_801736B0()  /* dedup: shared engine-core @0x801736b0 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801736FC);
+s32 func_801736FC(void *a0) {
+    extern s32 D_80181978;
+    ((s32 (*)(void *))(*(&D_80181978 + *(u8 *)((s32)a0 + 0x214))))(a0);
+}
+
 
 DEFINE_func_80173738()  /* dedup: shared engine-core @0x80173738 (src/shared) */
 
@@ -3610,7 +3653,13 @@ void func_801737B0(void) {
 DEFINE_func_801737B8()  /* dedup: shared engine-core @0x801737b8 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801737E8);
+extern u8 D_80181984[];
+
+s32 func_801737E8(void *a0)
+{
+    ((void (**)(void *))D_80181984)[*(u8 *)((s32)a0 + 0x214)](a0);
+}
+
 
 DEFINE_func_80173824()  /* dedup: shared engine-core @0x80173824 (src/shared) */
 
@@ -3624,7 +3673,12 @@ void func_801738D4(void) {
 DEFINE_func_801738DC()  /* dedup: shared engine-core @0x801738dc (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_8017390C);
+s32 func_8017390C(void *a0) {
+
+    extern void (*D_80181990[])(void);
+    D_80181990[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80173948()  /* dedup: shared engine-core @0x80173948 (src/shared) */
 
@@ -3690,7 +3744,12 @@ void func_80174274(void) {
 DEFINE_func_8017427C()  /* dedup: shared engine-core @0x8017427c (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801742A4);
+extern void (*aD_801819C0[])(void) __asm__("D_801819C0");
+
+s32 func_801742A4(void *a0) {
+    aD_801819C0[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801742E0()  /* dedup: shared engine-core @0x801742e0 (src/shared) */
 
@@ -3704,7 +3763,13 @@ void func_80174354(void) {
 DEFINE_func_8017435C()  /* dedup: shared engine-core @0x8017435c (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_80174384);
+s32 func_80174384(void* a0)
+{
+
+    extern void (*D_801819CC[])(void);
+    D_801819CC[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801743C0()  /* dedup: shared engine-core @0x801743c0 (src/shared) */
 
@@ -3718,7 +3783,13 @@ void func_80174430(void) {
 DEFINE_func_80174438()  /* dedup: shared engine-core @0x80174438 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_80174474);
+extern void (*D_801819D8[])(void);
+
+s32 func_80174474(void* a0)
+{
+    D_801819D8[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801744B0()  /* dedup: shared engine-core @0x801744b0 (src/shared) */
 
@@ -3783,7 +3854,13 @@ DEFINE_func_80174784()  /* dedup: shared engine-core @0x80174784 (src/shared) */
 DEFINE_func_801747AC()  /* dedup: shared engine-core @0x801747ac (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_80171B4C", func_801747CC);
+s32 func_801747CC(void* a0)
+{
+
+    extern void (*D_801819E4[])(void);
+    D_801819E4[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_80174808()  /* dedup: shared engine-core @0x80174808 (src/shared) */
 
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_8017CA18.c b/src/ov_MAIN_012/ov_MAIN_012_jr_8017CA18.c
index dbce7515e..e6a4d2a79 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_8017CA18.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_8017CA18.c
@@ -3923,5 +3923,28 @@ s32 func_8017CBC8(s32 ot, u8 *s, s16 c) {
 }
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8017CA18", func_8017CEB8);
+s32 func_8017CEB8(s32 a0, s16 a1, s16 a2, s16 a3, s32* p)
+{
+    extern u8 D_80115158[];
+    s32 t0 = 0;
+    *p = 0x808080;
+    a2 = D_80115158[(s16)a2 * 2];
+    if (a1 < 5) {
+        if (a1 > 0) {
+            if ((s16)a3 < a2) {
+                t0 = *(s32 *)(a0 + a3 * 4);
+            }
+        } else if (a1 != 0) {
+            if ((s16)a3 < a2) {
+                t0 = *(s32 *)(a0 + a3 * 4);
+            }
+        }
+    } else if (a1 != 5) {
+        if ((s16)a3 < a2) {
+            t0 = *(s32 *)(a0 + a3 * 4);
+        }
+    }
+    return t0;
+}
+
 
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_8017CF3C.c b/src/ov_MAIN_012/ov_MAIN_012_jr_8017CF3C.c
index 6722cfb3c..ef91aa721 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_8017CF3C.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_8017CF3C.c
@@ -4378,7 +4378,14 @@ s32 *func_8017DD28(s32 *out) {
 }
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8017CF3C", func_8017DF18);
+extern void func_80016714(void *a0, s32 a1);
+extern s8 D_801857F8;
+
+void func_8017DF18(void)
+{
+    func_80016714(&D_801857F8, 0x2DC);
+}
+
 
 #include "common.h"
 
@@ -4438,11 +4445,54 @@ void func_8017DF40(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8017CF3C", func_8017E22C);
+void func_8017E22C(s32 a0) {
+    extern void func_80016714(void *a0, s32 a1);
+    extern char D_80185B00;
+    func_80016714(&D_80185B00, 8);
+}
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8017CF3C", func_8017E254);
 
-INCLUDE_ASM("asm/ov_MAIN_012/nonmatchings/ov_MAIN_012_jr_8017CF3C", func_8017E298);
+s32 func_8017E254(void)
+{
+    extern s16 D_80185B00;
+    extern s16 D_80185B02;
+    extern void (*D_801827D8[])(void);
+    D_801827D8[D_80185B00]();
+    return ((u32)D_80185B02) >> 31;
+}
+
+
+extern s16 D_80185B08;
+extern s32 func_80029504(void);
+extern u16 D_80185B00;
+extern void func_8017C008(s32, s16);
+
+void func_8017E298() {
+
+    extern s16 D_80185B08;
+    extern u16 D_80185B00;
+    extern s32 func_80029504(void);
+    extern void func_8017C008(s32, s16);
+    s32 v;
+    u16 *p;
+
+    v = func_80029504();
+
+    if ((u32)(v - 5) >= 0x4B5) {
+        if (v != 0x6A4) {
+            D_80185B08 = 1;
+        } else {
+            D_80185B08 = 2;
+        }
+    } else {
+        D_80185B08 = 0;
+    }
+
+    func_8017C008(1, D_80185B08);
+    p = &D_80185B00;
+    (*p)++;
+}
+
 
 void func_8017E324(void) {
 
diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8017C340.c b/src/ov_SC01_005/ov_SC01_005_jr_8017C340.c
index d086e2d47..1b015d5be 100644
--- a/src/ov_SC01_005/ov_SC01_005_jr_8017C340.c
+++ b/src/ov_SC01_005/ov_SC01_005_jr_8017C340.c
@@ -3178,7 +3178,20 @@ void func_8017C340(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017C340", func_8017D220);
+extern s32 D_80126B58;
+extern s32 func_80029504(void);
+extern void func_8014BD98(s32 a0, u16 a1);
+extern void func_8014BB0C(void);
+extern void func_8014BE78(void);
+
+void func_8017D220(void) {
+    if (func_80029504() < 10) {
+        func_8014BD98((s32)&D_80126B58, 100);
+        func_8014BB0C();
+        func_8014BE78();
+    }
+}
+
 
 
 extern void (*D_80185EAC[])(void);
@@ -3340,7 +3353,39 @@ void func_8017D5FC(void) {
 
 INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017C340", func_8017D624);
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017C340", func_8017D6E4);
+void func_8017D6E4(void) {
+    extern void func_8012A018(s32 a, s32 b);
+    extern void func_8012A094(s32 a0);
+    extern void func_8017D7A4(void *a0);
+    extern u8  D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    extern s32 D_801274E8;
+    extern s16 D_801274EA;
+    extern s16 D_801274EC;
+
+    D_80126954 = 400;
+    D_8012695C = 400;
+    D_8012696A = 0x850;
+    D_80126968 = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x82;
+    D_8012697A = -0x180;
+    func_8012A018((s32)func_8017D7A4, 0);
+    (*(s16 *)&D_801274E8) = 0xD;
+    D_801274EA = -0x82;
+    D_801274EC = 0x8A;
+    func_8017D7A4(D_80126948);
+    func_8012A094((s32)D_80126948);
+}
+
 
 
 extern void (*D_80185EF8[])(void);
@@ -3399,7 +3444,27 @@ s16 func_8017DA9C(void) {
 DEFINE_func_8017DAAC()  /* dedup: shared engine-core @0x8017DAAC (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017C340", func_8017DB00);
+void func_8017DB00(void *a0) {
+    extern u8 D_800B9A15;
+    extern unsigned char D_800B9A13;
+    extern u16 D_80115110;
+    extern u16 D_80115112;
+    extern s16 D_80115126;
+    extern s16 D_801CD878;
+    extern void *D_8011DB24;
+    extern void func_8013E5E8(void);
+    void *func_ptr;
+
+    D_800B9A15 = 1;
+    D_80115112 = 7;
+    D_800B9A13 = 1;
+    func_ptr = func_8013E5E8;
+    D_80115110 = 0;
+    D_80115126 = (s16)a0;
+    D_801CD878 = 0;
+    D_8011DB24 = func_ptr;
+}
+
 
 extern void func_80029444(void);
 extern void func_801754A8(void);
@@ -3702,7 +3767,70 @@ void func_8017DEFC(void) {
 DEFINE_func_8017E0EC()  /* dedup: shared engine-core @0x8017E0EC (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017C340", func_8017E108);
+void func_8017E108(void)
+{
+    extern s32 D_801151D0;
+    extern s32 D_801151C8[];
+    extern s16 D_800B9A02;
+    extern u16 D_8011511A;
+    extern s16 D_80115126;
+    extern u8  D_80115138[];
+    extern u32 D_801CD9A8;
+    extern u32 D_801CD9AC;
+    extern s32 D_80115130;
+    extern u8  D_801BBA3C[];
+    extern u8  D_800B9A15;
+    extern u16 D_80115112;
+
+    extern s32 func_8017E3DC(void);
+    extern void func_8017E6BC(void);
+    extern s16 func_8014168C(s16 a0);
+    extern s32 func_8017ED5C(s32 a0, s32 a1);
+    extern void func_80139954(void);
+    extern s32 func_801376E8(s32 a0, s32 a1);
+    extern void func_80137B80(void);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+
+    register s32 b __asm__("$6");
+    s32 r;
+    s16 c;
+    s32 p;
+    s32 *p30;
+    u16 *p12;
+    s32 frame_pad[2];
+
+    D_801151D0 = D_801151C8[*(u16 *)&D_800B9A02];
+    r = func_8017E3DC();
+    func_8017E6BC();
+    c = func_8014168C(*(s16 *)&D_8011511A);
+    b = D_80115138[D_8011511A];
+    if (D_80115126 != 4) {
+        if (D_801CD9A8 != 0) {
+            p = D_801CD9A8;
+        } else {
+            p = func_8017ED5C(b, c);
+        }
+        if (p != 0) {
+            p30 = &D_80115130;
+            if (p != *p30) {
+                *p30 = p;
+                func_80139954();
+                D_801CD9AC = func_801376E8(p, (s32)D_801BBA3C);
+            }
+        }
+        func_80137B80();
+    }
+    if ((s16)r < 0) {
+        func_80139954();
+        D_800B9A15 = 0;
+        if ((s16)r == -1) {
+            func_8002D4C8(0x474, 0);
+        }
+        p12 = &D_80115112;
+        *p12 += 2;
+    }
+}
+
 
 void func_8017E258(void) {
     extern short D_800B9A02;
diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c b/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
index ad94af4f8..3e25e7df4 100644
--- a/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
+++ b/src/ov_SC01_005/ov_SC01_005_jr_8017ED5C.c
@@ -3348,7 +3348,22 @@ extern s32 func_8017DAAC(s32 a0, s32 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180614);
+s32 func_80180614(s32 a0) {
+    if (*(s16 *)(a0 + 0x10A) != 0) {
+        u16 next = *(u16 *)(a0 + 0x106) - 0x10;
+        *(s16 *)(a0 + 0x106) = next;
+        *(s16 *)(a0 + 0x108) = next;
+        if ((s16)next < 0) {
+            *(s16 *)(a0 + 0x106) = 0;
+            *(s16 *)(a0 + 0x108) = 0;
+        }
+        *(u16 *)(a0 + 0x10A) = *(u16 *)(a0 + 0x10A) - 3;
+        return 0;
+    }
+    *(s16 *)(*(s32 *)(a0 + 0xD4) + 0xFC) = 1;
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180674);
 
@@ -3369,7 +3384,23 @@ DEFINE_func_80180800()  /* dedup: shared engine-core @0x80180800 (src/shared) */
 
 INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180808);
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180908);
+extern s32 func_8016F1AC(void);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern u8 D_801BBC4C[];
+
+void func_80180908(a0)
+s32 a0;
+{
+    if (*(s32 *)(a0 + 0x1C) != 0) {
+        *(s32 *)(a0 + 0x1C) -= 1;
+    } else {
+        if (func_8016F1AC() == 0) {
+            func_80178B18(a0, &D_801BBC4C);
+            *(u16 *)(a0 + 2) += 1;
+        }
+    }
+}
+
 
 extern void func_8017FBCC(void);
 extern void func_8017FD50(s32 a0);
@@ -3396,7 +3427,19 @@ void func_80180974(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_801809F4);
+extern u8 D_80185E38[];
+extern void func_800D1724(s32 a0);
+
+void func_801809F4(s32 *a0) {
+    s32 v1;
+    v1 = a0[7] - 1;
+    a0[7] = v1;
+    if (v1 != -1) {
+        return;
+    }
+    func_800D1724((s32)D_80185E38);
+}
+
 
 DEFINE_func_80180A30()  /* dedup: shared engine-core @0x80180A30 (src/shared) */
 
@@ -3404,7 +3447,14 @@ INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180A3
 
 INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180AD0);
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180AE8);
+
+
+void func_80180AE8(param_1)
+s32 param_1;
+{
+    *(u16 *)(*(s32 *)(param_1 + 0xd0) + 0x2) += 1;
+}
+
 
 DEFINE_func_80180B04()  /* dedup: shared engine-core @0x80180B04 (src/shared) */
 
@@ -3559,7 +3609,21 @@ void func_80180FB0(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80180FFC);
+extern s32 func_80180BDC(s32 a0);
+extern u8 D_801BC5F8[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80180FFC(s32 a0) {
+    s32 v0;
+    v0 = func_80180BDC(a0);
+    if ((v0 << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, &D_801BC5F8);
+    *(s32 *)(a0 + 0x1c) = 0x28;
+    *(u16 *)(a0 + 2) += 1;
+}
+
 
 extern u8 D_801BC680[];
 extern void func_8012A828(s32 a0, void *a1);
@@ -3633,7 +3697,31 @@ extern void func_8012A828(s32 a0, void *a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8017ED5C", func_80181228);
+extern void *D_801BC798[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80181228(a0)
+s32 a0;
+{
+    s16 temp;
+
+    if (*(s16 *)(a0 + 0xFC) == 0) {
+        return;
+    }
+    temp = *(s16 *)(a0 + 0xFE);
+    if (temp == 0) {
+        *(s16 *)(a0 + 0xFE) = 8;
+        return;
+    }
+    temp = temp - 1;
+    *(s16 *)(a0 + 0xFE) = temp;
+    if ((temp << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, D_801BC798[*(s16 *)(a0 + 0xFC)]);
+    *(s16 *)(a0 + 0xFC) = 0;
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8017AE2C.c b/src/ov_SC01_006/ov_SC01_006_jr_8017AE2C.c
index 9c55cdbfa..ea5f15992 100644
--- a/src/ov_SC01_006/ov_SC01_006_jr_8017AE2C.c
+++ b/src/ov_SC01_006/ov_SC01_006_jr_8017AE2C.c
@@ -3434,7 +3434,18 @@ void func_8017C2A4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017AE2C", func_8017C2F4);
+extern void func_80154150(s32 a0, s32 a1);
+extern void func_80171A1C(u8 *a0);
+
+void func_8017C2F4(a0)
+void *a0;
+{
+    if (*(u16 *)((s32)a0 + 0xB8) == 0x8000) {
+        func_80154150((s32)a0, 0x25);
+        func_80171A1C((u8 *)a0);
+    }
+}
+
 
 DEFINE_func_8017C338()  /* dedup: shared engine-core @0x8017C338 (src/shared) */
 
diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8017C340.c b/src/ov_SC01_006/ov_SC01_006_jr_8017C340.c
index 51e00ae3c..008c16e56 100644
--- a/src/ov_SC01_006/ov_SC01_006_jr_8017C340.c
+++ b/src/ov_SC01_006/ov_SC01_006_jr_8017C340.c
@@ -3176,7 +3176,20 @@ void func_8017C340(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017D220);
+extern s32 D_80126B58;
+extern s32 func_80029504(void);
+extern void func_8014BD98(s32 a0, u16 a1);
+extern void func_8014BB0C(void);
+extern void func_8014BE78(void);
+
+void func_8017D220(void) {
+    if (func_80029504() < 10) {
+        func_8014BD98((s32)&D_80126B58, 100);
+        func_8014BB0C();
+        func_8014BE78();
+    }
+}
+
 
 
 extern void (*D_80185EAC[])(void);
@@ -3338,7 +3351,39 @@ void func_8017D5FC(void) {
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017D624);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017D6E4);
+void func_8017D6E4(void) {
+    extern void func_8012A018(s32 a, s32 b);
+    extern void func_8012A094(s32 a0);
+    extern void func_8017D7A4(void *a0);
+    extern u8  D_80126948[];
+    extern s32 D_80126954;
+    extern s32 D_8012695C;
+    extern s16 D_80126968;
+    extern s16 D_8012696A;
+    extern s16 D_8012696C;
+    extern s16 D_80126976;
+    extern s16 D_80126978;
+    extern s16 D_8012697A;
+    extern s32 D_801274E8;
+    extern s16 D_801274EA;
+    extern s16 D_801274EC;
+
+    D_80126954 = 400;
+    D_8012695C = 400;
+    D_8012696A = 0x850;
+    D_80126968 = 0;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x82;
+    D_8012697A = -0x180;
+    func_8012A018((s32)func_8017D7A4, 0);
+    (*(s16 *)&D_801274E8) = 0xD;
+    D_801274EA = -0x82;
+    D_801274EC = 0x8A;
+    func_8017D7A4(D_80126948);
+    func_8012A094((s32)D_80126948);
+}
+
 
 
 extern void (*D_80185EF8[])(void);
@@ -3370,7 +3415,27 @@ s16 func_8017DA9C(void) {
 
 DEFINE_func_8017DAAC()  /* dedup: shared engine-core @0x8017DAAC (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017DB00);
+void func_8017DB00(void *a0) {
+    extern u8 D_800B9A15;
+    extern unsigned char D_800B9A13;
+    extern u16 D_80115110;
+    extern u16 D_80115112;
+    extern s16 D_80115126;
+    extern s16 D_801CD878;
+    extern void *D_8011DB24;
+    extern void func_8013E5E8(void);
+    void *func_ptr;
+
+    D_800B9A15 = 1;
+    D_80115112 = 7;
+    D_800B9A13 = 1;
+    func_ptr = func_8013E5E8;
+    D_80115110 = 0;
+    D_80115126 = (s16)a0;
+    D_801CD878 = 0;
+    D_8011DB24 = func_ptr;
+}
+
 
 
 extern void func_80029444(void);
@@ -3652,7 +3717,70 @@ void func_8017DEFC(void) {
 DEFINE_func_8017E0EC()  /* dedup: shared engine-core @0x8017E0EC (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017E108);
+void func_8017E108(void)
+{
+    extern s32 D_801151D0;
+    extern s32 D_801151C8[];
+    extern s16 D_800B9A02;
+    extern u16 D_8011511A;
+    extern s16 D_80115126;
+    extern u8  D_80115138[];
+    extern u32 D_801CD9A8;
+    extern u32 D_801CD9AC;
+    extern s32 D_80115130;
+    extern u8  D_801BBA3C[];
+    extern u8  D_800B9A15;
+    extern u16 D_80115112;
+
+    extern s32 func_8017E3DC(void);
+    extern void func_8017E6BC(void);
+    extern s16 func_8014168C(s16 a0);
+    extern s32 func_8017ED5C(s32 a0, s32 a1);
+    extern void func_80139954(void);
+    extern s32 func_801376E8(s32 a0, s32 a1);
+    extern void func_80137B80(void);
+    extern void func_8002D4C8(s32 a0, s32 a1);
+
+    register s32 b __asm__("$6");
+    s32 r;
+    s16 c;
+    s32 p;
+    s32 *p30;
+    u16 *p12;
+    s32 frame_pad[2];
+
+    D_801151D0 = D_801151C8[*(u16 *)&D_800B9A02];
+    r = func_8017E3DC();
+    func_8017E6BC();
+    c = func_8014168C(*(s16 *)&D_8011511A);
+    b = D_80115138[D_8011511A];
+    if (D_80115126 != 4) {
+        if (D_801CD9A8 != 0) {
+            p = D_801CD9A8;
+        } else {
+            p = func_8017ED5C(b, c);
+        }
+        if (p != 0) {
+            p30 = &D_80115130;
+            if (p != *p30) {
+                *p30 = p;
+                func_80139954();
+                D_801CD9AC = func_801376E8(p, (s32)D_801BBA3C);
+            }
+        }
+        func_80137B80();
+    }
+    if ((s16)r < 0) {
+        func_80139954();
+        D_800B9A15 = 0;
+        if ((s16)r == -1) {
+            func_8002D4C8(0x474, 0);
+        }
+        p12 = &D_80115112;
+        *p12 += 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017C340", func_8017E258);
 
diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c b/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
index 29a1f45cb..06eaff25d 100644
--- a/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
+++ b/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
@@ -3097,9 +3097,163 @@ INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017FD5
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017FF74);
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180010);
+extern s32 func_8016F1AC(void);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern u8 D_801BBE98[];
+extern void func_80029124(s32, s32);
+extern void func_80029514(s32);
+extern void func_8017FD50(s32);
+
+void func_80180010(param_1)
+s32 param_1;
+{
+    extern void func_8017FD50(s32);
+    extern s32 func_8016F1AC(void);
+    extern void func_80029514(s32);
+    extern void func_80029124(s32, s32);
+    extern s32 func_80178B18(s32 param_1, s32 param_2);
+    extern u8 D_801BBE98[];
+
+    func_8017FD50(param_1);
+    if (*(s32 *)(param_1 + 0x1C) != 0) {
+        (*(s32 *)(param_1 + 0x1C))--;
+    } else {
+        if (func_8016F1AC() == 0) {
+            func_80029514(10);
+            func_80029124(0x125, 0);
+            func_80029124(0x126, 0);
+            func_80029124(0x127, 0);
+            func_80029124(0x128, 0);
+            *(u16 *)(param_1 + 0xDE) = 0;
+            *(u16 *)(param_1 + 0xDC) = 0;
+            func_80178B18(param_1, (s32)D_801BBE98);
+            *(s32 *)(param_1 + 0x1C) = 0;
+            *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+        }
+    }
+}
+
+
+extern s32 *D_80126B78;
+extern s32 D_80126B58;
+extern u8 D_80185E80[];
+extern void func_8017FD50(s32);
+extern s32 func_800149E0(s32);
+extern s32 func_800CF8B4();
+extern void func_80029514(s32);
+extern void func_80029124(s32, s32);
+extern s32 func_80029178(s32);
+extern void func_80172F9C(void);
+extern void func_80171B10(void *a0);
+extern void func_80172B14(s16);
+extern void func_80172EFC(void);
+extern void func_80182324(void);
+extern s32 func_801789AC(s32);
+extern void func_80178D18(void);
+extern void func_801746A4(void);
+extern void func_800D1724(s32 a0);
+
+typedef struct { s16 a; s16 b; s16 c; } Trio;
+
+void func_801800C0(s32 arg0)
+{
+    register s32 s1v __asm__("$17");
+    s32 v0;
+    s16 var;
+    s16 var2;
+    u16 u0;
+    Trio sp; // unused
+
+    *(s32*)(arg0 + 0x1c) += 1;
+    var = *(s16*)(arg0 + 0x10a);
+    if (var != 0) {
+        var = var - 1;
+        *(s16*)(arg0 + 0x10a) = var;
+        if ((var * 0x10000 >> 16) < 0x40) {
+            var2 = *(s16*)(arg0 + 0x106);
+            if (var2 != 0) {
+                var2 = var2 - 8;
+                *(s16*)(arg0 + 0x106) = var2;
+                if (var2 * 0x10000 < 0) {
+                    *(u16*)(arg0 + 0x106) = 0;
+                }
+            } else {
+                u0 = *(u16*)(arg0 + 0x108) - 8;
+                *(u16*)(arg0 + 0x108) = u0;
+                if ((s16)u0 < 0) {
+                    *(u16*)(arg0 + 0x108) = 0;
+                }
+            }
+        }
+        func_8017FD50(arg0);
+        v0 = 1;
+    } else {
+        v0 = 0;
+    }
+    if (v0 == 0 && (func_800149E0(0) & 0x800) != 0 && func_800CF8B4() != 0) {
+        if (*(s32*)(arg0 + 0x1c) == 0x8e) {
+            *(u16*)(D_80126B78 + 4) = 0;
+        }
+        *(u16*)(arg0 + 2) += 2;
+        func_80029514(2);
+        ((void (*)(u8*))func_800D1724)(D_80185E80);
+        return;
+    }
+    if (func_80029178(0x125) & 0xFF) {
+        func_80029124(0x125, 0);
+        func_80172F9C();
+    }
+    if (func_80029178(0x129) & 0xFF) {
+        func_80029124(0x129, 0);
+        func_80029124(0x126, 0);
+        sp.a = 0x20;
+        sp.b = 0;
+        sp.c = -0x80;
+        ((void (*)(void*, void*))func_80171B10)(&D_80126B58, &sp);
+    }
+    if (!(func_80029178(0x126) & 0xFF)) goto block_126;
+    switch (*(s16*)(arg0 + 0xdc)) {
+    case 0:
+        s1v = 0xe00;
+        break;
+    case 1:
+        s1v = 0x180;
+        break;
+    case 2:
+        s1v = 0xfc0;
+        break;
+    case 3:
+        s1v = -1;
+        func_80029124(0x126, 0);
+        break;
+    }
+    if ((s16)s1v > 0) {
+        u0 = *(u16*)(arg0 + 0xde) + 1;
+        *(u16*)(arg0 + 0xde) = u0;
+        if ((u0 * 0x10000 >> 16) >= 0x10) {
+            *(u16*)(arg0 + 0xde) = 0;
+            *(u16*)(arg0 + 0xdc) += 1;
+        }
+        func_80172B14(s1v);
+    }
+    __asm__ __volatile__("" : : "r"(s1v));
+block_126:
+    if (func_80029178(0x127) & 0xFF) {
+        func_80029124(0x127, 0);
+        func_80172EFC();
+    }
+    if (func_80029178(0x128) & 0xFF) {
+        func_80029124(0x128, 0);
+        func_80182324();
+    }
+    if (func_801789AC(arg0) != 0) {
+        ((void (*)(s32))func_80178D18)(arg0);
+        func_801746A4();
+        *(s32*)(arg0 + 0x1c) = 0x10;
+        *(u16*)(arg0 + 2) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_801800C0);
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_801803AC);
 
@@ -3143,7 +3297,22 @@ extern void func_8017DAAC(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180614);
+s32 func_80180614(s32 a0) {
+    if (*(s16 *)(a0 + 0x10A) != 0) {
+        u16 next = *(u16 *)(a0 + 0x106) - 0x10;
+        *(s16 *)(a0 + 0x106) = next;
+        *(s16 *)(a0 + 0x108) = next;
+        if ((s16)next < 0) {
+            *(s16 *)(a0 + 0x106) = 0;
+            *(s16 *)(a0 + 0x108) = 0;
+        }
+        *(u16 *)(a0 + 0x10A) = *(u16 *)(a0 + 0x10A) - 3;
+        return 0;
+    }
+    *(s16 *)(*(s32 *)(a0 + 0xD4) + 0xFC) = 1;
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180674);
 
@@ -3180,9 +3349,49 @@ DEFINE_func_80180800()  /* dedup: shared engine-core @0x80180800 (src/shared) */
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180808);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180908);
+extern s32 func_8016F1AC(void);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern u8 D_801BBC4C[];
+
+void func_80180908(a0)
+s32 a0;
+{
+    if (*(s32 *)(a0 + 0x1C) != 0) {
+        *(s32 *)(a0 + 0x1C) -= 1;
+    } else {
+        if (func_8016F1AC() == 0) {
+            func_80178B18(a0, &D_801BBC4C);
+            *(u16 *)(a0 + 2) += 1;
+        }
+    }
+}
+
+
+extern s32 func_801789AC(s32 arg0);
+extern void func_801746A4(void);
+extern void func_80178D18(void);
+extern void func_8017FBCC(void);
+extern void func_8017FD50(s32);
+
+void func_80180974(a0)
+s32 a0;
+{
+    s32 v0;
+
+    if (*(s16 *)(a0 + 0x100) == 0) {
+        func_8017FBCC();
+    } else {
+        func_8017FD50(a0);
+    }
+    v0 = func_801789AC(a0);
+    if (v0 != 0) {
+        ((void (*)(s32))func_80178D18)(a0);
+        func_801746A4();
+        *(s32 *)(a0 + 0x1c) = 0x10;
+        *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180974);
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_801809F4);
 
@@ -3196,7 +3405,14 @@ extern s32 D_801CDED4;
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180AE8);
+
+
+void func_80180AE8(param_1)
+s32 param_1;
+{
+    *(u16 *)(*(s32 *)(param_1 + 0xd0) + 0x2) += 1;
+}
+
 
 DEFINE_func_80180B04()  /* dedup: shared engine-core @0x80180B04 (src/shared) */
 
@@ -3240,15 +3456,63 @@ INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180BD
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180C98);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180D10);
+extern u8 D_801BC6C8[];
+
+void func_80180D10(a0)
+void *a0;
+{
+    if (*(s32 *)((char *)a0 + 0x1c) != 0) {
+        *(s32 *)((char *)a0 + 0x1c) = *(s32 *)((char *)a0 + 0x1c) - 1;
+    } else {
+        *(void **)((char *)a0 + 0xcc) = D_801BC6C8;
+        *(u16 *)((char *)a0 + 2) = *(u16 *)((char *)a0 + 2) + 1;
+    }
+}
+
 
 DEFINE_func_80180D48()  /* dedup: shared engine-core @0x80180D48 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180D9C);
+extern void *D_801BC78C[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80180D9C(a0)
+s32 a0;
+{
+    s16 temp;
+
+    if (*(s16 *)(a0 + 0xFC) == 0) {
+        return;
+    }
+    temp = *(s16 *)(a0 + 0xFE);
+    if (temp == 0) {
+        *(s16 *)(a0 + 0xFE) = 8;
+        return;
+    }
+    temp = temp - 1;
+    *(s16 *)(a0 + 0xFE) = temp;
+    if ((temp << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, D_801BC78C[*(s16 *)(a0 + 0xFC)]);
+    *(s16 *)(a0 + 0xFC) = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180E24);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180E9C);
+extern u8 D_801BC718[];
+
+void func_80180E9C(a0)
+void *a0;
+{
+    if (*(s32 *)((char *)a0 + 0x1c) != 0) {
+        *(s32 *)((char *)a0 + 0x1c) = *(s32 *)((char *)a0 + 0x1c) - 1;
+    } else {
+        *(void **)((char *)a0 + 0xcc) = D_801BC718;
+        *(u16 *)((char *)a0 + 2) = *(u16 *)((char *)a0 + 2) + 1;
+    }
+}
+
 
 extern s32 func_80180BDC(s32 a0);
 extern u8 D_801BC5E0[];
@@ -3265,19 +3529,129 @@ extern void func_8012A828(s32 a0, void *a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180F28);
+extern void *D_801BC798[];
+extern void func_8012A828(s32 a0, void *a1);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180FB0);
+void func_80180F28(a0)
+s32 a0;
+{
+    s16 temp;
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80180FFC);
+    if (*(s16 *)(a0 + 0xFC) == 0) {
+        return;
+    }
+    temp = *(s16 *)(a0 + 0xFE);
+    if (temp == 0) {
+        *(s16 *)(a0 + 0xFE) = 8;
+        return;
+    }
+    temp = temp - 1;
+    *(s16 *)(a0 + 0xFE) = temp;
+    if ((temp << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, D_801BC798[*(s16 *)(a0 + 0xFC)]);
+    *(s16 *)(a0 + 0xFC) = 0;
+}
+
+
+extern u8 D_801BC578[];
+extern u8 D_801BC764[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80180FB0(param_1)
+s32 param_1;
+{
+    extern u8 D_801BC578[];
+    extern u8 D_801BC764[];
+    s32 v1;
+
+    func_8012A828(param_1, D_801BC578);
+    v1 = *(u16 *)(param_1 + 2);
+    *(s32 *)(param_1 + 0xCC) = (s32)D_801BC764;
+    *(s32 *)(param_1 + 0x1C) = 0;
+    *(u16 *)(param_1 + 2) = v1 + 1;
+}
+
+
+extern s32 func_80180BDC(s32 a0);
+extern u8 D_801BC5F8[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80180FFC(s32 a0) {
+    s32 v0;
+    v0 = func_80180BDC(a0);
+    if ((v0 << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, &D_801BC5F8);
+    *(s32 *)(a0 + 0x1c) = 0x28;
+    *(u16 *)(a0 + 2) += 1;
+}
+
+
+extern u8 D_801BC680[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80181054(a0)
+s32 a0;
+{
+    s32 v0;
+    v0 = *(s32 *)(a0 + 0x1C) - 1;
+    *(s32 *)(a0 + 0x1C) = v0;
+    if (v0 == -1) {
+        func_8012A828(a0, &D_801BC680);
+        *(u16 *)(a0 + 2) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80181054);
 
 DEFINE_func_801810AC()  /* dedup: shared engine-core @0x801810AC (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80181100);
+extern void *D_801BC798[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80181100(a0)
+s32 a0;
+{
+    s16 temp;
+
+    if (*(s16 *)(a0 + 0xFC) == 0) {
+        return;
+    }
+    temp = *(s16 *)(a0 + 0xFE);
+    if (temp == 0) {
+        *(s16 *)(a0 + 0xFE) = 8;
+        return;
+    }
+    temp = temp - 1;
+    *(s16 *)(a0 + 0xFE) = temp;
+    if ((temp << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, D_801BC798[*(s16 *)(a0 + 0xFC)]);
+    *(s16 *)(a0 + 0xFC) = 0;
+}
+
+
+extern u8 D_801BC578[];
+extern u8 D_801BC778[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80181188(param_1)
+s32 param_1;
+{
+    extern u8 D_801BC578[];
+    extern u8 D_801BC778[];
+    s32 v1;
+
+    func_8012A828(param_1, D_801BC578);
+    v1 = *(u16 *)(param_1 + 2);
+    *(s32 *)(param_1 + 0xCC) = (s32)D_801BC778;
+    *(s32 *)(param_1 + 0x1C) = 0;
+    *(u16 *)(param_1 + 2) = v1 + 1;
+}
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80181188);
 
 extern s32 func_80180BDC(s32 a0);
 extern u8 D_801BC5E0[];
@@ -3294,7 +3668,31 @@ extern void func_8012A828(s32 a0, void *a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80181228);
+extern void *D_801BC798[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80181228(a0)
+s32 a0;
+{
+    s16 temp;
+
+    if (*(s16 *)(a0 + 0xFC) == 0) {
+        return;
+    }
+    temp = *(s16 *)(a0 + 0xFE);
+    if (temp == 0) {
+        *(s16 *)(a0 + 0xFE) = 8;
+        return;
+    }
+    temp = temp - 1;
+    *(s16 *)(a0 + 0xFE) = temp;
+    if ((temp << 16) != 0) {
+        return;
+    }
+    func_8012A828(a0, D_801BC798[*(s16 *)(a0 + 0xFC)]);
+    *(s16 *)(a0 + 0xFC) = 0;
+}
+
 
 
 extern s32 func_8012C1B8(void);
@@ -3576,7 +3974,57 @@ void func_80182000(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8018203C);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_801820F8);
+typedef struct { u8 b[12]; } Blk12_820F8;
+typedef struct { u8 b[8]; } Blk8_820F8;
+extern s32 D_801C339C[];
+extern s32 D_801C36F8[];
+extern s32 D_801CDD30;
+extern s32 D_801CDE20;
+extern u8 D_801CD9C0[];
+
+void func_801820F8(a0)
+s32 a0;
+{
+    s32 *dst = (s32 *)D_801CD9C0;
+    s32 k = *(s16 *)(a0 + 0x70);
+    s32 m = *(s16 *)(a0 + 0xFE);
+    s32 *src = (s32 *)D_801C339C[k];
+    s32 base = *(s32 *)(D_801C36F8[m] + k * 4);
+    Blk12_820F8 *pd12;
+    Blk8_820F8 *pd8;
+    u8 *t0;
+    u8 *t1;
+    s32 cond;
+
+    base += *(s32 *)(a0 + 0x94) * 8;
+    base = *(s32 *)base;
+    cond = base & 0x1000000;
+    if (cond == 0) {
+        pd12 = (Blk12_820F8 *)&D_801CDD30;
+        t0 = (u8 *)base;
+    } else {
+        pd8 = (Blk8_820F8 *)&D_801CDE20;
+        t1 = (u8 *)(base & 0xFEFFFFFF);
+    }
+    while (*src != 0) {
+        if (cond == 0) {
+            if ((u16)(*(u16 *)(t0 + 2) + 0x1FF) < 0x3FF) {
+                *dst++ = *src;
+                *pd12 = *(Blk12_820F8 *)t0;
+                pd12++;
+            }
+        } else {
+            *dst++ = *src;
+            *pd8 = *(Blk8_820F8 *)t1;
+            pd8++;
+        }
+        src++;
+        t0 += 12;
+        t1 += 8;
+    }
+    *dst = 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_80182240);
 
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c b/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
index c664b36a5..372cc0b93 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_80171B4C.c
@@ -3856,7 +3856,13 @@ void func_80174430(void) {
 DEFINE_func_80174438()  /* dedup: shared engine-core @0x80174438 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC02_037/nonmatchings/ov_SC02_037_jr_80171B4C", func_80174474);
+extern void (*D_80187264[])(void);
+
+s32 func_80174474(void* a0)
+{
+    D_80187264[*(u8 *)((s32)a0 + 0x214)]();
+}
+
 
 DEFINE_func_801744B0()  /* dedup: shared engine-core @0x801744b0 (src/shared) */
 
diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8017F83C.c b/src/ov_SC03_108/ov_SC03_108_jr_8017F83C.c
index 79a33ae83..715d31fc0 100644
--- a/src/ov_SC03_108/ov_SC03_108_jr_8017F83C.c
+++ b/src/ov_SC03_108/ov_SC03_108_jr_8017F83C.c
@@ -2904,7 +2904,17 @@ TAIL:
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017F83C", func_8017FBD8);
+
+
+void func_8017FBD8(param_1)
+s32 param_1;
+{
+    *(s32 *)(param_1 + 0x48) = 0x4000;
+    *(s16 *)(param_1 + 2) = 7;
+    *(s32 *)(param_1 + 0x1C) = 0x50;
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x14) = rand() % 0x1000;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017F83C", func_8017FC3C);
 
@@ -3414,7 +3424,46 @@ void func_80180A84(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017F83C", func_80180B7C);
+extern s32 func_8004787C(s32 a0);
+extern u16 D_800B99DA;
+extern u8 D_8019E682;
+extern u8 D_8019E6BC;
+extern u8 D_8019E6BD;
+extern u8 D_8019E6BE;
+
+void func_80180B7C(arg0)
+s32 arg0;
+{
+    s32 r;
+    s32 x;
+    s32 col0;
+    s32 col1;
+    s32 col2;
+    u8 *p;
+    s32 i;
+    s32 off;
+
+    r = func_8004787C((((D_800B99DA << 3) - D_800B99DA) << 3) & 0x7F8);
+    x = (((((r << 1) + r) << 3) + r) << 2) >> 12;
+    col0 = x + 100;
+    col1 = x - 126;
+    col2 = ((((((r << 3) - r) << 3) - r) << 1) >> 12) + 100;
+    i = 0;
+    p = &D_8019E682;
+    off = 0;
+    do {
+        i++;
+        p[off - 2] = col0;
+        p[off - 1] = col1;
+        p[off] = col2;
+        off += 16;
+    } while (i < 3);
+    D_8019E6BC = col0 - 50;
+    D_8019E6BD = col1 - 50;
+    D_8019E6BE = col2 - 50;
+    *(s32 *)(arg0 + 0x1C) += 1;
+}
+
 
 
 
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c b/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
index 41cee2f10..01aa0961c 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.c
@@ -5350,7 +5350,27 @@ ret0:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_8017F500);
+extern short D_801B99A8;
+extern u8 D_801E396C[];
+extern void func_8012A828(s32*, s32);
+extern void func_8012E88C(s32);
+extern void func_80184C90(s32);
+extern void func_80184ED4(s32, s32, s32, s32);
+
+void func_8017F500(arg0)
+void *arg0;
+{
+    extern short D_801B99A8;
+    extern u8 D_801E396C[];
+
+    *(short *)((char *)arg0 + 0x2) = 5;
+    *(short *)((char *)arg0 + 0x34) = 0;
+    func_8012E88C((s32)arg0);
+    ((void (*)(s32, s32))func_8012A828)((s32)arg0, (s32)&D_801B99A8);
+    func_80184C90((s32)arg0);
+    func_80184ED4((s32)arg0, (s32)D_801E396C, 0, 0x60);
+}
+
 
 void func_8017F564(void *a0) {
     extern short D_80191578;
@@ -5921,7 +5941,15 @@ DEFINE_func_8018042C()  /* dedup: shared engine-core @0x8018042C (src/shared) */
 DEFINE_func_8018048C()  /* dedup: shared engine-core @0x8018048C (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801804C8);
+extern void func_80178CBC(s32, s32);
+extern short D_8019195C;
+
+void func_801804C8(s32 arg0) {
+    *(short *)((char *)arg0 + 0x2) = 0x5;
+    ((void (*)(s32 *, s32))func_80178CBC)((s32 *)arg0, (s32)&D_8019195C);
+    *(short *)((char *)arg0 + 0x34) = 0;
+}
+
 
 
 extern s32 func_80184DD0(s32 a0);
@@ -5964,7 +5992,20 @@ void func_80180580(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_801805C0);
+void func_801805C0(s32 arg0) {
+    extern void func_80185F54(void*, s32, s32);
+    extern s32 func_80185BE0(s32);
+    extern s32 func_80184FA4(void);
+    extern void func_801803BC(void*);
+
+    ((void (*)(s32, s32, s32))func_80185F54)(arg0, 0xC, 1);
+    if (func_80185BE0(0xC) != 0) {
+        if (((s32 (*)(s32))func_80184FA4)(arg0) != 0) {
+            ((void (*)(s32))func_801803BC)(arg0);
+        }
+    }
+}
+
 
 void func_80180618(void *arg0) {
     extern short D_801B65C8;
@@ -6311,7 +6352,46 @@ s32 func_80180CC0(void *a0)
 DEFINE_func_80180D38()  /* dedup: shared engine-core @0x80180D38 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8017AE2C", func_80180E28);
+void func_80180E28(s32 a0) {
+    s32 s2;
+    s32 code;
+    s32 a0val;
+    s32 dd;
+    s32 sel;
+
+    s2 = a0;
+    *(s32 *)(*(s32 *)(s2 + 0xCC) + 0xB0) = 2;
+    dd = func_80184DD0(a0);
+    sel = func_80029504();
+
+    if (dd == 2 && sel < 0x276) {
+        a0val = 0xA;
+    } else {
+        if (func_80184BAC(0xA, 0x10) != 0) {
+            code = 0;
+            goto ladder_done;
+        }
+        a0val = 0x10;
+    }
+    if (func_80184BAC(a0val, 0x16) != 0) {
+        code = 1;
+    } else {
+        code = 2;
+    }
+ladder_done:
+
+    switch (code) {
+    case 0:
+        func_80180888((void *)a0);
+        break;
+    case 1:
+        func_801809DC((void *)a0);
+        break;
+    case 2:
+        break;
+    }
+}
+
 
 
 extern s32 func_80185BE0(s32 a0);
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_80181804.c b/src/ov_SC04_019/ov_SC04_019_jr_80181804.c
index 5b595d904..b8d64b859 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_80181804.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_80181804.c
@@ -3114,7 +3114,29 @@ void func_80181B34(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_80181B74);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+
+void func_80181B74(void *a0) {
+    extern void func_8012E8E0(s32 a0, s32 a1);
+    extern void func_8012E88C(s32 a0);
+    extern void func_8012A828(s32 *a0, s32 a1);
+    extern void func_80184C90(s32 a0);
+    extern void func_80181998(void);
+    extern s32 D_80191B3C;
+    extern short D_801C0D40;
+
+    if (func_80178970() != 0) {
+        ((void (*)(s32))func_80178D18)((s32)a0);
+        *(short *)((char *)a0 + 0x2) = 3;
+        func_8012E8E0((s32)a0, (s32)&D_80191B3C);
+        func_8012E88C((s32)a0);
+        func_8012A828((s32 *)a0, (s32)&D_801C0D40);
+        func_80184C90((s32)a0);
+        ((void (*)(void))func_80181998)();
+    }
+}
+
 
 
 extern s32 func_80184FA4(void);
@@ -3418,7 +3440,78 @@ INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_801821D
 
 DEFINE_func_8018233C()  /* dedup: shared engine-core @0x8018233C (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_80182378);
+extern s32 func_80029504(void);
+extern s32 func_8012E544(s32 a0);
+extern short D_80191C10;
+extern short D_80191CD8;
+extern short D_80191D30;
+extern short D_80191D88;
+extern short D_80191E60;
+extern short D_80191E88;
+extern short D_801B9B50;
+extern void func_8012A828(s32*, s32);
+extern void func_8012E88C(s32);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern void func_80178CBC(s32 arg0, s32 arg1);
+
+void func_80182378(a0)
+void *a0;
+{
+
+    extern short D_80191C10;
+    extern short D_801B9B50;
+    extern short D_80191E88;
+    extern short D_80191E60;
+    extern short D_80191CD8;
+    extern short D_80191D88;
+    extern short D_80191D30;
+
+    s32 v;
+    s32 arg;
+
+    *(short *)((char *)a0 + 0x2) = 9;
+    func_8012E8E0((s32)a0, (s32)&D_80191C10);
+    func_8012E88C((s32)a0);
+    func_8012A828((s32 *)a0, (s32)&D_801B9B50);
+
+    
+    if (*(u16 *)a0 == 0x2A0) {
+        v = func_8012E544(0x2A3);
+        if (v == 0) {
+            goto zero;
+        }
+        goto chk;
+    } else {
+        v = func_8012E544(0x2A0);
+        if (v != 0) {
+            goto chk;
+        }
+    }
+zero:
+    v = 0;
+    goto join;
+chk:
+    v = (*(u16 *)(v + 2) == 3);
+join:
+    if (v == 0) {
+        arg = (s32)&D_80191E88;
+        if (*(u16 *)a0 == 0x2A0) {
+            arg = (s32)&D_80191E60;
+        }
+    } else {
+        s32 t = func_80029504();
+        if (t < 0x2A8) {
+            arg = (s32)&D_80191CD8;
+        } else if (t < 0x2DA) {
+            arg = (s32)&D_80191D30;
+        } else {
+            arg = (s32)&D_80191D88;
+        }
+    }
+
+    func_80178CBC((s32 *)a0, arg);
+}
+
 
 
 extern void func_80178CBC(s32 a0, s32 a1);
@@ -3553,7 +3646,59 @@ s32 func_801825BC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_801826AC);
+extern s32 func_80029504(void);
+extern s32 func_80184BAC(s32 arg0, s32 arg1);
+extern s32 func_80184DD0(s32 a0);
+
+void func_801826AC(arg0)
+void *arg0;
+{
+    extern s32 func_80029504(void);
+    extern s32 func_80184BAC(s32 arg0, s32 arg1);
+    extern s32 func_80184DD0(s32 a0);
+    extern void func_80181F70(void *);
+    extern void func_801821A8(void *);
+
+    void *s2 = arg0;
+    s32 state;
+    s32 dd;
+    s32 sel;
+    s32 code;
+    s32 a0val;
+
+    state = 2;
+    *(s32 *)(*(s32 *)((char *)s2 + 0xCC) + 0xB0) = state;
+    dd = func_80184DD0((s32)arg0);
+    sel = func_80029504();
+
+    if (dd == state && sel < 0x276) {
+        a0val = 0xA;
+    } else {
+        if (func_80184BAC(0xA, 0x10) != 0) {
+            code = 0;
+            goto ladder_done;
+        }
+        a0val = 0x10;
+    }
+    if (func_80184BAC(a0val, 0x15) != 0) {
+        code = 1;
+    } else {
+        code = 2;
+    }
+ladder_done:
+
+    switch (code) {
+    case 0:
+        func_80181F70(s2);
+        break;
+    case 1:
+        func_801821A8(s2);
+        break;
+    case 2:
+        break;
+    }
+}
+
 
 
 extern s32 func_80185BE0(s32 a0);
@@ -4199,7 +4344,16 @@ void func_8018375C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_801837A8);
+extern s32 func_80184FA4();
+extern void func_801832A8();
+
+void func_801837A8(void *a0) {
+    *(s32 *)(*(s32 *)((char *)a0 + 0xCC) + 0xB0) = 2;
+    if (((s32 (*)(s32))func_80184FA4)((s32)a0)) {
+        func_801832A8(a0);
+    }
+}
+
 
 extern s32 func_80184FA4(void);
 extern s32 func_80185BE0(s32 arg0);
@@ -4221,7 +4375,28 @@ DEFINE_func_80183838()  /* dedup: shared engine-core @0x80183838 (src/shared) */
 DEFINE_func_80183890()  /* dedup: shared engine-core @0x80183890 (src/shared) */
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80181804", func_801838E0);
+extern int func_80178970(void);
+extern void func_8012A828(s32 *a0, s32 a1);
+extern void func_8012E88C(s32);
+extern void func_80178D18(void);
+
+void func_801838E0(arg0)
+void *arg0;
+{
+    extern int func_80178970(void);
+    extern void func_80178D18(void);
+    extern void func_8012E88C(s32);
+    extern void func_8012A828(s32 *a0, s32 a1);
+    extern short D_801B9AA8;
+
+    if (func_80178970() != 0) {
+        ((void (*)(s32))func_80178D18)((s32)arg0);
+        *(s16 *)((s32)arg0 + 2) = 6;
+        func_8012E88C((s32)arg0);
+        func_8012A828((s32 *)arg0, (s32)&D_801B9AA8);
+    }
+}
+
 
 
 /* func_80183938 — state-entry init (family exemplar, reach x11).
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c b/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
index d1e4ad51e..fae04199c 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_80183E6C.c
@@ -3245,7 +3245,34 @@ INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80183E6C", func_8018450
 
 INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80183E6C", func_80184560);
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80183E6C", func_801845B8);
+extern s32 func_801847BC(void *a0, void *a1);
+extern s32 func_80184BAC(s32 a0, s32 a1);
+extern void func_80184CB8(s32 *a0, s32 a1);
+extern s32 func_801788B8(s32 a0, s32 a1);
+extern s32 func_8018465C(a0);
+extern short D_8019224C;
+extern short D_8019225C;
+
+void func_801845B8(void *a0) {
+    s32 v1;
+
+    if (func_801847BC(a0, &D_8019225C) != 0) {
+        if (func_80184BAC(6, 7) != 0) {
+            *(s16 *)((char *)a0 + 0x2) = 5;
+        } else if (func_80184BAC(7, 0x10) != 0) {
+            *(s16 *)((char *)a0 + 0x2) = 6;
+        } else if (func_80184BAC(0x10, 0x14) != 0) {
+            *(s16 *)((char *)a0 + 0x2) = 0xC;
+        } else {
+            *(s16 *)((char *)a0 + 0x2) = 1;
+        }
+        func_80184CB8((s32 *)a0, (s32)&D_8019224C);
+        v1 = *(s32 *)((char *)a0 + 0x68);
+        *(s16 *)((char *)v1 + 0xC) = 0x7FFF;
+        func_801788B8((s32)a0, (s32)&func_8018465C);
+    }
+}
+
 
 extern s32 func_8012BD14(s32 a0);
 extern s32 func_80178BF8();
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_80185D70.c b/src/ov_SC04_019/ov_SC04_019_jr_80185D70.c
index f7395cbbc..d4afe8f02 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_80185D70.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_80185D70.c
@@ -3398,7 +3398,27 @@ s16 func_80186450(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80185D70", func_80186460);
+extern void func_801864AC(void);
+extern u8 D_800B9A15;
+extern u8 D_800B9A13;
+extern u16 D_80115110;
+extern u16 D_80115112;
+extern s16 D_80115126;
+extern void *D_8011DB24;
+
+s32 func_80186460(s32 a0) {
+    void *func_ptr;
+
+    D_800B9A15 = 1;
+    D_800B9A13 = 4;
+    D_80115110 = 3;
+    func_ptr = func_801864AC;
+    D_80115112 = 0;
+    D_80115126 = (s16)a0;
+    D_8011DB24 = func_ptr;
+    return (s32)func_ptr;
+}
+
 
 
 extern void func_80029444(void);
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_80188E1C.c b/src/ov_SC04_019/ov_SC04_019_jr_80188E1C.c
index 4026a969d..d57d88697 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_80188E1C.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_80188E1C.c
@@ -4810,7 +4810,30 @@ void func_8018BE38(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_80188E1C", func_8018BE74);
+extern s32 D_801E05E0[];
+extern s32 D_801E05F4[];
+extern s32 func_80029504(void);
+extern s32 func_80184D00(void);
+extern s32 func_80184DD0(s32);
+
+void func_8018BE74(a0)
+s32 a0;
+{
+
+    extern s32 D_801E05E0[];
+    extern s32 D_801E05F4[];
+
+    s32 v1 = func_80029504();
+
+    if (v1 < 0xC8) {
+        s32 v0 = ((s32 (*)(void))func_80184D00)();
+        *(s32 *)(a0 + 0xE4) = D_801E05E0[v0];
+    } else {
+        s32 v0 = ((s32 (*)(void))func_80184DD0)();
+        *(s32 *)(a0 + 0xE4) = D_801E05F4[v0];
+    }
+}
+
 
 extern s32 func_8014CB1C(void);
     s32 func_8018BEE8(void) {
diff --git a/src/ov_SC04_019/ov_SC04_019_jr_8018CC40.c b/src/ov_SC04_019/ov_SC04_019_jr_8018CC40.c
index 3baa3f181..5392e6d3e 100644
--- a/src/ov_SC04_019/ov_SC04_019_jr_8018CC40.c
+++ b/src/ov_SC04_019/ov_SC04_019_jr_8018CC40.c
@@ -3272,7 +3272,70 @@ DEFINE_func_8018CDDC()  /* dedup: shared engine-core @0x8018CDDC (src/shared) */
 
 DEFINE_func_8018CDE4()  /* dedup: shared engine-core @0x8018CDE4 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8018CC40", func_8018CDEC);
+extern void func_80029124(s32, s32);
+extern s32 func_800291B4(s32 arg);
+extern s32 func_800D0FE0(s32);
+extern void func_800D0F0C(s32, s32);
+
+extern s16 D_8010EDEC;
+extern u8 D_8010EDF1;
+extern s32 D_801E3D60;
+extern u32 D_801E3D74;
+extern s32 D_801E3EA4;
+
+typedef struct {
+    s16 unk00;   /* 0x00 */
+    s16 pad02;   /* 0x02 */
+    s32 unk04;   /* 0x04 */
+    s32 unk08;   /* 0x08 */
+    s32 unk0C;   /* 0x0C */
+} Struct801E79D8;
+
+extern Struct801E79D8 D_801E79D8;
+
+void func_8018CDEC(void) {
+    s16 i;
+
+    D_801E79D8.unk00 = 0;
+    for (i = 0; i < 0xC; i++) {
+        s32 slot = i + 0x2F;
+        s32 id = func_800291B4(slot) & 0xFF;
+        if (id != 0) {
+            register s32 tmp __asm__("$2");
+            register s32 t __asm__("$5");
+            register s32 rb __asm__("$6");
+            s16 flags;
+            s32 m;
+            tmp = (id << 1) + id;
+            t = tmp << 2;
+            flags = *(s16 *)((u8 *)&D_8010EDEC + t);
+            if (flags < 0) {
+                rb = *(u8 *)((u8 *)&D_8010EDF1 + t);
+                m = rb & 0xFF;
+                if (flags & 0x4000) {
+                    D_801E79D8.unk08 = (&D_801E3D60)[id];
+                    D_801E79D8.unk0C = (&D_801E3D74)[id];
+                    func_80029124(m, 1);
+                    func_800D0FE0(slot);
+                    D_801E79D8.unk00 = 2;
+                    return;
+                } else {
+                    register s32 sc __asm__("$4");
+                    register s32 d __asm__("$2");
+                    sc = slot;
+                    __asm__("" : "=r"(sc) : "0"(sc));
+                    d = rb - 0x14;
+                    __asm__("" : "=r"(d) : "0"(d));
+                    D_801E79D8.unk04 = (&D_801E3EA4)[d >> 1];
+                    ((void (*)(s32))func_800D0F0C)(sc);
+                    D_801E79D8.unk00 = 1;
+                    return;
+                }
+            }
+        }
+    }
+}
+
 
 
 
diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c b/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
index 3dba1c4df..11f6906a6 100644
--- a/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
+++ b/src/ov_SC06_000/ov_SC06_000_jr_8017AE2C.c
@@ -3880,7 +3880,17 @@ void func_8017CC44(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_8017CCC4);
+void func_8017CCC4(void *a0) {
+    s32 *a1 = *(s32 **)((s32)a0 + 0x20);
+    if (*(s32 *)((s32)a0 + 0x1C) & 1) {
+        *(s32 *)(a1 + 1) |= 0x80000000;
+    } else {
+        *(s32 *)(a1 + 1) &= 0x7FFFFFFF;
+    }
+    *(s16 *)((s32)a0 + 0x24) = 3;
+    *(s32 *)((s32)a0 + 0x1C) += 1;
+}
+
 
 
 extern void func_8017CE10(void *a0, s32 a1, s32 a2);
@@ -7459,7 +7469,34 @@ extern void func_8013C0F8(void *a0);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_801823BC);
+extern s16 D_801AEB52[];
+extern s32 D_801A158C;
+extern s32 D_801AEB1C;
+extern s32 D_801B20E0;
+extern void func_80049CAC(s32 a0, s32 a1);
+extern void func_8017EF68(s32 a0, s32 a1, s32 a2);
+
+void func_801823BC(a0, a1)
+s32 a0;
+s32 a1;
+{
+    extern void func_80049CAC(s32 a0, s32 a1);
+    extern void func_8017EF68(s32 a0, s32 a1, s32 a2);
+    extern s16 D_801AEB52[];
+    extern s32 D_801B20E0;
+    extern s32 D_801A158C;
+    extern s32 D_801AEB1C;
+    register s16 *q asm("$17");
+
+    q = D_801AEB52;
+    *q = a0;
+    func_80049CAC((s32)q - 2, (s32)q - 78);
+    __asm__("" : "=r"(q) : "0"(q));
+    D_801AEB1C = (s16)a1;
+    *(s32 *)((s32)q - 82) = 0;
+    func_8017EF68((s32)&D_801B20E0, (s32)&D_801A158C, (s32)q - 82);
+}
+
 
 extern void func_8013C0F8(void *a0);
     extern s32 func_8017EF08(s32 a0);
@@ -8101,7 +8138,22 @@ void func_801837DC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_8018381C);
+/*
+ * func_8018381C — actor update gate.
+ * Runs the table swap + state entry only while the actor is idle (+0x102 == 0)
+ * and the global mode word is anything except 2/3 (sltiu range check).
+ */
+void func_8018381C(void *param_1)
+{
+    extern s32 D_80126B58;
+    extern void (*D_8018C5A0[])(void);
+
+    if ((*(s16 *)((s32)param_1 + 0x102) == 0) && ((u32)(*(u16 *)&D_80126B58 - 2) >= 2)) {
+        func_80178B18((s32)param_1, (s32)D_8018C5A0);
+        func_8018291C((s32)param_1);
+    }
+}
+
 
 extern int func_80178970(void);
 extern void func_80178D18(void);
@@ -8269,7 +8321,36 @@ void func_80183C9C(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_80183DAC);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001CA1C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+
+extern u8 D_8018C804;
+extern s32 D_8018C8C4;
+
+void func_80183DAC(void *arg0)
+{
+    register void *self __asm__("$16") = arg0;
+    s32 h;
+
+    h = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)self + 0x20) = h;
+    if (h == 0) {
+        func_8012CAE4(self);
+    } else {
+        func_8001CA1C(h, (s32)&D_8018C804);
+        func_8012A828((s32)self, &D_8018C8C4);
+        *(u16 *)(*(s32 *)((s32)self + 0x20) + 0x18) = 0x2800;
+        *(u16 *)(*(s32 *)((s32)self + 0x20) + 0x1A) = 0x2800;
+        *(u32 *)(*(s32 *)((s32)self + 0x20) + 4) |= 0x50000000;
+        func_8002D4C8(0x92B, 0);
+        func_8012AD50(self);
+    }
+}
+
 
 typedef struct { s32 w[8]; } Mat32L;
 
@@ -8675,7 +8756,41 @@ void func_80184870(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_801848A4);
+
+
+int func_801848A4(int a0, void* a1)
+{
+    s16 stack_buf[8];
+    register s16 *s0 __asm__("$16") = (s16 *)a1;
+    s16 v0;
+    s32 result;
+    s32 ret;
+
+    v0 = s0[2];
+    stack_buf[0] = v0;
+    v0 = s0[3];
+    stack_buf[4] = v0;
+    v0 = s0[5];
+    stack_buf[5] = v0;
+    stack_buf[1] = v0;
+    v0 = s0[6];
+    stack_buf[6] = v0;
+    stack_buf[2] = v0;
+
+    result = func_80184940((s32)a0, (s32)&stack_buf[0], (s32)&stack_buf[4]);
+
+    if (result != 0) {
+        ret = 1;
+    } else {
+        v0 = s0[7];
+        stack_buf[6] = v0;
+        stack_buf[2] = v0;
+        result = func_80184940((s32)a0, (s32)&stack_buf[0], (s32)&stack_buf[4]);
+        ret = (result != 0);
+    }
+    return ret;
+}
+
 
 void func_80184940(s32 param_1, s32 param_2, s32 param_3)
 {
@@ -9401,7 +9516,23 @@ void func_80185DA4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8017AE2C", func_80185DE0);
+void func_80185DE0(int param_1)
+{
+    extern void func_8012C1B8(void);
+    extern void func_8001C810(s32 a0, s32 a1);
+    extern s32 func_8012AD50(void *a0);
+    extern u8 D_801AA1C8[];
+
+    int v0;
+
+    *(int *)(param_1 + 0x20) = v0 = ((int (*)(void))func_8012C1B8)();
+    if (v0 != 0) {
+        func_8001C810(v0, (s32)D_801AA1C8);
+        *(int *)(v0 + 4) |= 0x50000000;
+        ((s32 (*)(void *))func_8012AD50)((void *)param_1);
+    }
+}
+
 
 void func_80185E44(void) {
 }
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_80181D34.c b/src/ov_SC06_024/ov_SC06_024_jr_80181D34.c
index 6cde81b80..2a4c1ac6e 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_80181D34.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_80181D34.c
@@ -3832,9 +3832,54 @@ void func_801838F0(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80181D34", func_80183940);
+s32 func_80183940(s32 a0, s32 a1) {
+    extern s32 func_80132EF4(s32 a0, s32 a1);
+    extern s32 rand(void);
+    s32 s0;
+    s32 rr;
+    register s32 x1 __asm__("$3");
+    register s32 x2 __asm__("$4");
+
+    if (*(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) >= 0x800) {
+        if (*(s16 *)(a0 + 0xE4) == 0) {
+            *(s16 *)(a0 + 0xE4) = *(u16 *)(a0 + 0xE6);
+            s0 = func_80132EF4(a0, 0x22);
+            if (s0 != 0) {
+                rr = rand();
+                x1 = *(u16 *)(s0 + 0x6);
+                x1 = x1 - 0x10;
+                *(u16 *)(s0 + 0x6) = x1 + (rr & 0x1F);
+                rr = rand();
+                *(s32 *)(s0 + 0x14) = -0x40000;
+                x2 = *(u16 *)(s0 + 0xE);
+                x2 = x2 - 0x10;
+                *(u16 *)(s0 + 0xE) = x2 + (rr & 0x1F);
+                *(s16 *)(s0 + 0x34) = a1;
+                *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) = 0xC010;
+                *(u32 *)(*(s32 *)(s0 + 0x20) + 0x4) |= 0x40000000;
+            }
+            return 1;
+        }
+        *(s16 *)(a0 + 0xE4) = *(s16 *)(a0 + 0xE4) - 1;
+    }
+    return 0;
+}
+
+
+extern u16 D_80126B66;
+extern void func_80181EF4(s32 arg0);
+
+void func_80183A28(param_1)
+int param_1;
+{
+    if ((short)(*(u16 *)(param_1 + 0xE) - D_80126B66) < 0x140) {
+        void **fp = *(void **)(param_1 + 0xDC);
+        if (fp != 0 && *fp != 0)
+            (*(void (*)(void))*fp)();
+        func_80181EF4(param_1);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80181D34", func_80183A28);
 
 extern s32 func_8012BEE8(s32 a0);
 extern void func_8001C924(s32 a0, void *a1);
@@ -4122,7 +4167,20 @@ void func_80183FDC(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80181D34", func_801841F8);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_80142414(s32 a0, s16 a1);
+
+void func_801841F8(p)
+s32 p;
+{
+    if (*(s32 *)(p + 0x1C) == 0xF) {
+        func_80142414(p, -0x90);
+    }
+    if (func_8012BEE8(p) != 0) {
+        *(u16 *)(p + 2) = 2;
+    }
+}
+
 
 
 /* func_80184248 — a randomised state entry: seed the timer at 0x1C with
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c b/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c
index 09f226557..5009b693e 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c
@@ -3384,7 +3384,17 @@ void func_80185D38(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_801851E0", func_80185EB0);
+extern u8 D_801D3784[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_80185EB0(s32 a0) {
+    *(u16 *)(a0 + 0x2) = 0x20;
+    func_8012A828(a0, (s32)&D_801D3784);
+    *(s32 *)(a0 + 0x1C) = 0;
+    *(s32 *)(a0 + 0xE4) = 0;
+    *(s32 *)(a0 + 0x48) = 0x4650;
+}
+
 
 
 
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c b/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c
index 656eb9f11..dee178bb9 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c
@@ -3086,6 +3086,25 @@ void func_80186E48(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_801867DC", func_80186E94);
+extern s32 D_801BC408;
+extern s32 D_801BC418;
+extern void func_8012B14C(s32 a0, s32 a1);
+extern void func_80131B14();
+
+void func_80186E94(a0)
+s32 *a0;
+{
+    s32 s0 = a0;
+    *(u8 *)(s0 + 0xC2) = 0;
+    *(u8 *)(s0 + 0xC3) = 0;
+    *(s32 *)(s0 + 0x1C) = 0;
+    func_80131B14();
+    if ((*(u16 *)(s0 + 0x5E) == 9) || (*(u16 *)(s0 + 0x5E) == 0x1C)) {
+        func_8012B14C(s0, (s32)&D_801BC408);
+    } else {
+        func_8012B14C(s0, (s32)&D_801BC418);
+    }
+}
+
 
 
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c b/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c
index c3f74409c..f4d57ca37 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c
@@ -4623,7 +4623,42 @@ s32 func_801897F0(void *a0, s32 a1, s32 a2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80189888);
+void func_80189888(a0, a1, a2, a3, a4, a5)
+s32 a0;
+void *a1;
+s32 a2;
+s32 a3;
+u16 a4;
+s32 a5;
+{
+    extern s32 func_8012C51C(void *a0, s32 a1);
+    typedef struct {
+        u16 f10; /* 0x10 */
+        u16 f12; /* 0x12 */
+        u16 f14; /* 0x14 */
+        s16 f16; /* 0x16 */
+        s16 f18; /* 0x18 */
+        s16 f1a; /* 0x1A */
+        s16 f1c; /* 0x1C */
+        u16 f1e; /* 0x1E */
+        s32 f20; /* 0x20 */
+    } buf_80189888;
+    buf_80189888 sp;
+    u16 t;
+
+    sp.f10 = *(u16 *)a1;
+    sp.f12 = *(u16 *)(2 + (char *)a1);
+    t = *(u16 *)(4 + (char *)a1);
+    sp.f16 = a2;
+    sp.f18 = a3;
+    sp.f1a = 0;
+    sp.f1e = a4;
+    sp.f20 = a5;
+    sp.f1c = 0x7FFF;
+    sp.f14 = t;
+    func_8012C51C(&sp, a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_801898EC);
 
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8017AE2C.c b/src/ov_SC06_032/ov_SC06_032_jr_8017AE2C.c
index 697691cfa..a74649539 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_8017AE2C.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_8017AE2C.c
@@ -3412,5 +3412,23 @@ INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017AE2C", func_8017C0A
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017AE2C", func_8017C120);
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017AE2C", func_8017C1DC);
+extern s32 func_80146E98(s32 a0);
+extern void func_80146C3C();
+
+void func_8017C1DC(param_1)
+int param_1;
+{
+    int addr;
+
+    addr = *(int *)(param_1 + 0x20);
+    if (*(unsigned int *)(param_1 + 0x1c) & 1) {
+        *(unsigned int *)(addr + 4) = *(unsigned int *)(addr + 4) | 0x80000000;
+    } else {
+        *(unsigned int *)(addr + 4) = *(unsigned int *)(addr + 4) & 0x7fffffff;
+    }
+    if (func_80146E98(param_1) != 0) {
+        ((void (*)(s32))func_80146C3C)(param_1);
+    }
+}
+
 
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8017C24C.c b/src/ov_SC06_032/ov_SC06_032_jr_8017C24C.c
index fae689d00..bd3812b74 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_8017C24C.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_8017C24C.c
@@ -3385,7 +3385,47 @@ int func_8017D77C(short *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_8017D810);
+/* Handwritten GTE squared-distance check (§265 verbatim-asm lane, file-scope form).
+ * Recovered C semantics: dx=D_80126CAC-a0[3]; dz=D_80126CB0-a0[7];
+ * GTE SQR of {dx,0,dz}; return 0xC3FFF < (MAC1+MAC2+MAC3). */
+__asm__(".text\n.align 2\n.globl func_8017D810\n.ent\tfunc_8017D810\n"
+"func_8017D810:\n.frame $sp,16,$31\n.mask 0,0\n.fmask 0,0\n"
+".set\tnoreorder\n"
+"lui $2, %hi(D_80126CAC)\n"
+"lh $2, %lo(D_80126CAC)($2)\n"
+"lh $3, 6($4)\n"
+"addiu $29, $29, -16\n"
+"sw $0, 4($29)\n"
+"subu $2, $2, $3\n"
+"sw $2, 0($29)\n"
+"lui $2, %hi(D_80126CB0)\n"
+"lh $2, %lo(D_80126CB0)($2)\n"
+"lh $3, 14($4)\n"
+"nop\n"
+"subu $2, $2, $3\n"
+"sw $2, 8($29)\n"
+"lwc2 $9, 0($29)\n"
+"lwc2 $10, 4($29)\n"
+"lwc2 $11, 8($29)\n"
+"nop\n"
+"nop\n"
+"sqr 0\n"
+"swc2 $25, 0($29)\n"
+"swc2 $26, 4($29)\n"
+"swc2 $27, 8($29)\n"
+"lui $5, 12\n"
+"ori $5, $5, 16383\n"
+"lw $2, 0($29)\n"
+"lw $3, 4($29)\n"
+"lw $4, 8($29)\n"
+"addu $2, $2, $3\n"
+"addu $2, $2, $4\n"
+"slt $2, $5, $2\n"
+"addiu $29, $29, 16\n"
+"jr $31\n"
+"nop\n"
+".set\treorder\n.end\tfunc_8017D810\n");
+
 
 
 extern void (*D_80196DE0[])(void);
@@ -3417,7 +3457,53 @@ void func_8017D8D0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_8017D940);
+extern void func_8017DABC();
+
+void func_8017D940(int param_1)
+{
+    int iVar2;
+    int iVar3;
+    int iVar4;
+    int iVar5;
+    int tmp;
+    int dcVal;
+
+    if (*(short *)(param_1 + 0xfe) == 0) {
+        iVar2 = func_8004787C((int)*(short *)(param_1 + 0x100));
+        if (iVar2 < 0) {
+            iVar2 = iVar2 + 0x7f;
+        }
+        iVar2 = iVar2 >> 7;
+        tmp = *(unsigned short *)(param_1 + 0x100) + *(unsigned short *)(param_1 + 0x102);
+        *(short *)(param_1 + 0x100) = (short)tmp;
+        iVar3 = func_80047948((short)tmp);
+        if (iVar3 < 0) {
+            iVar3 = iVar3 + 0x7f;
+        }
+        *(int *)(param_1 + 0xe4) = *(int *)(param_1 + 0xe4) + 4;
+        iVar3 = iVar3 >> 7;
+        if (*(int *)(param_1 + 0xe4) >= 0x40) {
+            *(int *)(param_1 + 0xe4) = 0;
+        }
+        dcVal = *(int *)(param_1 + 0xdc);
+        *(int *)(param_1 + 0xe0) = *(int *)(param_1 + 0xe0) + 0xb;
+        iVar4 = func_8004787C(*(int *)(param_1 + 0xe0)) * 0x30;
+        if (iVar4 < 0) {
+            iVar4 = iVar4 + 0xfff;
+        }
+        iVar5 = iVar4 >> 0xc;
+        if (*(int *)(param_1 + 0xe0) >= 0x800) {
+            *(unsigned short *)(param_1 + 2) = *(unsigned short *)(param_1 + 2) - 1;
+            return;
+        }
+        iVar5 = iVar5 << 0x10 | iVar5 << 8 | iVar5;
+        func_8017DABC(param_1, 0, (short)iVar2, (short)iVar3, dcVal, iVar5);
+        func_8017DABC(param_1, 1, (short)iVar2, (short)iVar3, dcVal, iVar5);
+    } else {
+        *(short *)(param_1 + 0xfe) = *(short *)(param_1 + 0xfe) - 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_8017DABC);
 
@@ -4384,7 +4470,19 @@ set_and_return:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_8017F0C0);
+extern u8   D_801BE038[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_8017F0C0(arg0)
+void *arg0;
+{
+    func_8012A828((s32)arg0, D_801BE038);
+    *(s16 *)((s32)arg0 + 0x2) = 0xB;
+    *(s32 *)((s32)arg0 + 0x10) *= 2;
+    *(s32 *)((s32)arg0 + 0x18) *= 2;
+    *(s16 *)((s32)arg0 + 0x34) = 0;
+}
+
 
 
 extern s32  func_80181ED4(s32 a0, s32 a1);
@@ -4679,7 +4777,26 @@ void func_8017F6E8(s32 p)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_8017F84C);
+extern u8 D_801A63EC[];
+extern u8 D_801BD9C0[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_8017F84C(p)
+s32 p;
+{
+    extern u8 D_801A63EC[];
+    extern u8 D_801BD9C0[];
+
+    *(s16 *)(p + 2) = 0x14;
+    if (!(*(u32 *)(p + 0xE0) & 0x400)) {
+        *(s16 *)(p + 0x34) = 1;
+        func_8012A828(p, D_801BD9C0);
+    } else {
+        *(s16 *)(p + 0x34) = 0;
+        func_8012A828(p, D_801A63EC);
+    }
+}
+
 
 typedef struct {
     SVECTOR_8016E7C8 v[4];               /* 0x00 */
@@ -5122,7 +5239,15 @@ void func_801800C4(s32 p) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8017C24C", func_801801A4);
+extern u8 D_801BD7E8[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_801801A4(s32 a0) {
+    *(s16 *)(a0 + 0x2) = 0x1B;
+    func_8012A828(a0, (s32)&D_801BD7E8);
+    *(s32 *)(a0 + 0x1C) = 0x20;
+}
+
 
 extern void func_8012F214(s32, s32, s32);
 extern s32  func_80184028(void *a0, s32 a1, s32 a2);
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_80181014.c b/src/ov_SC06_032/ov_SC06_032_jr_80181014.c
index fb0d5ab40..fe3dea561 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_80181014.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_80181014.c
@@ -2966,7 +2966,16 @@ void func_80181478(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80181014", func_801814DC);
+extern s32 D_801A67EC[];
+extern void func_8012A828(s32 a0, void *a1);
+
+void func_801814DC(param_1)
+s32 param_1;
+{
+    func_8012A828(param_1, (void *)D_801A67EC[*(u16 *)(param_1 + 0x70) & 0xF]);
+    *(s32 *)(param_1 + 0xE4) = 0;
+}
+
 
 extern s32 DUMMY_UNUSED;
 
@@ -3413,7 +3422,75 @@ store:
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80181014", func_801820C4);
+extern u8   D_801202A0[];
+
+extern s32  func_8012BC60(struct Vec *a0, struct Vec *a1);
+extern s32  func_8012B6D4(s16 *a0, s16 *a1);
+extern void func_8012B0B4(unsigned int *p, int a1, int a2);
+extern s32  func_8012CEB0(void *a0, void *a1, s32 a2);
+extern void func_8012ADE4(u8 *a0);
+extern void func_8012C098(void *param_1);
+
+void func_801820C4(s32 a0) {
+    u8 *p;
+    s16 *self4;
+    unsigned int *sc;
+    s32 i;
+    s16 y;
+    s32 z;
+    s32 ang;
+    s16 v10[4];
+    s16 v18[4];
+    s32 sp20[2];
+
+    p = D_801202A0;
+    i = 0;
+    self4 = (s16 *)(a0 + 4);
+    sc = (unsigned int *)sp20;
+    do {
+        if ((u8 *)a0 != p) {
+            switch (*(u16 *)p) {
+            case 0x27A:
+                if (func_8012BC60((struct Vec *)self4, (struct Vec *)(p + 4)) < 0x6400) {
+                    ang = func_8012B6D4(self4, (s16 *)(p + 4));
+                    func_8012B0B4(sc, ang, 0xA1);
+                    v18[0] = *(u16 *)(p + 6);
+                    v18[1] = *(u16 *)(p + 0xA);
+                    v18[2] = *(u16 *)(p + 0xE);
+                    v18[0] += sp20[0];
+                    v18[2] += sp20[0] >> 16;
+                    v18[1] = *(u16 *)(a0 + 0xA);
+                    v10[0] = *(u16 *)(a0 + 0x3A);
+                    v10[1] = *(u16 *)(a0 + 0x3E);
+                    v10[2] = *(u16 *)(a0 + 0x42);
+                    if ((func_8012CEB0(v10, v18, 0) & 0x2000) == 0) {
+                        func_8012ADE4((u8 *)a0);
+                        return;
+                    }
+                    *(u16 *)(a0 + 6) = v18[0];
+                    *(u16 *)(a0 + 0xA) = v18[1];
+                    *(u16 *)(a0 + 0xE) = v18[2];
+                    return;
+                }
+                break;
+            case 0x2F4:
+                y = *(s16 *)(p + 0xE);
+                z = *(s16 *)(a0 + 0xE);
+                if (y + 0x10 < z) {
+                    func_8012C098((void *)a0);
+                    return;
+                }
+                if (y - 0x60 < z) {
+                    *(s16 *)(a0 + 0xE) = y - 0x60;
+                }
+                break;
+            }
+        }
+        i++;
+        p += 0x10C;
+    } while (i < 0x60);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80181014", func_80182288);
 
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
index 1c98bd933..cf59dc8bf 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c
@@ -4666,7 +4666,18 @@ void func_80185670(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857B0);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8012B23C();
+
+void func_801857B0(param_1)
+s32 param_1;
+{
+    func_8012B23C((void *)param_1);
+    *(s32 *)(param_1 + 0x14) = 0xFFD80000;
+    *(s32 *)(param_1 + 0x1C) = 0x10;
+    func_8012AD44((s32 *)param_1, 4);
+}
+
 
 extern void (*D_801BEEF8[])(void);
 extern void func_801875D0(void);
@@ -5395,7 +5406,27 @@ void func_80186CF0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186D90);
+extern int func_8018853C(short *pos, int a1, int a2);
+
+void func_80186D90(a0)
+s32 a0;
+{
+    short buf[4];
+    s32 p;
+
+    buf[0] = *(u16 *)(a0 + 0x6);
+    buf[1] = *(u16 *)(a0 + 0xA);
+    buf[2] = *(u16 *)(a0 + 0xE);
+    buf[3] = 0xC;
+
+    p = func_8018853C(buf, 0, 0x40C0C0);
+    if (p != 0) {
+        *(u16 *)(*(s32 *)(p + 0x20) + 0x2C) = 0xC006;
+        *(s32 *)(*(s32 *)(p + 0x20) + 0x4) |= 0x50000000;
+        *(s16 *)(*(s32 *)(p + 0x20) + 0x18) = 0xA00;
+    }
+}
+
 
 extern s32 func_80132EF4(s32 a0, s32 a1);
 
@@ -9083,7 +9114,31 @@ void func_8018C77C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018C7B8);
+extern void func_80016714(void *a0, s32 a1);
+extern void func_8002A04C(s32 a0);
+extern void func_8012C218(void *a0);
+
+void func_8018C7B8(a0)
+s32 a0;
+{
+    if (*(s16 *)(a0 + 0x70) != 0) {
+        *(u16 *)(a0 + 0x2) = 4;
+        *(u16 *)(a0 + 0x5C) = 0;
+        *(u16 *)(a0 + 0x5E) = 0;
+        *(u8 *)(a0 + 0xC1) = 0;
+        return;
+    }
+
+    if (*(s32 *)(a0 + 0xCC) != 0)
+        func_80016714(*(void **)(a0 + 0xCC), 0x84);
+
+    if (*(s32 *)(a0 + 0xD0) != 0)
+        func_80016714(*(void **)(a0 + 0xD0), 0x84);
+
+    func_8002A04C(a0);
+    func_8012C218((void *)a0);
+}
+
 
 
 extern void func_8002D4C8(s32 arg0, s32 arg1);
@@ -9326,7 +9381,35 @@ void func_8018CD54(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018CDB4);
+void func_8018CDB4(s32 param_1)
+{
+    extern void func_8012C1B8(void);
+    extern void func_8012CAE4(s32);
+    extern void func_8001C214(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_801CC5A8[];
+    extern u8 D_80193650[];
+
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        ((void (*)(void *))func_8012CAE4)((void *)param_1);
+    } else {
+        func_8001C214(v0, (s32)D_801CC5A8);
+        func_8012A828(param_1, (void *)D_80193650);
+        *(u16 *)(param_1 + 0x2) = 1;
+        *(s32 *)(param_1 + 0x1C) = 0x40;
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) =
+            *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x10);
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12);
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) =
+            *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x14);
+    }
+}
+
 
 extern u8 D_801CA8D4[];
 extern u8 D_801CA8E0[];
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
index 25c2eb336..1001201af 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -3911,7 +3911,18 @@ s32 func_8017E1A8(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E1BC);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E20C);
+extern u16 D_801863A0[];
+extern void func_8017E7E8(void *a0);
+
+void func_8017E20C(void *a0) {
+    func_800D0C48(1);
+    func_8017E7E8(a0);
+    *(s32 *)((s32)a0 + 0x1C) = 0x20;
+    func_80178B18((s32)a0, (s32)D_801863A0);
+    *(s16 *)((s32)a0 + 0x100) = 0;
+    func_8012AD44((s32 *)a0, 4);
+}
+
 
 extern s32 func_8012BEE8(s32 arg0);
 extern void func_8012AD80(s32 arg0);
@@ -4004,7 +4015,20 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E448);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E4B0);
+void func_8017E4B0(s32 a0) {
+    extern void func_8012B200(u8 *a0);
+    extern s32 func_8012B8A4(s16 *a0);
+
+    *(s16 *)(a0 + 0x06) = 0x1B0;
+    *(s16 *)(a0 + 0x0A) = -0x600;
+    *(s16 *)(a0 + 0x0E) = 0x2C70;
+    func_8012B200((u8 *)a0);
+    *(s32 *)(a0 + 0x10) = 0xFFFE8000;
+    *(s32 *)(a0 + 0x18) = 0x38000;
+    *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) = func_8012B8A4((s16 *)a0);
+    *(s16 *)(a0 + 0x34) = 3;
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E524);
 
@@ -4509,7 +4533,24 @@ void func_8017F3FC(s32 arg0)
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F464);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F4F8);
+extern u16 D_8018657C[];
+extern u16 D_8018657E[];
+
+void func_8017F4F8(a0)
+s32 a0;
+{
+    extern u16 D_8018657C[];
+    extern u16 D_8018657E[];
+    extern void MoveImage(void *a0, s32 a1, s32 a2);
+    s16 sp[4];
+
+    sp[0] = *(u16 *)((u8 *)D_8018657C + a0 * 4);
+    sp[1] = *(u16 *)((u8 *)D_8018657E + a0 * 4);
+    sp[2] = 0x8;
+    sp[3] = 0x20;
+    MoveImage(&sp[0], 0x2F4, 0x1a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F554);
 
@@ -4914,7 +4955,20 @@ void func_80180AA4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180B3C);
+void func_80180B3C(s32 a0)
+{
+    extern s16 D_801D0B7C;
+    extern void func_8017F098(void);
+    extern s32 func_8012B8A4(s16 *a0);
+    extern void func_8017F464();
+
+    if ((*(u16 *)&D_801D0B7C) == 4) {
+        func_8017F098();
+    }
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = func_8012B8A4((s16 *)a0);
+    func_8017F464(a0);
+}
+
 
 extern void func_80142414(s32 a0, s16 a1);
 extern void func_8017F0D0(s32 a0);
@@ -5255,7 +5309,30 @@ void func_801814B0(s32 param)
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80181528);
+extern s32 D_801ADE64[];
+extern s32 D_801D0900[];
+extern s32 D_801D0904[];
+
+void func_80181528(void *a0) {
+    *(s32 *)((u8 *)a0 + 0x20) = func_8012C1B8();
+    if (*(s32 *)((u8 *)a0 + 0x20) == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    *(s32 *)((s8 *)D_801D0900 + (*(s16 *)((u8 *)a0 + 0x70) << 3)) =
+        D_801ADE64[*(s16 *)((u8 *)a0 + 0x70)];
+    *(s32 *)((s8 *)D_801D0904 + (*(s16 *)((u8 *)a0 + 0x70) << 3)) = 0;
+    func_8001C214(*(s32 *)((u8 *)a0 + 0x20),
+                  (s32)((s8 *)D_801D0900 + (*(s16 *)((u8 *)a0 + 0x70) << 3)));
+
+    *(u16 *)((u8 *)a0 + 0x106) = rand() & 0xF0;
+    *(u16 *)((u8 *)a0 + 0x108) = rand() & 0xF0;
+    func_8012B23C(a0);
+    *(s32 *)((u8 *)a0 + 0x1C) = 0x20;
+    func_8012AD50(a0);
+}
+
 
 extern s32 func_8012BEE8(s32 arg0);
 extern void func_8012C218(void *arg0);