diff --git a/config/overlays.mk b/config/overlays.mk
index 2a50d1e73..57129e65c 100644
--- a/config/overlays.mk
+++ b/config/overlays.mk
@@ -762,7 +762,7 @@ build/src/ov_SC01_080/ov_SC01_080_jr_80159C84.o: JTBL_PADS := 0,4  # §8e pads (
 build/src/ov_SC01_080/ov_SC01_080_jr_8015AE2C.o: JTBL_PADS := 0,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC01_080/ov_SC01_080_jr_8016AB6C.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC01_080/ov_SC01_080_jr_80178D40.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x178
-build/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x14
+build/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.o: JTBL_PADS := 0,0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x14,+0x34
 build/src/ov_SC01_080/ov_SC01_080_o0c.o: JTBL_PADS := 0,4,4,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x38,+0xa8,+0x118
 ov_SC01_080_CHECK_SHA  := config/check.ov_SC01_080.sha
 ov_SC01_080_SYMBOLS    := config/symbols.ov_SC01_080.txt
diff --git a/config/splat.ov_SC01_080.yaml b/config/splat.ov_SC01_080.yaml
index 5124a5fcc..3a9293234 100644
--- a/config/splat.ov_SC01_080.yaml
+++ b/config/splat.ov_SC01_080.yaml
@@ -161,7 +161,7 @@ segments:
       - [0x9c4b4, .rodata, ov_SC01_080_jr_8017A4AC]  # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
       - [0x9c540, data, tail17]
       - [0x9c544, .rodata, ov_SC01_080_jr_8017AE2C]  # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
-      - [0x9c578, data, tail18]
+      - [0x9c590, data, tail18]
       - [0x9FDF4, bin, trailing]    # final 3 bytes (EOF not 4-aligned; spimdisasm drops a partial word)
   - [0x9FDF7]   # EOF marker = the 0.4.dec byte length
 # @TRAILING@ (above) is replaced by tools/new_overlay.sh: for a non-4-aligned overlay it becomes
diff --git a/src/md_MAIN_019/md_MAIN_019.c b/src/md_MAIN_019/md_MAIN_019.c
index 90244f778..deb26f6b9 100644
--- a/src/md_MAIN_019/md_MAIN_019.c
+++ b/src/md_MAIN_019/md_MAIN_019.c
@@ -149,13 +149,77 @@ void func_800CB4A8(void) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_019/nonmatchings/md_MAIN_019", func_800CB4C8);
+typedef struct { u8 b[8]; } Blk8;
+
+extern void func_80015978(s32 a0, s32 *a1);
+extern void func_80149374(s32 a0, s32 a1);
+extern u8 D_800CC5B0[];
+
+void func_800CB4C8(void *arg0) {
+    s32 s1 = (s32)arg0;
+    s32 off;
+    s32 t;
+    s32 s2;
+    u8 *dst;
+    s32 i;
+
+    s2 = *(s32 *)(s1 + 0x4C);
+    off = *(s32 *)(s1 + 0x50) * 160;
+    dst = D_800CC5B0 + off;
+    func_80015978(s1 + 4, (s32 *)(s1 + 0x10));
+    for (i = 0; i < 20; i++) {
+        *(Blk8 *)dst = *(Blk8 *)(s1 + 0x10);
+        dst += 8;
+    }
+    func_80149374(s2, s1 + 4);
+    t = *(s32 *)(s1 + 0x50);
+    *(u16 *)(s1 + 0x60) = 0;
+    *(u16 *)(s1 + 0x64) = t << 10;
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_019/nonmatchings/md_MAIN_019", func_800CB578);
 
 INCLUDE_ASM("asm/md_MAIN_019/nonmatchings/md_MAIN_019", func_800CB9F8);
 
-INCLUDE_ASM("asm/md_MAIN_019/nonmatchings/md_MAIN_019", func_800CBC0C);
+extern void func_80015978(s32 a0, s32 *a1);
+extern void func_80015954(s32 a0, s32 a1);
+extern void func_80149374(s32 a0, s32 a1);
+extern s32 func_8014C308(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_8014C278(s32 a0, s32 a1, s32 a2);
+extern s32 func_8014C3A4(void *a0, s32 a1, s32 a2, s32 a3);
+extern u8 D_801202A0[];
+extern u8 D_80126720[];
+
+void func_800CBC0C(void *a0) {
+    u8 *r04;
+    u8 *p;
+    s16 buf10[4];
+    s16 buf18[4];
+
+    r04 = (u8 *)a0 + 4;
+    func_80015978((s32)r04, (s32 *)buf18);
+    func_80015954((s32)a0 + 0x10, (s32)r04);
+    *(s16 *)((s32)a0 + 0xA) = 0;
+    func_80149374((s32)a0, (s32)r04);
+    p = D_801202A0;
+    if (p < p + 0x6480) {
+        do {
+            if (func_8014C308((s32)a0, (s32)p, 0x1E, 0x2000) != 0) {
+                if (*(s16 *)(p + 0xAA) == 0) {
+                    if (func_8014C278((s32)a0, (s32)p, 0x40) != 0) {
+                        func_80015978((s32)(p + 4), (s32 *)buf10);
+                        buf10[3] = 0;
+                        func_8014C3A4((void *)a0, (s32)p, 0x1E, (s32)buf10);
+                    }
+                }
+            }
+            p += 0x10C;
+        } while (p < D_80126720);
+    }
+    func_80015954((s32)buf18, (s32)((u8 *)a0 + 4));
+}
+
 
 
 
diff --git a/src/md_MAIN_028/md_MAIN_028.c b/src/md_MAIN_028/md_MAIN_028.c
index 4f506e980..8080c377c 100644
--- a/src/md_MAIN_028/md_MAIN_028.c
+++ b/src/md_MAIN_028/md_MAIN_028.c
@@ -33,7 +33,39 @@ INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB350);
 
 INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB3AC);
 
-INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB484);
+extern u16 D_800B99DA;
+extern s32 func_800CB6D4(s32 a0);
+extern void func_800CB684(s32 a0, s32 a1);
+extern void func_80146CA0(void *a0);
+extern void func_80146E90(s32 *a0, s32 a1);
+extern s32 rand(void);
+
+void func_800CB484(s32 *a0) {
+    u16 *p = *(u16 **)((u8 *)a0 + 0x20);
+    if (*(s32 *)((u8 *)a0 + 0x54) != 0) {
+        if (D_800B99DA & 1) {
+            p[0x15] = 0x100;
+        } else {
+            p[0x15] = 0x120;
+        }
+    }
+    if (func_800CB6D4((s32)a0) != 0) {
+        s16 v = *(u16 *)((u8 *)a0 + 0x18);
+        *(u16 *)((u8 *)a0 + 0x18) = v + 1;
+        if (v >= 4) {
+            func_800CB684((s32)a0, 0x200);
+            func_80146CA0(a0);
+            return;
+        }
+        if (*(s32 *)((u8 *)a0 + 0x54) != 0 && (rand() & 3) == 0) {
+            func_80146E90(a0, 0x20);
+            *(u16 *)((u8 *)a0 + 2) = 3;
+        } else {
+            func_800CB684((s32)a0, 0x80);
+        }
+    }
+}
+
 
 extern s32 func_800CB6D4(s32 a0);
 extern s32 func_800CB600();
diff --git a/src/md_MAIN_031/md_MAIN_031.c b/src/md_MAIN_031/md_MAIN_031.c
index 607df01fc..a506f26a0 100644
--- a/src/md_MAIN_031/md_MAIN_031.c
+++ b/src/md_MAIN_031/md_MAIN_031.c
@@ -73,7 +73,49 @@ void func_800CB0B0(void *arg) {
 
 INCLUDE_ASM("asm/md_MAIN_031/nonmatchings/md_MAIN_031", func_800CB1CC);
 
-INCLUDE_ASM("asm/md_MAIN_031/nonmatchings/md_MAIN_031", func_800CB288);
+void func_800CB288(s32 arg0)
+{
+    s16 sp10[3];
+    s16 sp18[3];
+    u16 temp;
+    u16 cur;
+    register u16 temp2 __asm__("$2");
+    register u16 cur2 __asm__("$3");
+
+    if ((func_80146E98(arg0) == 0) || (!(func_80148800((s32 *) arg0) & 0x20))) {
+        sp10[0] = 0;
+        sp10[1] = 0;
+        sp10[2] = 0;
+        sp18[0] = *(u16 *) (arg0 + 0x234);
+        sp18[2] = *(u16 *) (arg0 + 0x236);
+        sp18[1] = sp18[2];
+        func_800CB428(arg0, sp10, sp18);
+        func_800CB6A0(arg0, sp10, sp18, 1);
+        func_800CB6A0(arg0, sp10, sp18, 0);
+        func_800CB964(arg0, sp10, sp18);
+        if (*(s16 *) (arg0 + 0x236) != 0x10) {
+            temp = *(volatile u16 *) (arg0 + 0x23A) + 0x100;
+            cur = *(volatile u16 *) (arg0 + 0x236) - temp;
+            *(u16 *) (arg0 + 0x236) = cur;
+            *(u16 *) (arg0 + 0x23A) = temp;
+            if ((s16) cur < 0x10) {
+                *(u16 *) (arg0 + 0x236) = 0x10;
+            }
+            return;
+        }
+        temp2 = *(volatile u16 *) (arg0 + 0x238) + 0x200;
+        cur2 = *(volatile u16 *) (arg0 + 0x234) - temp2;
+        *(u16 *) (arg0 + 0x234) = cur2;
+        *(u16 *) (arg0 + 0x238) = temp2;
+        if ((s16) cur2 >= 0) {
+            return;
+        }
+        *(u16 *) (arg0 + 0x234) = 0;
+    }
+    func_80165A78(arg0);
+    func_80159B3C((void *) arg0);
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_031/nonmatchings/md_MAIN_031", func_800CB3B4);
 
diff --git a/src/md_MAIN_045/md_MAIN_045.c b/src/md_MAIN_045/md_MAIN_045.c
index aa47df22e..56b4f62d3 100644
--- a/src/md_MAIN_045/md_MAIN_045.c
+++ b/src/md_MAIN_045/md_MAIN_045.c
@@ -7,7 +7,30 @@ INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCB28);
 
 INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCB78);
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCC54);
+extern void (*D_800CD684[])(void);
+extern s16 D_800CE050;
+extern s32 func_80012ABC(s32, s32, s32);
+extern void func_8014ACC0(s32, s32);
+extern s32 func_80161A00(s32 a0);
+extern void func_80147364(s32 a, s32 b);
+extern void func_800CCE60();
+
+void func_800CCC54(s32 param_1)
+{
+    s32 iVar1;
+    iVar1 = *(s32 *)(param_1 + 0x4C);
+    D_800CD684[*(u16 *)(param_1 + 2)]();
+    *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) &= 0x7FFFFFFF;
+    *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) |= *(s32 *)(*(s32 *)(iVar1 + 0x20) + 4) & 0x80000000;
+    *(u16 *)(param_1 + 0x60) = 0;
+    D_800CE050 = func_80012ABC(D_800CE050, *(s16 *)(*(s32 *)(iVar1 + 0x20) + 0x12), 10);
+    func_8014ACC0(iVar1, 1);
+    if (func_80161A00(iVar1) == 0) {
+        func_80147364(0x4, 0x8E0);
+        ((void (*)(s32))func_800CCE60)(param_1);
+    }
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCD2C);
 
@@ -19,9 +42,41 @@ void func_800CCE60(void) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCE80);
+extern void func_80013F3C(void *a0);
+extern void RotMatrixY(s32 a0, void *a1);
+extern void func_80048D9C(void *a0, void *a1);
+extern void func_80020F34(s32 a0, s32 a1);
+
+void func_800CCE80(void *arg0) {
+    void *s2;
+    void *s1;
+    void *s0;
+    void *p;
+
+    s2 = *(void **)((u8 *)arg0 + 0x4C);
+    p = *(void **)((u8 *)s2 + 0x20);
+    s1 = *(void **)((u8 *)arg0 + 0x20);
+    *(s16 *)((u8 *)arg0 + 0x06) = *(s32 *)((u8 *)p + 0x48);
+    *(s16 *)((u8 *)arg0 + 0x0A) = *(s32 *)((u8 *)p + 0x4C) - 0x20;
+    s0 = (void *)((u8 *)s1 + 0x34);
+    *(s16 *)((u8 *)arg0 + 0x0E) = *(s32 *)((u8 *)p + 0x50);
+    func_80013F3C(s0);
+    RotMatrixY(*(s16 *)((u8 *)s1 + 0x12), s0);
+    func_80048D9C(s0, (void *)((u8 *)*(void **)((u8 *)s2 + 0x20) + 0x34));
+    func_80020F34((s32)s0, (s32)((u8 *)s1 + 0x18));
+    *(u16 *)((u8 *)s1 + 0x2C) |= 1;
+}
+
+
+extern s32 func_8014C088(s32 a0, s32 a1);
+
+void func_800CCF28(s32 a0) {
+    s32 v1 = func_8014C088(a0, 0x10);
+    if (v1 != 0) {
+        *(s16 *)(v1 + 0x60) = 1;
+    }
+}
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCF28);
 
 INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CCF58);
 
@@ -50,7 +105,21 @@ INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD010);
 
 INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD0CC);
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD1A8);
+extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
+extern void func_80162CCC(void);
+
+void func_800CD1A8(void) {
+    register void *a0r __asm__("$4");
+    void *arg0 = a0r;
+
+    func_80146A6C(3, arg0,
+                  *(s16 *)((u8 *)arg0 + 6),
+                  *(s16 *)((u8 *)arg0 + 0xA),
+                  *(s16 *)((u8 *)arg0 + 0xE),
+                  0x8880000, 0x1800A000);
+    ((void (*)(void *))func_80162CCC)(arg0);
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD204);
 
@@ -110,6 +179,21 @@ void func_800CD5BC(void) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_045/nonmatchings/md_MAIN_045", func_800CD5DC);
+extern void func_80013F3C(void *a0);
+extern void func_800126C4(s32 a0, s32 a1);
+extern void func_80012558(s32 a0, s32 a1);
+extern void func_800123F0(s32 a0, s32 a1);
+
+void func_800CD5DC(s32 a0, s32 a1) {
+    s32 q = *(s32 *)(a0 + 0x20);
+    func_80013F3C((void *)a1);
+    func_800126C4((s32)a1, *(s16 *)(a0 + 0x60));
+    func_800123F0((s32)a1, *(s16 *)(a0 + 0x64));
+    func_80012558((s32)a1, *(s16 *)(a0 + 0x62));
+    func_80012558((s32)a1, *(s16 *)(q + 0x12));
+    func_800126C4((s32)a1, *(s16 *)(q + 0x10));
+    func_800123F0((s32)a1, *(s16 *)(q + 0x14));
+}
+
 
 INCLUDE_RODATA("asm/md_MAIN_045/nonmatchings/md_MAIN_045", D_800CCB1C);
diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index c999b0e74..8aa7d74ea 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -305,7 +305,30 @@ void func_801A115C(s32 a0) {
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A11D4);
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A1400);
+extern void func_801A4328(s32 a0);
+extern void func_8017F928(void);
+extern void func_801A36F0(void *a0);
+extern void func_801A34C4(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 D_801EF8A0;
+
+void func_801A1400(s32 *a0)
+{
+    s32 *s0 = a0;
+    u16 v0;
+
+    func_801A4328(4);
+    func_8017F928();
+    func_801A36F0(s0);
+    *(u16 *)((s32)s0 + 0x102) = 0;
+    func_801A34C4((s32)s0);
+    v0 = *(u16 *)((s32)s0 + 0x5C);
+    *(u16 *)((s32)s0 + 0x5C) = v0 & 0xDFFF;
+    func_8012A828((s32)s0, &D_801EF8A0);
+    func_8012AD44(s0, 7);
+}
+
 
 INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A1470);
 
diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8017BE9C.c b/src/ov_SC01_004/ov_SC01_004_jr_8017BE9C.c
index 3a6de7c94..5499f07b0 100644
--- a/src/ov_SC01_004/ov_SC01_004_jr_8017BE9C.c
+++ b/src/ov_SC01_004/ov_SC01_004_jr_8017BE9C.c
@@ -3292,7 +3292,46 @@ s32 func_8017D020(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_jr_8017BE9C", func_8017D060);
+extern s32 func_80029504(void);
+extern s32 func_80029178(s32 arg);
+extern void func_80029124(s32 a0, s32 a1);
+extern void func_80029514(s32 arg0);
+extern void func_8002931C(s32 a0);
+
+extern u16 D_80182DB4;
+extern u8 D_80182D24[];
+extern u8 D_80182D48;
+extern s8 D_80182D6C[];
+extern u8 D_80182D90[];
+extern void (*D_80182C74[])(void);
+
+void *func_8017D060(void) {
+    s32 v;
+    u8 flg;
+
+    v = func_80029504();
+    if ((u32)(v - 0x294) < 10) {
+        return &D_80182DB4;
+    }
+    flg = func_80029178(0xB5);
+    if (flg || v >= 0xA) {
+        if (v >= 0x384) {
+            return &D_80182D90;
+        }
+        if (v >= 0x258) {
+            return &D_80182D6C;
+        }
+        if (v >= 0xC8) {
+            return &D_80182D48;
+        }
+        return &D_80182D24;
+    }
+    func_80029124(0xB5, 1);
+    func_80029514(0xA);
+    func_8002931C(0x21C0000);
+    return &D_80182C74;
+}
+
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017D13C(void) {
diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
index 3ed87bc36..053ba026c 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
@@ -3166,7 +3166,17 @@ void func_8017F6B4(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F6C0);
+extern s32 func_800291B4(s32 arg);
+
+s32 func_8017F6C0(void *a0) {
+    *(s16 *)((char *)a0 + 0x104) = 2;
+    if ((func_800291B4(0x4C) & 0xFF) != 0) {
+        return 0;
+    }
+    *(s16 *)((char *)a0 + 0x104) -= 1;
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F710);
 
@@ -3288,9 +3298,71 @@ extern void func_800D0C48(s32 arg);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FA14);
+void func_8017FA14(s32 a0)
+{
+    extern s32 func_8012C1B8(void);
+    extern void func_8001C214(s32 a0, s32 a1);
+    extern u8 D_801AAEDC[];
+    extern void func_8012A828(s32 a0, void *a1);
+    extern u8 D_801E9088[];
+    extern void func_80143994(s32 a0, s32 a1);
+    extern void func_8017EFC4(s32 a0);
+
+    s16 arr[4];
+    s32 t;
+    s32 c;
+
+    if ((*(s32 *)(a0 + 0x20) = ((s32 (*)(void))func_8012C1B8)()) == 0) {
+        return;
+    }
+    func_8001C214(*(s32 *)(a0 + 0x20), (s32)D_801AAEDC);
+    func_8012A828(a0, &D_801E9088);
+    func_80143994(a0, 0x3000);
+    t = func_80029504();
+    c = func_800291B4(0x3B);
+    if (((u16)(t - 0x2DA) < 0x14) && ((c & 0xFF) < 9)) {
+        *(s16 *)(a0 + 0x102) = 1;
+        func_8017EFC4(a0);
+        arr[0] = 0;
+        arr[1] = -0x82;
+        arr[2] = -0x1F8;
+        arr[3] = 0x800;
+        func_80172310((u8 *)arr);
+        *(s32 *)(a0 + 0x1C) = 0xF;
+    } else {
+        *(s32 *)(a0 + 0x1C) = 2;
+    }
+    *(u16 *)(a0 + 2) += 1;
+}
+
+
+extern s32 D_801E91A8;
+extern s32 D_801E9528;
+
+void func_8017FAFC(s32 param_1) {
+    s32 v0;
+    s16 h;
+
+    v0 = *(s32 *)(param_1 + 0x1C);
+    if (v0 != 0) {
+        *(s32 *)(param_1 + 0x1C) = v0 - 1;
+        return;
+    }
+    if (func_8016F1AC() != 0) {
+        h = *(s16 *)(param_1 + 0x102);
+        if (h == 0) {
+            return;
+        }
+    }
+    h = *(s16 *)(param_1 + 0x102);
+    if (h == 0) {
+        func_80178B18(param_1, (s32)&D_801E91A8);
+    } else {
+        func_80178B18(param_1, (s32)&D_801E9528);
+    }
+    *(u16 *)(param_1 + 2) += 1;
+}
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FAFC);
 
 extern void func_80178CBC(s32 arg0, s32 arg1);
 extern s32 func_801789AC(s32 arg0);
diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c b/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
index fecfcf6a9..d5a7d29c0 100644
--- a/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
+++ b/src/ov_SC01_074/ov_SC01_074_jr_8017BE9C.c
@@ -3326,9 +3326,30 @@ INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D1D
 
 INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D244);
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D2B4);
+void func_8017D2B4(void *a0) {
+    extern void func_8017D364();
+    func_80147AD4((s32)a0, 0, 0, -0x8000);
+    func_801473EC(a0);
+    func_8017D364(a0);
+}
+
+
+extern s32 func_8012E544(s32 arg);
+
+void func_8017D2F8(void *a0, s32 a1) {
+    s32 v0;
+    u32 t;
+
+    v0 = func_8012E544(0x195);
+    if (v0 != 0) {
+        *(s32 *)(v0 + 4) = *(s32 *)((s32)a0 + 4);
+        *(s32 *)(v0 + 8) = *(s32 *)((s32)a0 + 8) - 0x400000;
+        t = *(u32 *)((s32)a0 + 0xC);
+        *(s16 *)(v0 + 0xFC) = (s16)a1;
+        *(s32 *)(v0 + 0xC) = t;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D2F8);
 
 INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D364);
 
@@ -3348,7 +3369,19 @@ void func_8017D424(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D460);
+void func_8017D460(void *a0) {
+    extern void func_8017D98C();
+    func_8014706C(a0);
+    func_8014708C(a0);
+    func_801472C8(a0);
+    *(s32 *)((s32)a0 + 0x200) = 0x316;
+    *(s32 *)((s32)a0 + 0x204) = 0;
+    *(s16 *)((s32)a0 + 0x20C) = 1;
+    func_8017D98C(a0, 1, *(s32 *)((s32)a0 + 0x200), 0);
+    *(s16 *)((s32)a0 + 0x20E) = 30;
+    func_80171990(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D4D0);
 
@@ -3381,7 +3414,25 @@ INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D73
 
 INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D7A4);
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017D80C);
+extern void func_8017D98C(void *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017DB04(void *a0, s32 a1);
+extern void func_8017D918(s32 a0);
+
+void func_8017D80C(s32 a0)
+{
+    func_8017D98C((void *)a0, *(s16 *)(a0 + 0x20C), *(s32 *)(a0 + 0x200), 0);
+    func_8017DB04((void *)a0, 0);
+
+    if ((*(s32 *)(a0 + 0x204) -= 0x4000) < 0x10000)
+        *(s32 *)(a0 + 0x204) = 0x10000;
+    if ((*(s32 *)(a0 + 0x200) += *(s16 *)(a0 + 0x206)) > 0x315) {
+        *(s32 *)(a0 + 0x200) = 0x1E;
+        func_8017D918(a0);
+        func_80147324(0xC25);
+        func_80171990((u8 *)a0);
+    }
+}
+
 
 extern s32 func_80171990(u8 *a0);
     s32 func_8017D8A8(s32 arg0) {
@@ -3527,7 +3578,22 @@ void func_8017DD58(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8017BE9C", func_8017DE0C);
+#include "common.h"
+
+
+
+extern void func_8017DE88(s32 param_1, s16 *param_2);
+extern s16 D_80126940;
+extern s16 D_801274E8;
+
+void func_8017DE0C(s32 param_1) {
+    if (*(s32 *)(param_1 + 0x9C) != 0) {
+        *(Blk8_dd58 *)&D_801274E8 = *(Blk8_dd58 *)&D_80126940;
+        *(s32 *)(param_1 + 0x9C) += -1;
+    }
+    func_8017DE88(param_1, &D_801274E8);
+}
+
 
 
 // @class: schedule
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
index cb6077a73..8d3a7ec85 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
@@ -4767,7 +4767,61 @@ void func_8017EF58(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017EFDC);
+extern s32 func_8016F410(s32 a0);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_80139914(s32 a0);
+extern s32 func_801399F0(s32 a0);
+extern void func_80147060(u8 *a0);
+
+extern u8 D_800D599C[];
+extern u8 D_801894CC[];
+extern u8 D_801895CC[];
+extern u8 D_8018954C[];
+extern u8 D_800D5A34[];
+
+void func_8017EFDC(int param_1) {
+    switch (*(s16 *)(param_1 + 0x20C)) {
+    case 0:
+        if (func_8016F410(0) != 0) {
+            *(u16 *)(param_1 + 0x20C) = *(u16 *)(param_1 + 0x20C) + 1;
+            func_80154274((s32 *)param_1, (s32)&D_800D599C);
+        }
+        break;
+    case 2:
+        if (func_8016F410(1) != 0) {
+            func_80154274((s32 *)param_1, (s32)&D_801894CC);
+            *(u16 *)(param_1 + 0x20E) = 0;
+            *(u16 *)(param_1 + 0x20C) = *(u16 *)(param_1 + 0x20C) + 1;
+        }
+        break;
+    case 3:
+        if (((*(u16 *)(param_1 + 0xB8) & 0x8000) != 0) && (*(s16 *)(param_1 + 0x20E) == 0)) {
+            *(u16 *)(param_1 + 0x20E) = 1;
+            func_80154274((s32 *)param_1, (s32)&D_801895CC);
+        }
+        if (func_8016F410(2) != 0) {
+            func_80154274((s32 *)param_1, (s32)&D_8018954C);
+            *(u16 *)(param_1 + 0x20C) = *(u16 *)(param_1 + 0x20C) + 1;
+        }
+        break;
+    case 1:
+    case 4:
+        if ((*(u16 *)(param_1 + 0xB8) & 0x8000) != 0) {
+            func_80154274((s32 *)param_1, (s32)&D_800D5A34);
+            *(u16 *)(param_1 + 0x20C) = *(u16 *)(param_1 + 0x20C) + 1;
+        }
+        break;
+    case 5:
+        break;
+    }
+
+    if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) {
+        func_80139914(*(s32 *)(param_1 + 0x198));
+        func_80147060((u8 *)param_1);
+        *(u8 *)(param_1 + 0x214) = *(u8 *)(param_1 + 0x214) + 1;
+    }
+}
+
 
 
 // @class: plumbing
@@ -4834,7 +4888,31 @@ void func_8017F268(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017F2A4);
+extern s32 func_80172658(s32 *a0);
+extern s32 ratan2(s32 dx, s32 dy);
+extern void func_80175454(void);
+extern s16 D_80126968;
+extern s16 D_80189664[][4];
+extern s16 D_80189668[][4];
+
+void func_8017F2A4(s32 *param_1)
+{
+    s32 idx;
+    s16 curx;
+    s16 curz;
+
+    if (func_80172658(param_1) != 0) {
+        idx = *(s32 *)((s32)param_1 + 0x218);
+        curx = *(s16 *)((s32)param_1 + 6);
+        curz = *(s16 *)((s32)param_1 + 0xE);
+        *(s16 *)((s32)param_1 + 0x20C) = ratan2(curx - D_80189664[idx][0], curz - D_80189668[idx][0]) & 0xFFF;
+        *(s16 *)((s32)param_1 + 0x20E) = D_80126968;
+        D_80126968 = 0x38E;
+        func_80175454();
+        *(u8 *)((s32)param_1 + 0x214) = *(u8 *)((s32)param_1 + 0x214) + 1;
+    }
+}
+
 
 extern s32 func_80012B04(s32 a0, s32 a1, s32 a2);
 extern s32 func_8013767C(s32 a0);
diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
index 5924c4815..19f76a33e 100644
--- a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
+++ b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c
@@ -3220,7 +3220,25 @@ s32 func_8017D254(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017D294);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8001BFD0(void);
+extern void func_800D0C48(s32 a0);
+extern void func_800D1E28(void);
+
+s32 func_8017D294(u8 *a0) {
+    if (--(*(s32 *)(a0 + 0x28)) == -1) {
+        func_8002D4C8(0x1C, 0);
+        func_8001BFD0();
+        func_8002D4C8(0x1D, 0);
+        func_800D0C48(1);
+        func_800D1E28();
+        func_8002D4C8(4, 0x574);
+        func_8002D4C8(0x20, 0);
+        *(u8 *)(a0 + 0x15) += 1;
+    }
+    return 0;
+}
+
 
 extern s32 func_800D1EBC(void);
     void func_8017D328(void) {
@@ -3680,7 +3698,19 @@ s32 func_8017EE50(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017EE68);
+extern void func_800291F0(s32 a0, s32 a1);
+extern void func_80029514(s32 a0);
+extern void func_80162714(void);
+extern u16 D_80078EAC;
+extern u8 D_80078EB1;
+extern u8 D_80078EB0;
+
+void func_8017EE68(void) {
+    func_800291F0(0, D_80078EAC * 1440 + D_80078EB1 * 60 + D_80078EB0);
+    func_80029514(0x104);
+    func_80162714();
+}
+
 
 extern void func_80029514(s32 arg);
     void func_8017EED8(void) {
diff --git a/src/ov_SC03_014/ov_SC03_014_jr_801848E4.c b/src/ov_SC03_014/ov_SC03_014_jr_801848E4.c
index a42bcdb46..fc181e865 100644
--- a/src/ov_SC03_014/ov_SC03_014_jr_801848E4.c
+++ b/src/ov_SC03_014/ov_SC03_014_jr_801848E4.c
@@ -4062,7 +4062,28 @@ INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_jr_801848E4", func_8018788
 
 INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_jr_801848E4", func_80187A98);
 
-INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_jr_801848E4", func_80187CA8);
+void func_80187CA8(s32 a0) {
+    extern void (*D_801906F8[])(void);
+    extern void (*D_80190700[])(void);
+    extern void (*D_80191848[])(void *);
+    extern s32 D_801EAC80;
+    extern void func_800599B8();
+    extern void func_8012B2CC(s32 a0);
+    extern void func_80185A0C(s32 a0);
+    s32 idx;
+
+    if ((*(s16 *)(a0 + 0x70) == 0) && (D_801EAC80 != 0)) {
+        idx = (*(u16 *)(a0 + 0x100) + 1) & 7;
+        *(u16 *)(a0 + 0x100) = idx;
+        func_800599B8(D_801906F8, D_80190700[idx]);
+    }
+    D_80191848[*(u16 *)(a0 + 2)](a0);
+    if ((*(s16 *)(a0 + 0x70) == 0) && (*(u16 *)(a0 + 2) != 0) && (*(u16 *)(a0 + 2) < 0xD)) {
+        func_8012B2CC(a0);
+        func_80185A0C(a0);
+    }
+}
+
 
 
 extern void (*D_80191890[])(void);
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 0e0d6e485..1a3a0093d 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -8025,7 +8025,37 @@ void func_80189808(s32 arg0)
 
 INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80189904);
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_801899A0);
+void func_801899A0(s32 arg0)
+{
+    extern void func_800183E0(s32);
+    extern u8 D_801D55BC[];
+    extern u8 D_801D55DC[];
+    extern u8 D_80078E78[];
+    u8 *base;
+    s32 a;
+    s32 b;
+    s32 cond;
+
+    base = D_80078E78;
+    if (*(u16 *)(arg0 + 0xFC) & 0xF) {
+        func_800183E0(D_801D55DC);
+    } else {
+        func_800183E0(D_801D55BC);
+    }
+
+    a = *(s16 *)(arg0 + 0xDE);
+    if (a >= 0x564 && (b = *(s16 *)(base + 0x1A)) < 0x3D) {
+        cond = b + 0x5A0 < a;
+    } else {
+        cond = *(s16 *)(arg0 + 0xDE) > *(s16 *)(base + 0x1A);
+    }
+    if (cond == 0) {
+        *(s16 *)(arg0 + 2) = 2;
+        *(u8 *)(arg0 + 0xC1) = 0;
+        *(u16 *)(arg0 + 0x5C) = 0x8000;
+    }
+}
+
 
 void func_80189A54(s32 arg0) {
     s16 var;
diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c b/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
index b1daa2c5e..2d89bdb9a 100644
--- a/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
+++ b/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
@@ -3180,7 +3180,22 @@ void func_8017D960(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_8017D9A0);
+extern int func_8017E30C(int param_1);
+
+void func_8017D9A0(void)
+{
+    extern const void D_80187858;
+    extern void (*const D_801878E4)(void);
+    extern u8 *D_801274C8;
+    extern void *D_801274CC;
+    extern s32 D_8012704C;
+
+    D_801274C8 = (u8 *)&D_80187858;
+    D_801274CC = (void *)&D_801878E4;
+    func_8017E30C(1);
+    D_8012704C = 1;
+}
+
 
 
 extern void (*D_801873AC[])(void);
@@ -3373,9 +3388,27 @@ void func_8017DDB0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_8017DDEC);
+extern void func_8017DE34(void *a0);
+
+void func_8017DDEC(void *param_1)
+{
+    func_80171990(param_1);
+    func_80146994(0x19, (s32)param_1, 0x6960697, 0);
+    func_8017DE34(param_1);
+}
+
+
+extern s32 func_8014C050(s32 arg0, s32 arg1);
+extern void func_80171928(void *a0);
+extern u8 D_800AE6BD;
+
+void func_8017DE34(void *a0) {
+    if (func_8014C050((s32)a0, 0x19) == 0) {
+        D_800AE6BD = D_800AE6BD + 1;
+        func_80171928(a0);
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_8017DE34);
 
 extern void func_8016EE40(s32 a0, s32 a1, s32 a2);
 void func_8017DE88(void) {
@@ -4937,7 +4970,7 @@ INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_801807F
 
 extern code_fn D_8019AA0C[];
 
-extern s32 func_8018095C(s32 a0);
+extern s32 func_8018095C();
 
 void func_80180814(int param_1)
 {
@@ -4962,7 +4995,22 @@ void func_80180918(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_8018095C);
+extern void func_801330E0(void *arg0, s16 *arg1, s32 arg2);
+
+s32 func_8018095C(void *a0)
+{
+    void *v1 = *(void **)((s32)a0 + 0xCC);
+    s16 *dest;
+    if (v1 == NULL) {
+        return;
+    }
+    *(u16 *)((s32)v1 + 0x8) = *(u16 *)((s32)a0 + 0x6);
+    *(u16 *)((s32)v1 + 0xA) = *(u16 *)((s32)a0 + 0xA);
+    *(u16 *)((s32)v1 + 0xC) = *(u16 *)((s32)a0 + 0xE);
+    dest = (s16 *)((s32)v1 + 0x8);
+    func_801330E0(dest, dest, -0x100);
+}
+
 
 typedef struct {
     u16 x, y, z;
@@ -6869,7 +6917,23 @@ void func_80183084(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_80183284);
+extern u16 func_8018330C(void *a0);
+
+void func_80183284(s32 a0)
+{
+    switch (*(s16 *)(a0 + 0x70)) {
+    case 0:
+        func_8002D4C8(0x6D5, 0);
+        break;
+    case 1:
+        func_8002D4C8(0x856, (u16)(func_8018330C((void *)a0) | 0x2000));
+        break;
+    case 2:
+        func_8002D4C8(0x857, (u16)(func_8018330C((void *)a0) | 0x2000));
+        break;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_8018330C);
 
diff --git a/src/ov_SC03_101/ov_SC03_101_jr_801833CC.c b/src/ov_SC03_101/ov_SC03_101_jr_801833CC.c
index 6821983a6..3e2ebe916 100644
--- a/src/ov_SC03_101/ov_SC03_101_jr_801833CC.c
+++ b/src/ov_SC03_101/ov_SC03_101_jr_801833CC.c
@@ -2766,7 +2766,7 @@ extern void func_80180790(void *arg0);
 extern s32 func_80178B18(s32, s32);
 extern void func_801807B8(void *arg0);
 extern code_fn D_8019AA0C[];
-extern s32 func_8018095C(s32 a0);
+extern s32 func_8018095C();
 extern void func_80180814(int param_1);
 extern void (*D_8019AA38[])(void);
 extern void func_80180B10(void *a0);
diff --git a/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c b/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c
index ad435f634..8dff98a82 100644
--- a/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c
+++ b/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c
@@ -3480,7 +3480,14 @@ void func_8017D704(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8017BEBC", func_8017D740);
 
-INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8017BEBC", func_8017D7C8);
+extern s32 D_80182BD0;
+
+void func_8017D7C8(s32 arg0)
+{
+    *(s16 *)(*(s32 *)(*(s32 *)(arg0 + 0x64) + 0xD4) + 0x10A) = -0x7020;
+    *(s32 *)(*(s32 *)(*(s32 *)(arg0 + 0x64) + 0xD4) + 0xF8) = &D_80182BD0;
+}
+
 
 extern void (*D_80182908[])(s32);
 
@@ -3610,7 +3617,34 @@ void func_8017DEA8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8017BEBC", func_8017DEE4);
+extern s32 func_8012C194(void);
+extern void func_8012C098(void *param_1);
+extern s32 func_8012AD50(void *arg0);
+extern void func_800233CC(void *, unsigned short);
+extern void func_8001CD9C(int, void *);
+extern void func_8017E014(s32 a0, s32 a1);
+extern s32 D_801A96B8;
+
+void func_8017DEE4(s32 a0) {
+    s32 var_v0;
+    s32 var_s2;
+
+    var_v0 = func_8012C194();
+    var_s2 = (s32)&D_801A96B8;
+    *(s32 *)(a0 + 0x20) = var_v0;
+    if (var_v0 != 0) {
+        func_8001CD9C(var_v0, (void *)var_s2);
+        *(u16 *)(var_v0 + 0x1A) = 0x3000;
+        *(s32 *)(var_v0 + 4) |= 0x50000000;
+        func_800233CC((void *)var_s2, 0x80);
+        func_8017E014(a0, var_s2);
+        *(u16 *)(a0 + 0x100) = 0;
+        func_8012AD50((void *)a0);
+    } else {
+        func_8012C098((void *)a0);
+    }
+}
+
 
 extern void func_8017E014(s32 a0, s32 a1);
 extern void func_8017E070(s32 a0, s32 a1);
diff --git a/src/ov_SC03_121/ov_SC03_121_jr_8017E1D0.c b/src/ov_SC03_121/ov_SC03_121_jr_8017E1D0.c
index ac5266435..d6d1fac08 100644
--- a/src/ov_SC03_121/ov_SC03_121_jr_8017E1D0.c
+++ b/src/ov_SC03_121/ov_SC03_121_jr_8017E1D0.c
@@ -4068,7 +4068,27 @@ extern void func_8002D4C8(s32 arg0, s32 arg1);
 
 INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_jr_8017E1D0", func_80181908);
 
-INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_jr_8017E1D0", func_801819B8);
+void func_801819B8(s32 arg0) {
+    extern s16 D_8019B9B0;
+    s16 w;
+
+    w = *(u16 *)(arg0 + 0xFC) + 1;
+    *(u16 *)(arg0 + 0xFC) = w;
+
+    *(s16 *)(arg0 + 0xE) = ((w - w * 72) >> 5) + 0x176;
+
+    *(s16 *)(arg0 + 0xA) = (-(*(s16 *)(arg0 + 0xFC) * 109) >> 5) - 0x9E;
+    *(s16 *)(arg0 + 0xA) -= func_8004787C(*(s16 *)(arg0 + 0xFC) << 6) >> 5;
+
+    if (*(s16 *)(arg0 + 0xFC) == 0x20) {
+        *(s16 *)(arg0 + 0x34) = 0;
+        *(u16 *)(arg0 + 2) += 1;
+    }
+    if (*(s16 *)(arg0 + 0xFC) == 0xF) {
+        func_80178B18(arg0, (s32)&D_8019B9B0);
+    }
+}
+
 
 DEFINE_func_80181A98()  /* dedup: shared engine-core @0x80181A98 (src/shared) */
 
diff --git a/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c b/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c
index ae3d72f5a..b7c9c2453 100644
--- a/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c
+++ b/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c
@@ -3486,7 +3486,13 @@ s32 func_8017EE14(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017EE2C);
+extern void (*D_80187C04[])(void);
+
+void func_8017EE2C(void) {
+    func_80029514(0x122);
+    func_800D1724(D_80187C04);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017EE5C);
 
@@ -3643,7 +3649,23 @@ INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017F78
 
 INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017F804);
 
-INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017F87C);
+void func_8017F87C(void *arg0) {
+    extern s32 func_80181DD4(s32 a0);
+    extern void func_8012E8A8(u8 *a0);
+    extern void func_8012E8E0(s32 a0, s32 a1);
+    extern s32 D_80188030;
+    extern s32 D_80188054;
+
+    if (func_80181DD4((s32)arg0) != 0) {
+        *(s16 *)((s32)arg0 + 0x2) = 1;
+        *(s16 *)((s32)arg0 + 0x98) = 0;
+        func_8012E8A8((u8 *)arg0);
+        func_8012E8E0((s32)arg0, (s32)&D_80188030);
+        *(s32 *)((s32)arg0 + 0x58) = (u32)&D_80188054 | 0x40000000;
+        *(s16 *)((s32)arg0 + 0x5C) = 0;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017F8E4);
 
@@ -4312,7 +4334,33 @@ void func_801810C0(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_801810FC);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32, s32);
+extern void func_8012E8E0(s32 a0, s32 a1);
+
+void func_801810FC(s32 param_1)
+{
+    extern u8 D_80188458;
+    extern s32 D_80188448;
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)param_1);
+        return;
+    }
+
+    func_8001C214(v0, 0);
+    func_8012E8E0(param_1, (s32)&D_80188448);
+
+    *(s32 *)(param_1 + 0x58) = 0x40000000 | (s32)&D_80188458;
+    *(s16 *)(param_1 + 0x5C) = 0xC00;
+    *(u16 *)(param_1 + 2) += 1;
+    *(u8 *)(param_1 + 0x75) = 8;
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_80181188);
 
diff --git a/src/ov_SC04_015/ov_SC04_015_jr_8017AE2C.c b/src/ov_SC04_015/ov_SC04_015_jr_8017AE2C.c
index 97acc17b3..8b4bfeb7c 100644
--- a/src/ov_SC04_015/ov_SC04_015_jr_8017AE2C.c
+++ b/src/ov_SC04_015/ov_SC04_015_jr_8017AE2C.c
@@ -5082,9 +5082,79 @@ extern void func_80029124(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_jr_8017AE2C", func_8017FC7C);
+extern void func_80178CBC(s32 arg0, s32 arg1);
+extern void func_80181240(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_80181310(s32 a0);
+extern int func_80178970(void);
+extern void func_80178D18(void);
+
+extern u8 D_801B23A0[];
+extern u8 D_80188A00[];
+
+void func_8017FC7C(s32 a0) {
+    switch (*(u16 *)(a0 + 0x34)) {
+    case 0:
+        if (func_80181310(a0) != 0) {
+            func_80181240(a0, (s32)&D_801B23A0, 0, 0x60);
+        }
+        break;
+    case 1:
+        func_80178CBC(a0, (s32)&D_80188A00);
+        *(u16 *)(a0 + 0x34) = 2;
+        break;
+    case 2:
+        if (((s32 (*)(s32))func_80178970)(a0) != 0) {
+            ((void (*)(s32))func_80178D18)(a0);
+            *(u16 *)(a0 + 0x34) = 0;
+        }
+        break;
+    }
+}
+
+
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C214(s32, s32);
+extern void func_80180FFC(s32);
+extern s32 func_801788B8(s32, s32);
+extern void func_80181240(s32, s32, s32, s32);
+extern void func_8012E8E0(s32, s32);
+extern void func_8012B2CC(s32);
+extern void func_8012E88C(u8 *);
+extern void func_8012A828(s32 *, s32);
+extern s32 func_8017FE08(void *);
+
+extern u8 D_801BC84C[];
+extern void (*D_801889E8[])(void);
+extern s32 D_801B3BE8;
+extern u8 D_801B23A0[];
+
+void func_8017FD40(s32 a0) {
+    s32 v0;
+    s32 v1;
+    s32 ret;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+    }
+
+    func_8001C214(*(s32 *)(a0 + 0x20), (s32)D_801BC84C);
+    func_80180FFC(a0);
+    ret = func_801788B8(a0, (s32)func_8017FE08);
+    v1 = *(s32 *)(a0 + 0x68);
+    *(s32 *)(a0 + 0xD4) = ret;
+    *(s16 *)(a0 + 0x2) = 1;
+    *(s16 *)(a0 + 0x34) = 0;
+    *(s16 *)(v1 + 0xC) = 0x7FFF;
+    func_8012E8E0(a0, (s32)D_801889E8);
+    func_8012B2CC(a0);
+    func_8012E88C((u8 *)a0);
+    func_8012A828((s32 *)a0, (s32)&D_801B3BE8);
+    func_80181240(a0, (s32)D_801B23A0, 0, 0x60);
+}
 
-INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_jr_8017AE2C", func_8017FD40);
 
 extern s32 func_80029178(s32 arg);
 extern s32 func_8012BD14(void);
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 765b3fe5d..35e400c99 100644
--- a/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
+++ b/src/ov_SC05_008/ov_SC05_008_jr_8017AE2C.c
@@ -5424,7 +5424,23 @@ extern s32 func_8012AD50(void *a0);
 
 INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_80181050);
 
-INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_801810D8);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern s32 func_80182334(void);
+extern s32 func_80182478();
+extern s32 func_8012AD50(void *a0);
+
+void func_801810D8(void *arg0) {
+    void *sp0;
+
+    sp0 = arg0;
+    func_80182334();
+    if (func_80182478() + 0x28 == *(s32 *)((s32)sp0 + 0xDC)) {
+        *(s16 *)((s32)sp0 + 0xFE) = 0;
+        func_8002D4C8(0x88F, 0);
+        func_8012AD50(sp0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8017AE2C", func_8018112C);
 
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 9082f2d37..1255c5431 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
@@ -4195,7 +4195,16 @@ void func_80180C34(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_80180C9C);
+extern s32 D_801936E4;
+
+void func_80180C9C(s32 a0)
+{
+    if (func_8012BE54(a0) < 0x6401) {
+        func_80178B18(a0, (s32)&D_801936E4);
+        *(s16 *)(a0 + 2) = 2;
+    }
+}
+
 
 
 extern int func_80178970(void);
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 38264b1ca..0047f4f4d 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -4433,7 +4433,55 @@ void func_8017FAFC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017FB38);
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017FBE8);
+extern void func_8001CD9C(s32, void *);
+extern void func_800233CC(void *, u16);
+typedef struct { u8 b[4]; } __attribute__((packed, aligned(1))) Blk4;
+extern Blk4 D_801CE7A4[];
+extern u8 D_801865C0;
+extern u8 D_801D0678[];
+
+void func_8017FBE8(void *arg0) {
+    s32 mode = *(s16 *)((u8 *)arg0 + 0x2C);
+    u8 *s0 = (u8 *)D_801D0678 + (mode << 6);
+    switch (mode) {
+    case 0:
+        func_8001CD9C(*(s32 *)((u8 *)arg0 + 0x20), s0);
+        func_800233CC(s0, 0x80);
+        *(Blk4 *)s0 = D_801CE7A4[0];
+        *(Blk4 *)(s0 + 4) = D_801CE7A4[0];
+        *(u32 *)(*(s32 *)((u8 *)arg0 + 0x20) + 4) |= 0x60000000;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x18) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x1A) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x2C) = 0xC040;
+        *(u16 *)((u8 *)arg0 + 0x2E) = 1;
+        *(s32 *)((u8 *)arg0 + 0x1C) = 2;
+        *(u16 *)((u8 *)arg0 + 2) = 1;
+        break;
+    case 1:
+        func_8001CD9C(*(s32 *)((u8 *)arg0 + 0x20), s0);
+        func_800233CC(s0, 0x40);
+        *(Blk4 *)s0 = D_801CE7A4[0];
+        *(Blk4 *)(s0 + 4) = D_801CE7A4[0];
+        *(u32 *)(*(s32 *)((u8 *)arg0 + 0x20) + 4) |= 0x50000000;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x18) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x1A) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x2C) = 0xC040;
+        *(u16 *)((u8 *)arg0 + 2) = 3;
+        break;
+    case 2:
+        func_8001CD9C(*(s32 *)((u8 *)arg0 + 0x20), s0);
+        func_800233CC(s0, 0x80);
+        *(Blk4 *)s0 = D_801CE7A4[0];
+        *(Blk4 *)(s0 + 4) = ((Blk4 *)&D_801865C0)[0];
+        *(u32 *)(*(s32 *)((u8 *)arg0 + 0x20) + 4) |= 0x50000000;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x18) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x1A) = 0;
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x2C) = 0xC040;
+        *(u16 *)((u8 *)arg0 + 2) = 4;
+        break;
+    }
+}
+
 
 
 extern void (*D_801865C4[])(void);
diff --git a/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c b/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c
index 104725d1b..b052263c9 100644
--- a/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c
+++ b/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c
@@ -4265,7 +4265,39 @@ void func_8017DD78(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8017BEBC", func_8017DDB4);
 
-INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8017BEBC", func_8017DE9C);
+void func_8017DE9C(void *param_1) {
+    extern void func_8017DFE8();
+    extern void func_8017E01C();
+    extern void func_8017E078();
+
+    s16 w;
+    s32 r;
+
+    func_8017DFE8(param_1);
+    func_8017E01C(param_1);
+    switch (*(u16 *)((s32)param_1 + 0x70) & 0xF) {
+    case 0:
+        w = *(u16 *)((s32)param_1 + 0xFC) + 0x22;
+        *(u16 *)((s32)param_1 + 0xFC) = w;
+        r = func_8004787C(w);
+        if (r < 0) {
+            r += 0xFF;
+        }
+        *(s16 *)((s32)param_1 + 0xA) = *(u16 *)((s32)param_1 + 0x8A) + (r >> 8);
+        break;
+    case 1:
+        w = *(u16 *)((s32)param_1 + 0xFC) + 0x22;
+        *(u16 *)((s32)param_1 + 0xFC) = w;
+        r = func_8004787C(w);
+        if (r < 0) {
+            r += 0xFF;
+        }
+        *(s16 *)((s32)param_1 + 0xA) = *(u16 *)((s32)param_1 + 0x8A) + (r >> 8);
+        func_8017E078(param_1);
+        break;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8017BEBC", func_8017DF70);