From f74fd335e00e50b48269b79dbf0dee063e6272b3 Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Mon, 24 Aug 2026 07:54:38 -0600
Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20bb=20overlays=20?=
 =?UTF-8?q?=E2=80=94=2029=20banked?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Committed before the main batch: gate_main reverts on failure and would take these with it.
---
 src/md_SC07_004/md_SC07_004.c             |  23 ++++-
 src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c |  13 ++-
 src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c |  27 +++++-
 src/ov_SC02_005/ov_SC02_005_jr_80181D30.c |  17 +++-
 src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c |  18 +++-
 src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c |  15 ++-
 src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c |  58 ++++++++++-
 src/ov_SC03_013/ov_SC03_013_jr_8017C730.c |  42 +++++++-
 src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c |  75 +++++++++++++-
 src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c |  26 ++++-
 src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c |  66 ++++++++++++-
 src/ov_SC04_011/ov_SC04_011_jr_8017D494.c |  35 ++++++-
 src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c |  22 ++++-
 src/ov_SC05_018/ov_SC05_018_jr_8017D604.c |  55 ++++++++++-
 src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c |  23 ++++-
 src/ov_SC06_016/ov_SC06_016_jr_801839D0.c |   2 +-
 src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c |  53 +++++++++-
 src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c |  34 ++++++-
 src/ov_SC06_029/ov_SC06_029_jr_8017C954.c | 100 ++++++++++++++++++-
 src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c | 113 +++++++++++++++++++++-
 src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c |  56 ++++++++++-
 21 files changed, 840 insertions(+), 33 deletions(-)

diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 191753894..251446b9b 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -3049,7 +3049,16 @@ void func_801A8738(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A876C);
+void func_801A876C(s32 arg0, s16 arg1, s32 arg2) {
+    if (*(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) < arg1) {
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) = *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) + arg2;
+    }
+
+    if (*(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) < arg1) {
+        *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) = *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) + arg2;
+    }
+}
+
 
 void func_801A87C4(s32 a0, s16 a1, s32 a2) {
     s16 varA;
@@ -3998,7 +4007,17 @@ s32 func_801AA4EC(s32 param_1, s32 param_2)
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AA540);
+void func_801AA540(void *arg0) {
+    extern u16 D_80126B96;
+    extern s16 D_80126B98;
+    extern s32 func_801AA584();
+
+    if (func_801AA584()) {
+        D_80126B98 = 100;
+        D_80126B96 |= 0x4000;
+    }
+}
+
 
 extern s32 func_8012DEB8(s32 a0, s32 a1, s32 a2);
 
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 114e1d8e2..36ecf5544 100644
--- a/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
+++ b/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
@@ -3001,7 +3001,18 @@ s32 *func_8017EFA8(s32 *ot, void *a1p, s32 idx, void *a3p, s32 tag) {
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017F2D4);
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017F730);
+s32 func_8017F730(void) {
+    extern s32 func_800291B4(s32 arg);
+    extern s16 func_8014168C(s16 a0);
+    extern u8 D_8018347E;
+    extern u8 D_80183478[];
+
+    if ((func_800291B4(D_8018347E) & 0xFF) != 0) {
+        return (func_800291B4(D_80183478[func_8014168C(1)]) & 0xFF) == 0;
+    }
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017F790);
 
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
index 22520912d..dc9d69bc3 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017CA80.c
@@ -6039,7 +6039,32 @@ void func_801853C4(void) {
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_801853CC);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017CA80", func_8018544C);
+void func_8018544C(s32 arg0)
+{
+    s16 sp10[3];
+    s16 temp_v0;
+    s32 temp_a0;
+
+    temp_v0 = *(s16 *)(arg0 + 0xDC) + 0x10;
+    *(s16 *)(arg0 + 0xDC) = temp_v0;
+    temp_a0 = func_8004787C(temp_v0);
+    *(s16 *)(arg0 + 0xA) = *(s16 *)(arg0 + 0xDE) + (temp_a0 << 5 >> 12);
+    sp10[0] = *(u16 *)(arg0 + 6);
+    sp10[1] = *(u16 *)(arg0 + 0xA);
+    sp10[2] = *(u16 *)(arg0 + 0xE);
+    *(u16 *)(*(s32 *)(arg0 + 0xCC) + 8) = sp10[0];
+    *(u16 *)(*(s32 *)(arg0 + 0xCC) + 0xA) = sp10[1];
+    *(u16 *)(*(s32 *)(arg0 + 0xCC) + 0xC) = sp10[2];
+    func_80183DA4(sp10);
+    if (*(u16 *)(arg0 + 0x5C) & 1) {
+        if (*(u16 *)(arg0 + 0x5E) == 0x10) {
+            func_80184090(arg0);
+        } else {
+            *(u16 *)(arg0 + 0x5C) = *(u16 *)(arg0 + 0x5C) & ~1;
+        }
+    }
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern void func_80183DA4();
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
index a02e6ecd9..eb58d42d4 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_80181D30.c
@@ -7387,7 +7387,22 @@ void func_8018A0E4(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_80181D30", func_8018A174);
+void func_8018A174(s32 arg0) {
+    u8 *ptr;
+    s32 i;
+    s16 val;
+
+    i = 0;
+    val = 0x4000;
+    do {
+        ptr = func_8018A30C(arg0, i);
+        if (ptr != NULL) {
+            *(s16 *) (ptr + 0x34) = val;
+        }
+        i++;
+    } while (i < 4);
+}
+
 
 #include "common.h"
 
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 ef468f20a..783dcca7c 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -9476,7 +9476,23 @@ void func_80187110(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801871CC);
+
+extern Block4 D_801EB524;
+extern u8 D_801EB525;
+extern u8 D_801EB526;
+
+void func_801871CC(void) {
+    if (D_801EB524.b[0] < 0xc0) {
+        D_801EB524.b[0] += 4;
+    }
+    if (D_801EB525 < 0xc0) {
+        D_801EB525 += 4;
+    }
+    if (D_801EB526 < 0x20) {
+        D_801EB526 += 4;
+    }
+}
+
 
 extern s32 func_80186740(void);
     void func_80187234(void) {
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
index 8a298808f..73176027f 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8017AE2C.c
@@ -6781,7 +6781,20 @@ void func_801815A8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_8018163C);
+extern void func_800291A0(s32 a0, s32 a1);
+extern void func_8012C218(void *a0);
+
+void func_8018163C(s32 arg0) {
+    short v;
+
+    v = *(short *)((s8 *)arg0 + 0xE) - 0x10;
+    *(short *)((s8 *)arg0 + 0xE) = v;
+    if (v < 0x345) {
+        func_800291A0(0xCC, 0x10);
+        func_8012C218((void *)arg0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8017AE2C", func_80181694);
 
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
index 3036018e0..2872673dd 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
@@ -5421,7 +5421,63 @@ INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017FB4
 
 INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017FBA0);
 
-INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017FC6C);
+#include "common.h"
+
+typedef struct { s16 a, b, c, d; } SV4_FC6C;
+
+extern s32 *D_80126B78;
+extern u8 D_8018BE48[];
+extern u8 D_8018BE50[];
+extern void RotTransSV(void *a0, void *a1, void *a2);
+
+#define SRM_FC6C(r0) __asm__ volatile (              \
+    "lw $12, 0( %0 );"                                   \
+    "lw $13, 4( %0 );"                                   \
+    "ctc2 $12, $0;"                                      \
+    "ctc2 $13, $1;"                                      \
+    "lw $12, 8( %0 );"                                   \
+    "lw $13, 12( %0 );"                                  \
+    "lw $14, 16( %0 );"                                  \
+    "ctc2 $12, $2;"                                      \
+    "ctc2 $13, $3;"                                      \
+    "ctc2 $14, $4"                                       \
+    :                                                    \
+    : "r"( r0 )                                          \
+    : "$12", "$13", "$14" )
+#define STM_FC6C(r0) __asm__ volatile (              \
+    "lw $12, 20( %0 );"                                  \
+    "lw $13, 24( %0 );"                                  \
+    "ctc2 $12, $5;"                                      \
+    "lw $14, 28( %0 );"                                  \
+    "ctc2 $13, $6;"                                      \
+    "ctc2 $14, $7"                                       \
+    :                                                    \
+    : "r"( r0 )                                          \
+    : "$12", "$13", "$14" )
+
+extern u8 *func_8017FD6C(s32 a0, s32 a1, s32 a2);
+
+void func_8017FC6C(s32 s2)
+{
+    SV4_FC6C sv0;   /* sp+0x10 */
+    SV4_FC6C sv1;   /* sp+0x18 */
+    s32 flag;       /* sp+0x20 */
+
+    SRM_FC6C(*(s32 *)((char *)s2 + 0x20) + 0x34);
+    STM_FC6C(*(s32 *)((char *)s2 + 0x20) + 0x34);
+
+    RotTransSV((void *)D_8018BE48, &sv0, &flag);
+    RotTransSV((void *)D_8018BE50, &sv1, &flag);
+
+    func_8017FD6C(*(s16 *)(*(s32 *)((char *)s2 + 0x20) + 0x12), (s32)&sv0, *(s16 *)((char *)s2 + 0xDC));
+    func_8017FD6C(*(s16 *)(*(s32 *)((char *)s2 + 0x20) + 0x12), (s32)&sv1, *(s16 *)((char *)s2 + 0xDC));
+
+    *(u16 *)((char *)s2 + 0xDC) = *(u16 *)((char *)s2 + 0xDC) + 1;
+    if ((s16)*(u16 *)((char *)s2 + 0xDC) >= 3) {
+        *(u16 *)((char *)s2 + 0xDC) = 2;
+    }
+}
+
 
 extern u32 D_8018BD88[];
 extern u8 *func_801290DC(s32 a0, u8 *a1);
diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c b/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
index 87c974186..0da9280ff 100644
--- a/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
+++ b/src/ov_SC03_013/ov_SC03_013_jr_8017C730.c
@@ -3776,7 +3776,47 @@ void func_8017F31C(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_jr_8017C730", func_8017F324);
+extern void (*D_80184EA8)(void);
+extern s32 func_8012C194(void);
+extern s32 func_80024054(u8 *, u8 *);
+extern void func_8001CE28(void *, void *);
+extern void func_8001CE68(void *, void *);
+extern void func_800242D0(s32, void *, s32);
+extern u16 D_800AF7BC;
+extern u16 D_800AF7BE;
+extern u8 D_801AD328[];
+extern u8 D_801AD350[];
+
+void func_8017F324(s32 arg0) {
+    u16 *bc;
+    s32 h;
+    s16 q;
+
+    func_8017F5A4();
+    h = func_8012C194();
+    if (h != 0) {
+        *(s32 *)(arg0 + 0xE0) = h;
+        func_80024054((u8 *)&D_80184EA8, (u8 *)&D_801AD328);
+        func_8001CE28((void *)h, (void *)&D_801AD328);
+        bc = &D_800AF7BC;
+        *(s16 *)(h + 8) = -*bc / 2 + 0x10;
+        *(s16 *)(h + 0xA) = -D_800AF7BE / 2 + 0x18;
+        *(s16 *)(h + 0x2C) = 1;
+        *(u8 *)(h + 0x27) = 1;
+        h = func_8012C194();
+        if (h != 0) {
+            q = (s16)((s16)*(u16 *)(arg0 + 0xFC) / 30);
+            *(s32 *)(arg0 + 0xDC) = h;
+            func_800242D0(q, (void *)&D_801AD350, 2);
+            func_8001CE68((void *)h, (void *)&D_801AD350);
+            *(s16 *)(h + 8) = -*bc / 2 + 0x18;
+            *(s16 *)(h + 0xA) = -D_800AF7BE / 2 + 0x20;
+            *(s16 *)(h + 0x2C) = 1;
+            *(u16 *)(arg0 + 2) += 1;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_jr_8017C730", func_8017F4B4);
 
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
index d7615072a..ff9dcfbdc 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -5877,7 +5877,24 @@ void func_80185984(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_801859CC);
+extern void func_800183E0(s32 a0);
+extern s32 D_80190948[];
+
+void func_801859CC(s32 arg0) {
+    u16 var;
+
+    var = *(u16 *)(arg0 + 0xFC);
+    var = var + 1;
+    *(u16 *)(arg0 + 0xFC) = var;
+    if ((s16)var < 9) {
+        func_800183E0(D_80190948[(s16)var >> 1]);
+    } else {
+        *(s16 *)(arg0 + 2) = 2;
+        *(u8 *)(arg0 + 0xC1) = 0;
+        *(u16 *)(arg0 + 0x5C) = 0x8000;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80185A3C);
 
@@ -7863,7 +7880,37 @@ INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189AF
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189BF0);
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189C90);
+extern void func_800183E0(s32 a0);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern void (*D_80190918[])(void *);
+
+void func_80189C90(s32 arg0)
+{
+    u16 var;
+    s16 cmp;
+    s32 a0;
+
+    var = *(u16 *)(arg0 + 0xFC);
+    if ((s16)var < 13) {
+        func_800183E0((s32)D_80190918[(s16)var >> 1]);
+        cmp = *(s16 *)(arg0 + 0xFC);
+        if (cmp == 5) {
+            if (*(s16 *)(*(s32 *)(arg0 + 0x64) + 0xFC) == 0) {
+                a0 = func_8012C588(*(s16 *)(arg0 + 0xFE), arg0);
+                if (a0 != 0) {
+                    *(s32 *)(a0 + 0x64) = *(s32 *)(arg0 + 0x64);
+                    *(s32 *)(a0 + 4) = *(s32 *)(*(s32 *)(arg0 + 0x64) + 4);
+                    *(s32 *)(a0 + 8) = *(s32 *)(*(s32 *)(arg0 + 0x64) + 8) - 0x40000;
+                    *(s32 *)(a0 + 0xC) = *(s32 *)(*(s32 *)(arg0 + 0x64) + 0xC);
+                    *(s16 *)(*(s32 *)(arg0 + 0x64) + 0xFC) = 8;
+                }
+            }
+        }
+    } else {
+        *(s16 *)(arg0 + 2) = 2;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189D8C);
 
@@ -7873,7 +7920,29 @@ INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189ED
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189F7C);
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_8018A078);
+typedef struct {
+    u8 pad00[2];   /* 0x00 */
+    s16 unk2;      /* 0x02 */
+    u8 pad04[2];   /* 0x04 */
+    s16 unk6;      /* 0x06 */
+    u8 pad08[0x14];/* 0x08 */
+    s32 unk1C;     /* 0x1C */
+    u8 pad20[0xDC];/* 0x20 */
+    u16 unkFC;     /* 0xFC */
+} Struct_8018A078;
+
+extern s32 D_801909A4[];
+extern void func_800183E0(s32 a0);
+
+void func_8018A078(Struct_8018A078 *arg0)
+{
+    func_800183E0(D_801909A4[((s16)arg0->unkFC >> 1) % 6]);
+    arg0->unk6 = arg0->unk6 + 8;
+    if (--arg0->unk1C == 0) {
+        arg0->unk2 = 2;
+    }
+}
+
 
 extern void func_800183E0(s32 a0);
 extern s32 func_8012C588(s32 a0, s32 a1);
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
index af3da3080..730444399 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
@@ -4332,7 +4332,31 @@ INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_801831E
 
 INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_801834A4);
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_8018364C);
+extern s32 rand(void);
+extern s32 func_801850D8();
+extern u8 D_8018E47C[];
+
+void func_8018364C(void *arg0) {
+    s16 sp20[3];
+    s32 i;
+    s32 r;
+    s32 ret;
+
+    sp20[2] = 0;
+    sp20[0] = 0;
+    sp20[1] = -0x120;
+    for (i = 0; i < 10; i++) {
+        r = rand();
+        ret = func_801850D8(6, (s16)(i * 0x200 + 0x3000 + r % 1024), 0, 0, sp20,
+                            (s32)arg0, (s32)D_8018E47C, 0);
+        if (ret != 0) {
+            *(s16 *)(ret + 0x52) = i;
+            r = rand();
+            *(s16 *)(ret + 0x4C) = r % 8;
+        }
+    }
+}
+
 
 void func_8018373C(void *a0, s32 a1)
 {
diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c b/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
index 778d28f16..1d4a08ddf 100644
--- a/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
+++ b/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
@@ -7224,7 +7224,32 @@ s32 func_801826E8(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80182808);
+extern s32 func_80132E6C(s16 *a0);
+extern s32 func_8012B864(s32 a0);
+
+s32 func_80182808(s32 a0) {
+    s32 t;
+    s16 r;
+    s16 sd;
+
+    if (func_80132E6C((s16 *)a0) > 0x23FFF) {
+        return 0;
+    }
+    t = func_8012B864(a0);
+    r = t;
+    sd = t - (*(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) & 0xFFF);
+    if (sd < 0) {
+        sd = -sd;
+    }
+    if (sd < 0x180) {
+        if ((t << 16) == 0) {
+            r = t + 1;
+        }
+        return r;
+    }
+    return 0;
+}
+
 
 extern s32 func_8012C588(s32 a0, s32 a1);
 extern void func_8002D4C8(s32 a0, s32 a1);
@@ -7591,7 +7616,44 @@ void func_80183008(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_801830EC);
+#include "common.h"
+
+extern s32 func_80182564(s32 a0, s32 a1, s32 *a2);
+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 func_8012BEE8(s32 a0);
+extern s32 D_801A86E4;
+extern s32 func_80182808(s32 a0);
+extern void func_80181CE8(void *arg0, s16 a1);
+extern void func_80182BA4(s32 a0, s32 a1);
+
+void func_801830EC(s32 param_1) {
+    s32 out;
+
+    if (func_80182564(param_1, 0xFFFB0000, &out) == 1) {
+        func_8012ADE4((u8 *)param_1);
+        *(s32 *)(param_1 + 0x1C) = 8;
+        func_8012A8B0((u8 *)param_1, (s32)&D_801A86E4);
+        func_8012B23C(param_1);
+        func_8012AD44((s32 *)param_1, 1);
+    } else if (func_8012BEE8(param_1) != 0) {
+        *(s32 *)(param_1 + 0x1C) = 8;
+        func_8012A8B0((u8 *)param_1, (s32)&D_801A86E4);
+        func_8012B23C(param_1);
+        func_8012AD44((s32 *)param_1, 1);
+    } else {
+        if ((*(u16 *)(param_1 + 0x86) & 1) == 0) {
+            s16 r = func_80182808(param_1);
+            if (r != 0) {
+                func_80181CE8((void *)param_1, r);
+            }
+        }
+    }
+    func_80182BA4(param_1, 1);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
index a839d9615..194f9e0bb 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
@@ -7610,7 +7610,40 @@ void func_80186908(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186940);
+#include "common.h"
+
+extern u16 D_801EFD40;
+extern s32 D_801EFC48;
+extern s32 D_801EFD24;
+extern s32 D_801EFD28;
+extern s16 func_80186A20(s32 a0, s32 a1);
+extern void func_80186A68(void);
+extern void func_8016AA50(s32 param_1, s32 param_2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80186940(void *a0, s32 a1, s32 a2) {
+    s16 ret;
+    s16 a2s;
+    s32 msg;
+
+    a2s = a2;
+    D_801EFD40 |= 0x80;
+    ret = func_80186A20(D_801EFC48, (s16)a1);
+    *(u16 *)(D_801EFC48 + 0x60) = *(u16 *)(D_801EFC48 + 0x60) + ret;
+    if (a2s != 0) {
+        func_8016AA50((s32)a0, ret);
+    }
+    *(u16 *)&D_801EFD24 = 8;
+    if (ret != 0) {
+        func_80186A68();
+        msg = 0xBA9;
+        if (*(u16 *)&D_801EFD28 - *(s16 *)(D_801EFC48 + 0x60) > 0) {
+            msg = 0x906;
+        }
+        func_8002D4C8(msg, 0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80186A20);
 
diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c b/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
index 3c5f01d30..d82454354 100644
--- a/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
+++ b/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
@@ -4541,7 +4541,27 @@ INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_8017FBC
 
 INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_8017FC14);
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_8017FC94);
+extern void (*D_8018664C[])(void);
+extern s32 func_80013328(s32 a0, s32 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017FC94(s32 *p) {
+    extern s32 D_80126B58;
+    register s32 *q __asm__("$17");
+
+    D_8018664C[*(u16 *)((s32)p + 0x2)]();
+    q = &D_80126B58;
+    if (p[8] != 0) {
+        s16 v = ((s16 (*)(s32, s32))func_80013328)((s32)p + 4, (s32)(q + 1));
+        if (v >= 0xA01) {
+            *(s32 *)(p[8] + 4) |= 0x80000000;
+        } else {
+            func_8002D4C8(0xA76, (((0xA00 - v) * 0x7F) / 0xA00) & 0xFFFF);
+            *(s32 *)(p[8] + 4) &= 0x7FFFFFFF;
+        }
+    }
+}
+
 
 extern s32 func_8012AD50(void *a0);
     void func_8017FD7C(s32 *a0) {
diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
index c644c081d..c124017c3 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8017D604.c
@@ -3440,7 +3440,60 @@ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017ECE
 
 INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017ED60);
 
-INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8017D604", func_8017EDD0);
+extern void func_80129FF4(void);
+extern void func_801805E0(void);
+extern void func_8013C9C4(void *a0);
+extern s16 func_8012A758(void);
+extern void func_80015978(s32 a0, s32 *a1);
+extern void func_80182CDC(void *a0, void *a1, s32 a2, s32 a3);
+extern void func_8017F818(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F990();
+extern s32 func_80171990(u8 *a0);
+extern u8 D_8018A880[];
+extern u16 D_8018A898[];
+
+void func_8017EDD0(s32 arg0)
+{
+    struct { s16 x, y; } pos;
+    s32 cnt;
+    s16 r;
+    s32 temp;
+
+    if ((*(s32 *)(arg0 + 0x200) >= 0x2BC) && (*(s16 *)(arg0 + 0x20E) == 0)) {
+        *(s16 *)(arg0 + 0x20E) = 1;
+        func_80129FF4();
+        func_801805E0();
+        cnt = 0;
+        func_8013C9C4(D_8018A880);
+        r = func_8012A758() - 0x200;
+        func_80015978(arg0 + 4, (s32 *)&pos);
+        pos.x = pos.x - 0xC0;
+        pos.y = pos.y + 0x80;
+        do {
+            func_80182CDC(&pos, D_8018A898, r, 2);
+            if ((cnt & 1) != 0) {
+                D_8018A898[1] = D_8018A898[1] + 0x30;
+            } else {
+                D_8018A898[1] = D_8018A898[1] - 0x30;
+            }
+            cnt++;
+            r = r + 0x63;
+        } while (cnt < 8);
+    }
+    func_8017F818((void *)arg0, *(s16 *)(arg0 + 0x20C), *(s32 *)(arg0 + 0x200), 0);
+    func_8017F990(arg0, 0);
+    temp = *(s32 *)(arg0 + 0x204) - 0x4000;
+    *(s32 *)(arg0 + 0x204) = temp;
+    if (temp <= 0xFFFF) {
+        *(s32 *)(arg0 + 0x204) = 0x10000;
+    }
+    *(s32 *)(arg0 + 0x200) += *(s16 *)(arg0 + 0x206);
+    if (*(s32 *)(arg0 + 0x200) >= 0x316) {
+        *(s32 *)(arg0 + 0x200) = 0x1E;
+        func_80171990((u8 *)arg0);
+    }
+}
+
 
 extern s32 func_80171990(u8*);
 void func_8017EF54(void *a0) {
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
index 77f30c0d3..1436d97a8 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
@@ -5794,7 +5794,7 @@ void func_80182C30(void *param)
 
 
 
-extern s32 func_80183020(void);
+extern s32 func_80183020();
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern void func_80171928(void *a0);
 
@@ -5828,7 +5828,7 @@ void func_80182CE0(void *a0) {
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182D1C);
 
 
-extern s32 func_80183020(void);
+extern s32 func_80183020();
 extern void func_8002D4C8(s32 a0, s32 a1);
 extern s32 func_80171990(u8*);
 
@@ -5847,7 +5847,24 @@ INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182E6
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80182F44);
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80183020);
+s32 func_80183020(s32 s0) {
+    s32 v0, v1;
+    s32 tmp;
+    v0 = *(s32 *)(s0 + 0x204);
+    v1 = *(s32 *)(v0 + 0x20);
+    if (v0 != 0) {
+        *(u16 *)(v1 + 0x12) = *(u16 *)(v1 + 0x12) + 0x80;
+        func_8012F14C(v1 + 0x34, s0 + 0x20C, &tmp);
+        func_80015954(&tmp, s0 + 0x4);
+    }
+    v1 = *(s32 *)(s0 + 0x20);
+    v0 = *(u16 *)(v1 + 0x12) + 0x80;
+    *(u16 *)(v1 + 0x12) = v0;
+    v0 = *(u16 *)(s0 + 0x208) + 0x80;
+    *(u16 *)(s0 + 0x208) = v0;
+    return !((s16)v0 ^ 0x800);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801830B4);
 
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_801839D0.c b/src/ov_SC06_016/ov_SC06_016_jr_801839D0.c
index 393746a4c..294a344ef 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_801839D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_801839D0.c
@@ -2767,7 +2767,7 @@ extern void func_80182B2C(void);
 extern s32 D_8019A464;
 extern void (*D_8019A47C[])(void);
 extern void func_80182BF4(void *a0);
-extern s32 func_80183020(void);
+extern s32 func_80183020();
 extern void func_80182C78(void *param);
 extern s32 D_8019A484;
 extern void func_80182CB8(void);
diff --git a/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c b/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
index a116656be..36b9a2d3e 100644
--- a/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
+++ b/src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c
@@ -5281,7 +5281,58 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_jr_80187AEC", func_8018B9D4);
+extern u16 D_80126B96;
+extern s16 D_80126B98;
+
+void func_8018B9D4(s32 param_1)
+{
+    struct { u16 a; u16 b; s16 c; u16 d; } t1;
+    struct { u16 a; u16 b; s16 c; u16 d; } t2;
+    s32 r1, r2, r3, r4;
+    s32 pad[2];
+    s32 var_ea;
+    s32 var_fe;
+    s32 var_a0;
+    s32 var_v0;
+    register s32 zr __asm__("$0");
+
+    func_8018BCC4((void *)param_1, 0, (u16 *)(param_1 + 0xE8), 0x81818);
+    func_8018BCC4((void *)param_1, 1, (u16 *)(param_1 + 0xE8), 0x204040);
+    t1.b = 0;
+    t1.a = 0;
+    t1.c = -*(u16 *)(param_1 + 0xE8);
+    t2.b = 0;
+    t2.a = 0;
+    t2.c = -*(u16 *)(param_1 + 0xEA);
+    (void)r1; (void)r2; (void)r3; (void)r4; (void)pad;
+    if (func_8012DEB8(param_1, &t1, &t2) != 0) {
+        D_80126B96 = 0x4018;
+        D_80126B98 = 0x96;
+    }
+    var_ea = *(s16 *)(param_1 + 0xEA);
+    var_fe = *(s16 *)(param_1 + 0xFE);
+    var_a0 = var_ea + zr;
+    if (var_ea < var_fe) {
+        var_v0 = var_a0 + 0x40;
+        *(s16 *)(param_1 + 0xEA) = var_v0;
+        if ((var_v0 << 16) >> 16 >= *(s16 *)(param_1 + 0xFE)) {
+            *(s16 *)(param_1 + 0xEA) = *(s16 *)(param_1 + 0xFE);
+            func_8018BC40(param_1);
+        }
+    } else {
+        var_v0 = *(u16 *)(param_1 + 0xE8) + 0x40;
+        *(u16 *)(param_1 + 0xE8) = var_v0;
+        if ((var_v0 << 16) >> 16 < *(s16 *)(param_1 + 0xFE)) {
+            return;
+        }
+        if (*(s32 *)(param_1 + 0xCC) != 0) {
+            func_80016714((void *)*(s32 *)(param_1 + 0xCC), 0x38);
+        }
+        *(s32 *)(*(s32 *)(param_1 + 0x64) + 0xD0) = 0;
+        func_8012C218((void *)param_1);
+    }
+}
+
 
 extern void func_80016714(void *a0, s32 a1);
 extern void func_8012C218(void *a0);
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
index 4d517cee6..ef621eae0 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
@@ -3838,7 +3838,39 @@ void func_80180AA8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80180B5C);
+#include "common.h"
+
+extern s32 func_80047948(s32 a0);
+extern s32 D_80126B60;
+
+s32 func_80180B5C(s32 arg0)
+{
+    u16 v1 = *(u16 *)((s32)arg0 + 0x34);
+
+    switch (v1) {
+    case 0: {
+        u16 t = *(u16 *)((s32)arg0 + 0xFC);
+        t = t + 0x40;
+        *(u16 *)((s32)arg0 + 0xFC) = t;
+        if ((s16)t >= 0x400) {
+            *(u16 *)((s32)arg0 + 0x34) = *(u16 *)((s32)arg0 + 0x34) + 1;
+        }
+        *(s32 *)((s32)arg0 + 0x8) =
+            *(s32 *)((s32)arg0 + 0x8) -
+            ((0x1000 - func_80047948(*(s16 *)((s32)arg0 + 0xFC))) << 7);
+        break;
+    }
+    case 1:
+        if (D_80126B60 != *(s32 *)((s32)arg0 + 0xDC)) {
+            *(u16 *)((s32)arg0 + 0xA) = *(u16 *)((s32)arg0 + 0xA) - 8;
+        }
+        break;
+    }
+
+    *(s32 *)((s32)arg0 + 0xDC) = D_80126B60;
+    return 0;
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80180C34);
 
diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
index 112917479..1c9f0710b 100644
--- a/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
+++ b/src/ov_SC06_029/ov_SC06_029_jr_8017C954.c
@@ -4677,7 +4677,25 @@ void func_80181C04(s32 param_1)
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80181D40);
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80181D94);
+extern void (*D_80190238[])(void);
+extern void *func_80185C6C();
+extern void func_801856A4(s32 *a0, s32 a1);
+
+void func_80181D94(s32 param_1)
+{
+    s32 iVar1;
+    s32 iVar2;
+
+    iVar1 = (s32)func_80185C6C(*(u16 *)(param_1 + 0x70) & 0xF, 0);
+    iVar2 = 0;
+    do {
+        func_801856A4((s32 *)iVar1, (s32)&D_80190238);
+        *(s8 *)(iVar1 + 6) = (s8)iVar2;
+        iVar2 = iVar2 + 1;
+        iVar1 = iVar1 + 8;
+    } while (iVar2 < 4);
+}
+
 
 INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_80181DF8);
 
@@ -8523,7 +8541,53 @@ void func_8018A5F0(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018A6A4);
+extern void func_8012BEE8(void);
+
+void func_8018A6A4(s32 p) {
+    s32 o;
+    s32 tbl;
+    s32 lim1, lim2;
+    s16 t1, t2, lv1, lv2;
+    s32 pad[3];
+
+    (void)&pad;
+    o = *(s32 *)(p + 0x20);
+    if (*(u16 *)(p + 0x34) == 0) {
+        t1 = *(u16 *)(o + 0x1C) + 0x800;
+        tbl = *(s32 *)(p + 0xDC);
+        *(s16 *)(o + 0x1C) = t1;
+        *(s16 *)(o + 0x18) = t1;
+        lim1 = *(s16 *)tbl;
+        lv1 = lim1;
+        if (lim1 < t1) {
+            *(s16 *)(o + 0x1C) = lv1;
+            *(s16 *)(o + 0x18) = lv1;
+        }
+        t2 = *(u16 *)(o + 0x1A) + 0x800;
+        *(s16 *)(o + 0x1A) = t2;
+        lim2 = *(s16 *)(tbl + 2);
+        lv2 = lim2;
+        if (lim2 < t2) {
+            *(s16 *)(o + 0x1A) = lv2;
+            *(s32 *)(p + 0x1C) = *(s16 *)(tbl + 4);
+            *(u16 *)(p + 0x34) += 1;
+        }
+    } else if (((s32 (*)(void))func_8012BEE8)() != 0) {
+        t1 = *(u16 *)(o + 0x1C) + 0x400;
+        *(s16 *)(o + 0x1C) = t1;
+        *(s16 *)(o + 0x18) = t1;
+        if (t1 >= 0x7001) {
+            *(s16 *)(o + 0x1C) = 0x7000;
+            *(s16 *)(o + 0x18) = 0x7000;
+        }
+        t2 = *(u16 *)(o + 0x1A) + 0x100;
+        *(s16 *)(o + 0x1A) = t2;
+        if (t2 >= 0x7001) {
+            *(s16 *)(o + 0x1A) = 0x7000;
+        }
+    }
+}
+
 
 #include "common.h"
 
@@ -9680,7 +9744,37 @@ void func_8018BE14(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8017C954", func_8018BE68);
+extern u8 D_80062BF4[];
+extern void func_80019064(void *a0);
+extern void func_80149020(s32 *a0);
+extern void func_80147324(s32 a0);
+extern int func_801511E0(int arg);
+extern s32 func_80012A60(s32 a0, s32 a1);
+extern M2C_UNK D_800D5880;
+extern s32 D_800D58AC;
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_80154A74(s32 a0, s32 a1);
+extern void func_80146CA0(void *a0);
+
+void func_8018BE68(s32 param_1)
+{
+    short ret;
+
+    func_80019064(D_80062BF4);
+    func_80149020((s32 *)param_1);
+    func_80147324(0x451);
+    func_801511E0(param_1);
+    ret = func_80012A60(*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12), *(s16 *)(param_1 + 0xF4));
+    if (ret > 0x400) {
+        func_80154274((s32 *)param_1, (s32)&D_800D5880);
+    } else {
+        func_80154274((s32 *)param_1, (s32)&D_800D58AC);
+    }
+    func_80154A74(param_1, 0x16);
+    func_80149020((s32 *)param_1);
+    func_80146CA0((void *)param_1);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
index 362046de5..ebc8f558f 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -4040,13 +4040,57 @@ void func_80180CAC(void) {
 
 INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80180CCC);
 
-extern s32 func_80180DAC(void);
+extern s32 func_80180DAC();
     void func_80180D8C(void) {
         func_80180DAC();
     }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80180DAC);
+typedef struct { s16 m0, m1, m2, m3; } Pos;
+
+extern s16 D_80126940[4];
+extern void func_80180F7C(s32 a0, void *a1);
+
+s32 func_80180DAC(s32 a0)
+{
+    Pos cur;
+    Pos target;
+    s32 ret;
+    s32 dist;
+    s16 clamped;
+    register s16 ang __asm__("$5");
+    register s32 sc __asm__("$2");
+
+    cur = *(Pos *) D_80126940;
+    ret = func_8012E544(0x306);
+    if (ret != 0) {
+        func_80015978(ret + 4, (s32 *) &target);
+        if (cur.m1 > -0x200) {
+            cur.m1 = -0x200;
+        }
+        func_80015978(ret + 4, (s32 *) &target);
+        target.m1 = cur.m1;
+        dist = func_80013294(&cur, &target) - 0x80;
+        clamped = dist;
+        if (clamped < 0) {
+            clamped = 0;
+        }
+        if (clamped > 0x380) {
+            clamped = 0x380;
+        }
+        ang = ((clamped * 111) / 896) - 0x70;
+        *(s16 *) (a0 + 0x30) = ang;
+        sc = ((clamped * 1000) / 896) + 0x190;
+        *(s32 *) (a0 + 0x14) = (s16) sc;
+    } else {
+        target = *(Pos *) D_80126940;
+    }
+
+    cur.m0 = (cur.m0 + target.m0) / 2;
+    cur.m2 = (cur.m2 + target.m2) / 2;
+    func_80180F7C(a0, &cur);
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80180F7C);
 
@@ -4225,7 +4269,63 @@ void func_80181CBC(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80181CF0);
+#include "common.h"
+
+extern s32 func_8004787C(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_801829F0(s32 *a0);
+
+void func_80181CF0(void *a0)
+{
+    s32 s0 = (s32)a0;
+    s32 v;
+    s32 p;
+    s32 q;
+
+    switch (*(u16 *)(s0 + 0x34)) {
+    case 0:
+        *(u16 *)(s0 + 0x100) = *(u16 *)(s0 + 0x100) + 0x40;
+        if (0x80 < *(s32 *)(s0 + 0xE0)) {
+            *(s32 *)(s0 + 0xE0) = *(s32 *)(s0 + 0xE0) - 0x10;
+        }
+        if (0x300 < *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18)) {
+            *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) =
+                *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) - 0x40;
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1A) =
+                *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18);
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1C) =
+                *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18);
+        }
+        if (0x1800 < *(s16 *)(s0 + 0x100)) {
+            *(u16 *)(s0 + 0x34) = *(u16 *)(s0 + 0x34) + 1;
+        }
+        break;
+    case 1:
+        *(u16 *)(s0 + 0x100) = *(u16 *)(s0 + 0x100) + 0x80;
+        *(s32 *)(s0 + 0xE0) = *(s32 *)(s0 + 0xE0) - 4;
+        *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) =
+            *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) - 0x10;
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1A) =
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18);
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1C) =
+            *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18);
+        if (*(s32 *)(s0 + 0xE0) > 0) {
+            break;
+        }
+        func_8012C218((void *)s0);
+        return;
+    }
+    v = *(u16 *)(s0 + 0x104) + 0x30;
+    *(u16 *)(s0 + 0x104) = v;
+    v = func_8004787C((s16)v);
+    *(u16 *)(s0 + 0x102) = v >> 4;
+    func_801829F0((s32 *)s0);
+    p = *(s32 *)(s0 + 0x20);
+    *(u16 *)(p + 0x10) = *(u16 *)(p + 0x10) + *(u16 *)(s0 + 0x106);
+    q = *(s32 *)(s0 + 0x20);
+    *(u16 *)(q + 0x14) = *(u16 *)(q + 0x14) + *(u16 *)(s0 + 0x108);
+}
+
 
 
 extern void (*D_8018A428[])(void);
@@ -4388,7 +4488,12 @@ void func_80182270(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_8018241C);
+void func_8018241C(void *a0) {
+    s16 v = (s16)(*(u16 *)((s32)a0 + 0xE8) + 0x30);
+    *(u16 *)((s32)a0 + 0xE8) = v;
+    *(u16 *)((s32)a0 + 0x52) = func_8004787C(v) >> 8;
+}
+
 
 void func_80182464(void *a0) {
         s32 v0 = *(u16 *)((s32)a0 + 0xA);
diff --git a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
index cdd12d557..900dc4b54 100644
--- a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
+++ b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c
@@ -4540,7 +4540,21 @@ void func_8017E4D0(s32 a0) {
 
 DEFINE_func_8017E518()  /* dedup: shared engine-core @0x8017E518 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E520);
+extern void func_8017E5B8();
+
+void func_8017E520(s32 a0) {
+    s16 t;
+    if (*(s16 *)((s32)a0 + 0xFC) < 6) {
+        t = *(u16 *)((s32)a0 + 0xFE) - 1;
+        *(u16 *)((s32)a0 + 0xFE) = t;
+        if (t == -1) {
+            func_8017E5B8(a0, (*(s16 *)((s32)a0 + 0xFC))++);
+            func_8017E5B8(a0, (*(s16 *)((s32)a0 + 0xFC))++);
+            *(u16 *)((s32)a0 + 0xFE) = 4;
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E5B8);
 
@@ -5033,7 +5047,45 @@ void func_8017FBB8(void) {
 
 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017FBD8);
 
-INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017FC54);
+extern void func_8017FD54(void *a0);
+extern void func_8017FED8(u8 *a0);
+extern void func_8017FF68(s32 a0, void *a1);
+extern u8 D_801A814C[][0x44];
+
+void func_8017FC54(u8 *arg0) {
+    s32 i;
+    u8 *p;
+    s16 kind;
+    s16 t;
+
+    for (i = 0; i < 0x40; i++) {
+        p = D_801A814C[i];
+        kind = *(s16 *)p;
+        switch (kind) {
+        case 0:
+            t = *(u16 *)(p + 2);
+            t = t - 1;
+            *(u16 *)(p + 2) = t;
+            if (t == -1) {
+                *(u16 *)(p + 2) = 0x14;
+                *(u16 *)p = *(u16 *)p + 1;
+            }
+            break;
+        case 1:
+            t = *(u16 *)(p + 2);
+            t = t - 1;
+            *(u16 *)(p + 2) = t;
+            if (t == -1) {
+                func_8017FD54(p);
+            } else {
+                func_8017FF68(arg0, p);
+                func_8017FED8(p);
+            }
+            break;
+        }
+    }
+}
+
 
 void func_8017FD54(void *param_1) {
     extern s32 D_80185C70[];