diff --git a/config/overlays.mk b/config/overlays.mk
index f1059fb08..1c502a55d 100644
--- a/config/overlays.mk
+++ b/config/overlays.mk
@@ -3195,6 +3195,7 @@ build/src/ov_SC04_007/ov_SC04_007_jr_80159C84.o: JTBL_PADS := 0,4  # §8e pads (
 build/src/ov_SC04_007/ov_SC04_007_jr_8015AE2C.o: JTBL_PADS := 0,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC04_007/ov_SC04_007_jr_8016AB6C.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC04_007/ov_SC04_007_jr_80178D40.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x178
+build/src/ov_SC04_007/ov_SC04_007_jr_8017BEBC.o: JTBL_PADS := 0,0  # §8e pads (jtbl_carve.py) tables=+0x0,+0x20
 build/src/ov_SC04_007/ov_SC04_007_o0c.o: JTBL_PADS := 0,4,4,4  # §8e pads (jtbl_carve.py) tables=+0x0,+0x38,+0xa8,+0x118
 ov_SC04_007_CHECK_SHA  := config/check.ov_SC04_007.sha
 ov_SC04_007_SYMBOLS    := config/symbols.ov_SC04_007.txt
diff --git a/config/splat.md_SC03_136.yaml b/config/splat.md_SC03_136.yaml
index 0779dfe5e..f84e6d345 100644
--- a/config/splat.md_SC03_136.yaml
+++ b/config/splat.md_SC03_136.yaml
@@ -94,7 +94,9 @@ segments:
       # 0x801E25E8 ahead of the code, a 1-word analogue of main's rodata-island (no ld_interleave).
       # - [0x0, rodata, head]
       - [0x0, .rodata, md_SC03_136]      # module-id header (+jtbl/ptr table) — §154-A
+      - [0x14, .rodata, md_SC03_136_jr_801E2CD0]   # §154-A island split (jtbl_carve --island-split)
       - [0x28, c, md_SC03_136]
+      - [0x6e8, c, md_SC03_136_jr_801E2CD0]
       - [0xBEC, data, tail] # data tail: pointer tables + packed data (split iterated)
   - [0x7FC8]   # 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/config/splat.ov_SC04_007.yaml b/config/splat.ov_SC04_007.yaml
index 6d1bc2329..836fa67a4 100644
--- a/config/splat.ov_SC04_007.yaml
+++ b/config/splat.ov_SC04_007.yaml
@@ -163,7 +163,7 @@ segments:
       - [0x8bd34, data, tail17]
       - [0x8bd38, .rodata, ov_SC04_007_jr_8017AE2C]  # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
       - [0x8bd4c, .rodata, ov_SC04_007_jr_8017BEBC]  # Phase-26 §8 jtbl-rodata carve (jtbl_carve.py)
-      - [0x8bd6c, data, tail18]
+      - [0x8bd80, data, tail18]
       - [0x8DA34, bin, trailing]    # final 3 bytes (EOF not 4-aligned; spimdisasm drops a partial word)
   - [0x8DA37]   # 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_SC02_009/md_SC02_009.c b/src/md_SC02_009/md_SC02_009.c
index fdbc15a02..f883235e1 100644
--- a/src/md_SC02_009/md_SC02_009.c
+++ b/src/md_SC02_009/md_SC02_009.c
@@ -72,7 +72,26 @@ void func_801E514C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E51C0);
+void func_801E51C0(s32 a0) {
+    extern void func_801E53E0(s32);
+    extern s32 func_801399F0(s32);
+    extern void func_80139914(s32);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern void func_8017E454(void);
+    extern s32 func_8013767C(s32);
+    extern u8 D_801E5FFC[];
+    extern u8 D_801974DC[];
+
+    func_801E53E0(a0);
+    if (func_801399F0(*(s32 *)(a0 + 0xB0)) != 0) {
+        func_80139914(*(s32 *)(a0 + 0xB0));
+        func_8012A828(a0, D_801E5FFC);
+        func_8017E454();
+        *(s32 *)(a0 + 0xB0) = func_8013767C((s32)D_801974DC);
+        *(u16 *)((s32)a0 + 2) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E5240);
 
@@ -148,9 +167,41 @@ INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E5580);
 
 INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E55F4);
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E5664);
+void func_801E5664(s32 *a0) {
+    s32 *s0 = a0;
+    extern void func_801E590C();
+    extern s32 func_801399F0(s32 a0);
+    extern void func_80139914(s32 a0);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 D_801270C8;
+    extern s32 D_801E63C4;
+
+    func_801E590C(s0);
+    if (func_801399F0(*(s32 *)((u8 *)s0 + 0xB0)) != 0) {
+        func_80139914(*(s32 *)((u8 *)s0 + 0xB0));
+        D_801270C8 = 12;
+        func_8012A828((s32)s0, &D_801E63C4);
+        (*(u16 *)((u8 *)s0 + 2))++;
+    }
+}
+
+
+void func_801E56D8(s32 a0) {
+    extern void func_801E590C();
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 func_8013767C(s32);
+    extern s32 D_801270C8;
+    extern u8 D_80197418[];
+    extern u8 D_801E644C[];
+
+    func_801E590C(a0);
+    if (D_801270C8 == 14) {
+        *(s32 *)((s32)a0 + 0xB0) = func_8013767C((s32)D_80197418);
+        func_8012A828(a0, D_801E644C);
+        *(u16 *)((s32)a0 + 2) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E56D8);
 
 void func_801E5748(s32 *a0) {
     s32 *s0 = a0;
@@ -172,9 +223,36 @@ void func_801E5748(s32 *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E57C4);
+extern s32 MoveImage(void *a0, s32 a1, s32 a2);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801E65E4[];
+
+void func_801E57C4(s32 a0) {
+    s16 rect[4];
+    s32 s0;
+    s32 v0;
+
+    s0 = a0;
+    v0 = *(s32 *)(s0 + 0x1C) - 1;
+    *(s32 *)(s0 + 0x1C) = v0;
+    if (v0 == -1) {
+        rect[0] = 0x328;
+        rect[1] = 0x140;
+        rect[2] = 8;
+        rect[3] = 0x20;
+        MoveImage(rect, 0x32C, 0x1C8);
+        func_8012A828(s0, D_801E65E4);
+        *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1;
+    }
+}
+
+
+void func_801E584C(void *a0) {
+    if (*(s16 *)((s32)a0 + 0x98) == 0) {
+        *(u16 *)((s32)a0 + 0x2) += 1;
+    }
+}
 
-INCLUDE_ASM("asm/md_SC02_009/nonmatchings/md_SC02_009", func_801E584C);
 
 void func_801E5874(void *a0) {
 
diff --git a/src/md_SC03_136/md_SC03_136.c b/src/md_SC03_136/md_SC03_136.c
index da72750ae..33e040ae1 100644
--- a/src/md_SC03_136/md_SC03_136.c
+++ b/src/md_SC03_136/md_SC03_136.c
@@ -229,115 +229,3 @@ void func_801E2B30(s32 param_1, s16 *param_2) {
 s32 func_801E2CC8(void) {
     return 39;
 }
-
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E2CD0);
-
-
-
-void func_801E2E2C(void *a0) {
-
-    extern void (*D_801E3598[])(void);
-    D_801E3598[*(u16 *)((s32)a0 + 0x2)]();
-}
-
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E2E68);
-
-
-
-void func_801E2E78(void) {
-
-    extern s32 D_801EA5AC;
-    D_801EA5AC = 1;
-}
-
-
-
-
-s32 func_801E2E8C(void) {
-
-    extern s32 D_801EA5AC;
-    return D_801EA5AC;
-}
-
-
-
-
-
-extern s32 func_80029178(s32 arg);
-    extern void func_80029124(s32, s32);
-    s32 func_801E2E9C(void) {
-        if ((func_80029178(0x111) & 0xFF) == 0) {
-            ((void (*)(void *, s32))func_80029124)((void *)0x111, 1);
-            return 1;
-        }
-        return 0;
-    }
-
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E2ED8);
-
-extern void func_80029514(int);
-void func_801E2FB4(void) {
-    func_80029514(0x181);
-}
-
-
-extern void func_8018A788(void);
-void func_801E2FD4(void) {
-    func_8018A788();
-}
-
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E2FF4);
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E3080);
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E3098);
-
-INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136", func_801E30C8);
-
-extern s32 D_801BF4F0;
-extern s32 D_801E3280;
-extern s32 D_801E32B0;
-extern s32 D_801EA574;
-extern s32 D_801EA5A4;
-extern s32 D_801EA5A8;
-extern s32 func_80029504(void);
-extern s32 func_8012C1B8(void);
-extern void func_8001C214(s32, s32);
-extern void func_8012A828(s32, s32);
-extern void func_8012CAE4(void *);
-extern void func_8012E8E0(s32, s32);
-extern void func_80178B18(s32, s32);
-
-void func_801E3124(void *a0) {
-    extern s32 D_801EA574;
-    extern s32 D_801BF4F0;
-    extern s32 D_801E3280;
-    extern s32 D_801E32B0;
-    extern s32 D_801EA5A8;
-    extern s32 D_801EA5A4;
-    s32 v0;
-    s32 ptr;
-
-    v0 = func_8012C1B8();
-    *(s32 *)((s32)a0 + 0x20) = v0;
-    if (v0 == 0) {
-        func_8012CAE4(a0);
-    } else {
-        func_8001C214(v0, (s32)&D_801EA574);
-        ptr = *(s32 *)((s32)a0 + 0x68);
-        *(s32 *)&D_801EA5A8 = 0;
-        *(s16 *)(ptr + 0xC) = 0x7FFF;
-        *(s16 *)((s32)a0 + 0x2) = 1;
-        func_8012A828((s32)a0, (s32)&D_801BF4F0);
-        func_8012E8E0((s32)a0, (s32)&D_801E3280);
-        *(s16 *)((s32)a0 + 0x34) = 0;
-        func_80178B18((s32)a0, (s32)&D_801E32B0);
-        v0 = func_80029504();
-        *(s32 *)&D_801EA5A4 = v0;
-    }
-}
-
diff --git a/src/md_SC03_136/md_SC03_136_jr_801E2CD0.c b/src/md_SC03_136/md_SC03_136_jr_801E2CD0.c
new file mode 100644
index 000000000..abee5c164
--- /dev/null
+++ b/src/md_SC03_136/md_SC03_136_jr_801E2CD0.c
@@ -0,0 +1,313 @@
+#include "common.h"
+
+/* ==== Phase-26 §8b carried decl layer (jr_isolate_all.py) ===================
+ * The file-scope decl environment from earlier code regions of this object —
+ * file-local types, col-0 decls, DEFINE_func macro externs, and each earlier
+ * definition's implied prototype (types first, then decls in original order).
+ * Decls emit no code => byte-neutral. See cookbook §8c. */
+typedef struct { u8 c[8]; } Blk8;
+typedef struct { short vx, vy, vz, pad; } SVECTOR;
+typedef struct { short m[3][3]; long t[3]; } MATRIX;
+extern u8 *D_80126B10;
+extern u8 D_801E3230[];
+extern void func_80175414(s32 _arg0);
+void func_800167B8(int);
+extern int func_801E2610(u8 *arg);
+extern s32 func_800167F0(s32 a0);
+extern s32 func_801E2668(void);
+extern void func_8016EDEC(s32 a0, s32 a1, s32 a2);
+extern void func_801E293C(void *arg0);
+extern s32 func_801E268C(s32 param_1);
+extern s32 func_800D1E28(void);
+extern s32 func_8002D4C8(s32, s32);
+extern s32 func_8001BFD0(void);
+extern s32 func_800291B4(s32);
+extern s32 func_80029524(void);
+extern s32 func_800D0C48(s32);
+extern s32 func_801E26D8(s32 param_1);
+extern void func_800D1EBC(void);
+extern void func_801E2778(void);
+extern void func_801E2798(void *a0);
+extern void func_801E27D4(void *a0);
+extern void func_801E2810(void *a0);
+extern void func_80171A1C(void*);
+extern void func_801E284C(void);
+extern s32 func_80171D78(u32, void *);
+extern void func_801E2874(u32 arg0);
+extern s32 func_80014C54(s32, s32, s32);
+extern void func_800D1724(void *);
+extern void func_80171A1C(void *);
+extern void func_801E28DC(void *arg0);
+extern void func_801E2934(void);
+extern void func_801E293C(void *a0);
+extern void func_801E2978(void);
+extern void func_801E2998(u32 arg0);
+extern void func_801E2A00(void);
+extern void func_801E2ACC(void *a0);
+extern s32 func_80012ABC(s32 a0, s32 a1, s32 a2);
+extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2);
+extern void func_80049CAC(s32 a0, s32 a1);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern void func_801E2B30(s32 param_1, s16 *param_2);
+extern s32 func_801E2CC8(void);
+/* ==== end §8b carried decl layer ==== */
+
+
+extern s32 func_801789AC(s32 a0);
+extern void func_80178CBC(s32 a0, s32 a1);
+extern void func_80174438(s32 a0);
+extern void func_80185B88(s32 a0);
+extern s16 func_80185B78(void);
+extern u8 *D_80126B10;
+
+void func_801E2CD0(void *param_1) {
+
+    extern s32 D_801E336C;
+    extern s32 D_801E3384;
+    extern s32 D_801E3308;
+    extern s32 D_801E3580[];
+
+    switch (*(u16 *)((s32)param_1 + 0x34)) {
+    case 0: {
+        s32 v1 = func_801789AC((s32)param_1);
+        switch (v1) {
+        case 1:
+            *(u16 *)((s32)param_1 + 0x34) = 2;
+            func_80185B88(2);
+            break;
+        case 2:
+            func_80178CBC((s32)param_1, (s32)&D_801E336C);
+            *(u16 *)((s32)param_1 + 0x34) = 0;
+            break;
+        case 3:
+            func_80178CBC((s32)param_1, (s32)&D_801E3384);
+            *(u16 *)((s32)param_1 + 0x34) = 3;
+            break;
+        }
+        break;
+    }
+    case 1:
+        break;
+    case 2: {
+        s32 v0 = func_80185B78();
+        if (v0 != 0) {
+            func_80178CBC((s32)param_1, (s32)D_801E3580[v0]);
+            *(u16 *)((s32)param_1 + 0x34) = 4;
+        } else {
+            func_80178CBC((s32)param_1, (s32)&D_801E3308);
+            *(u16 *)((s32)param_1 + 0x34) = 0;
+        }
+        break;
+    }
+    case 3:
+        if (func_801789AC((s32)param_1) != 0) {
+            func_80174438((s32)D_80126B10);
+            *(u16 *)((s32)param_1 + 0x34) = 1;
+        }
+        break;
+    case 4:
+        if (func_801789AC((s32)param_1) != 0) {
+            *(u16 *)((s32)param_1 + 0x34) = 2;
+            func_80185B88(2);
+        }
+        break;
+    }
+}
+
+
+
+
+void func_801E2E2C(void *a0) {
+
+    extern void (*D_801E3598[])(void);
+    D_801E3598[*(u16 *)((s32)a0 + 0x2)]();
+}
+
+
+INCLUDE_ASM("asm/md_SC03_136/nonmatchings/md_SC03_136_jr_801E2CD0", func_801E2E68);
+
+
+
+void func_801E2E78(void) {
+
+    extern s32 D_801EA5AC;
+    D_801EA5AC = 1;
+}
+
+
+
+
+s32 func_801E2E8C(void) {
+
+    extern s32 D_801EA5AC;
+    return D_801EA5AC;
+}
+
+
+
+
+
+extern s32 func_80029178(s32 arg);
+    extern void func_80029124(s32, s32);
+    s32 func_801E2E9C(void) {
+        if ((func_80029178(0x111) & 0xFF) == 0) {
+            ((void (*)(void *, s32))func_80029124)((void *)0x111, 1);
+            return 1;
+        }
+        return 0;
+    }
+
+
+extern s32 func_80029504(void);
+extern s32 func_801844F8(void);
+extern s32 func_8018456C(void);
+extern void func_801845C8(void);
+
+void func_801E2ED8(s32 a0) {
+
+    extern s32 D_801EA5A4;
+    extern s32 D_801E3328[];
+    extern s32 D_801E333C[];
+    extern s32 D_801E3358[];
+
+    s32 v1 = func_80029504();
+
+    if (v1 < 0xC8) {
+        s32 x = D_801EA5A4;
+        s32 idx;
+        if (x < 0x14) {
+            idx = 0;
+        } else if (x < 0x46) {
+            idx = 1;
+        } else if (x < 0x64) {
+            idx = 2;
+        } else if (x < 0x82) {
+            idx = 3;
+        } else {
+            idx = 4;
+        }
+        *(s32 *)(a0 + 0xE4) = D_801E3328[idx];
+    } else if (v1 < 0x384) {
+        s32 v0 = func_801844F8();
+        *(s32 *)(a0 + 0xE4) = D_801E333C[v0];
+    } else {
+        s32 v0 = func_8018456C();
+        *(s32 *)(a0 + 0xE4) = D_801E3358[v0];
+        func_801845C8();
+    }
+}
+
+
+extern void func_80029514(int);
+void func_801E2FB4(void) {
+    func_80029514(0x181);
+}
+
+
+extern void func_8018A788(void);
+void func_801E2FD4(void) {
+    func_8018A788();
+}
+
+
+#include "common.h"
+
+extern s16 D_801E2498;
+extern s32 D_801E256C;
+extern s32 D_801E3488;
+extern void *D_801E34C0[];
+extern void *D_801E34F4[];
+
+void func_801E2FF4(void) {
+    switch (D_801E2498) {
+    case 0:
+        *(s32 *)(*(s32 *)&D_801E256C + 4) = (s32)((void *)&D_801E3488);
+        break;
+    case 1:
+        *(s32 *)(*(s32 *)&D_801E256C + 4) = (s32)D_801E34C0;
+        break;
+    case 2:
+        *(s32 *)(*(s32 *)&D_801E256C + 4) = (s32)D_801E34F4;
+        break;
+    }
+}
+
+
+void func_801E3080(void) {
+    extern s32 D_801E256C;
+    extern s32 D_801E249C;
+    *(s32 *)(D_801E256C + 4) = D_801E249C;
+}
+
+
+void func_801E3098(void) {
+    extern s32 D_801E256C;
+    extern s32 D_801E24A4;
+    extern s32 D_801E24A0;
+    extern s32 D_801E34F0;
+
+    *(s32 *)(*(s32 *)&D_801E256C + 4) = D_801E24A4;
+    D_801E34F0 = D_801E24A0;
+}
+
+
+extern void func_8018A788(void);
+extern s16 D_801E2498;
+extern s32 D_801E256C;
+extern s32 D_801E3488;
+extern s32 D_801E34A8;
+
+void func_801E30C8(void) {
+    func_8018A788();
+    if (D_801E2498 == 0) {
+        *(s32 *)(D_801E256C + 4) = (s32)&D_801E3488;
+    } else {
+        *(s32 *)(D_801E256C + 4) = (s32)&D_801E34A8;
+    }
+}
+
+
+extern s32 D_801BF4F0;
+extern s32 D_801E3280;
+extern s32 D_801E32B0;
+extern s32 D_801EA574;
+extern s32 D_801EA5A4;
+extern s32 D_801EA5A8;
+extern s32 func_80029504(void);
+extern s32 func_8012C1B8(void);
+extern void func_8001C214(s32, s32);
+extern void func_8012A828(s32, s32);
+extern void func_8012CAE4(void *);
+extern void func_8012E8E0(s32, s32);
+extern void func_80178B18(s32, s32);
+
+void func_801E3124(void *a0) {
+    extern s32 D_801EA574;
+    extern s32 D_801BF4F0;
+    extern s32 D_801E3280;
+    extern s32 D_801E32B0;
+    extern s32 D_801EA5A8;
+    extern s32 D_801EA5A4;
+    s32 v0;
+    s32 ptr;
+
+    v0 = func_8012C1B8();
+    *(s32 *)((s32)a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+    } else {
+        func_8001C214(v0, (s32)&D_801EA574);
+        ptr = *(s32 *)((s32)a0 + 0x68);
+        *(s32 *)&D_801EA5A8 = 0;
+        *(s16 *)(ptr + 0xC) = 0x7FFF;
+        *(s16 *)((s32)a0 + 0x2) = 1;
+        func_8012A828((s32)a0, (s32)&D_801BF4F0);
+        func_8012E8E0((s32)a0, (s32)&D_801E3280);
+        *(s16 *)((s32)a0 + 0x34) = 0;
+        func_80178B18((s32)a0, (s32)&D_801E32B0);
+        v0 = func_80029504();
+        *(s32 *)&D_801EA5A4 = v0;
+    }
+}
+
+
diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c
index 8c77034e9..cdf511ca8 100644
--- a/src/md_SC07_004/md_SC07_004.c
+++ b/src/md_SC07_004/md_SC07_004.c
@@ -5978,7 +5978,19 @@ void func_801AC47C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AC54C);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8012C218(void *a0);
+extern void func_801A9B80(s32 *a0, u16 a1, u16 a2);
+extern u8 D_801F8A58;
+
+void func_801AC54C(s32 param_1) {
+    if (func_8012BEE8(param_1) != 0) {
+        func_8012C218((void *)param_1);
+    } else {
+        func_801A9B80(&D_801F8A58, 0x160, 0x157);
+    }
+}
+
 
 #include "common.h"
 
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 24319b18c..450bd601f 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
@@ -3163,7 +3163,17 @@ extern void func_8017D2E0(s32 arg0, s32 arg1);
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F488);
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F4D0);
+extern s32 func_800291B4(s32 arg);
+
+s32 func_8017F4D0(void *a0) {
+    *(s16 *)((char *)a0 + 0x104) = 4;
+    if ((func_800291B4(0x45) & 0xFF) != 0) {
+        return 0;
+    }
+    *(s16 *)((char *)a0 + 0x104) -= 1;
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F520);
 
@@ -3195,7 +3205,13 @@ extern void func_800291A0(s32 arg0, s32 arg1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F67C);
+extern void func_800291A0(s32, s32);
+
+void func_8017F67C(s32 *a0) {
+    func_800291A0(0x3B, 8);
+    *(s16 *)((s32)a0 + 2) = 5;
+}
+
 
 void func_8017F6B4(void *a0) {
         *(short *)((char *)a0 + 0x2) = 0x5;
@@ -3315,7 +3331,14 @@ void func_8017F8D8(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F8E4);
+extern s32 D_801E97C4;
+
+void func_8017F8E4(void *a0) {
+    *(s16 *)((s32)a0 + 0xFA) = -1;
+    *(s32 *)((s32)a0 + 0x1C) = 0;
+    D_801E97C4 = 0;
+}
+
 
 extern s32 ratan2(s32 dx, s32 dy);
 extern void func_80171B10(void *a0);
@@ -3488,7 +3511,65 @@ INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FED
 INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017FFD0);
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_801803E4);
+void func_801803E4(s32 param_1) {
+    extern void func_800183E0(s32 a0);
+    extern s32 rand(void);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 func_80012ABC(s32 a0, s32 a1, s32 a2);
+    extern void (*D_801EFF04)();
+    extern u8 D_801F0154[];
+    extern u8 D_801ECC74[];
+    extern u8 D_801ECCDC[];
+    extern u8 D_801EE8A0[];
+
+    s32 v1;
+    s32 v0;
+    s32 val;
+    s16 h;
+
+    v1 = *(s16 *)(param_1 + 0xF8);
+    if (v1 == 0) {
+        func_800183E0((s32)&D_801EFF04);
+        val = (rand() & 0x1F) + 0x23;
+    } else {
+        if (v1 == 2) {
+            func_800183E0((s32)D_801F0154);
+        }
+        val = *(u16 *)(param_1 + 0xF8) - 1;
+    }
+    *(u16 *)(param_1 + 0xF8) = (u16)val;
+    __asm__ ("" ::: "memory");
+
+    v0 = *(s32 *)(param_1 + 0x64);
+    h = *(s16 *)(v0 + 0xFA);
+    if (h != 0) {
+        *(s16 *)(v0 + 0xFA) = 0;
+        if (h >= 0) {
+            val = h & 0xFFF;
+            if (val != 0) {
+                *(u16 *)(param_1 + 0xFA) = (u16)val;
+            }
+            if ((h & 0x1000) != 0) {
+                func_8012A828(param_1, D_801ECC74);
+            }
+            if ((h & 0x2000) != 0) {
+                func_8012A828(param_1, D_801ECCDC);
+            }
+        } else {
+            func_8012A828(param_1, D_801ECCDC);
+            func_800183E0((s32)&D_801EFF04);
+            *(s32 *)(param_1 + 0xCC) = (s32)D_801EE8A0;
+            *(s32 *)(param_1 + 0x1C) = 0;
+            *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1;
+            return;
+        }
+    }
+
+    *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
+        func_80012ABC(*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12),
+                      *(s16 *)(param_1 + 0xFA), 4);
+}
+
 
 extern void (*D_801EEDBC[])(void);
 
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 9efbf60cc..3e45416e4 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -8072,7 +8072,19 @@ s32 func_80183C2C(s32 param_1, s32 param_2, u32 param_3)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801840C0);
+extern void func_8012F214(s32 a0, s32 a1, s32 a2);
+extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3);
+
+s32 func_801840C0(s32 a0, s32 a1, s32 a2, s32 a3) {
+    s32 sp10[2];
+    s32 sp18[2];
+
+    func_8012F214(a0, a2, (s32)sp10);
+    func_8012F214(a0, a3, (s32)sp18);
+    return func_80135888(*(s32 *)(a1 + 0x20), *(s32 *)(a1 + 0x58),
+                         (s32)sp10, (s32)sp18) != 0;
+}
+
 
 extern void func_80184738(s32 a0);
 extern void func_80188228(void);
diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c
index 380e2debe..58e8888af 100644
--- a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c
+++ b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c
@@ -3308,7 +3308,58 @@ void func_8017EE24(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017EE60);
+extern u16 func_80148800(s32 *a0);
+extern void func_8017EF84(s32 a0, s16 *a1);
+extern s32 D_80126B58;
+extern s16 D_80126940;
+extern s16 D_80126942;
+extern s16 D_80126944;
+extern s16 D_801880B0[];
+
+void func_8017EE60(s32 param_1) {
+    s16 sp10[3];
+
+    if ((func_80148800(&D_80126B58) & 3) != 0) {
+        *(u8 *)(param_1 + 5) = (*(u8 *)(param_1 + 5) + 1) & 1;
+        *(s32 *)(param_1 + 0x14) = D_801880B0[*(u8 *)(param_1 + 5)];
+    }
+    if (D_80126942 < -0x200) {
+        *(s16 *)(param_1 + 0x20) = 0xAA;
+    } else {
+        *(s16 *)(param_1 + 0x20) = 0x18D;
+    }
+    if (D_80126940 < -0x380) {
+        sp10[0] = -0x380;
+    } else if (D_80126940 < 0x2A1) {
+        goto c1mid;
+    } else {
+        sp10[0] = 0x2A0;
+    }
+    goto c1end;
+c1mid:
+    sp10[0] = D_80126940;
+c1end:
+    if (D_80126942 < -0x460) {
+        sp10[1] = -0x460;
+    } else {
+        goto c2mid;
+    }
+    goto c2end;
+c2mid:
+    sp10[1] = D_80126942;
+c2end:
+    if (D_80126944 < -0x13F) {
+        goto c3mid;
+    } else {
+        sp10[2] = -0x140;
+    }
+    goto c3end;
+c3mid:
+    sp10[2] = D_80126944;
+c3end:
+    func_8017EF84(param_1, sp10);
+}
+
 
 
 // @class: schedule
@@ -3361,7 +3412,15 @@ INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017F11
 
 INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017F154);
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017F190);
+extern void func_8012AD44(s32 *a0, s16 a1);
+
+void func_8017F190(s32 a0) {
+    *(u16 *)(a0 + 0xFE) = *(u16 *)(a0 + 6);
+    *(u16 *)(a0 + 0x100) = *(u16 *)(a0 + 0xA);
+    *(u16 *)(a0 + 0x102) = *(u16 *)(a0 + 0xE);
+    func_8012AD44((s32 *)a0, 3);
+}
+
 
 void func_8017F1C8(void *a0) {
     extern void (*D_801880EC[])(void);
@@ -3470,7 +3529,31 @@ void func_8017F33C(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017F434);
+#include "/home/musashi/bfm-decomp/src/shared/engine_core.h"
+
+extern u16 D_80126B5E;
+extern u16 D_80126B62;
+extern u16 D_80126B66;
+extern s32 func_800132BC(s32 a0, s32 a1);
+
+s32 func_8017F434(s32 a0) {
+    SV3_8012CC88 sp10;
+    SV3_8012CC88 sp18;
+    SV3_8012CC88 sp20;
+
+    sp10.vx = D_80126B5E;
+    sp10.vy = D_80126B62;
+    sp10.vz = D_80126B66;
+    sp18.vx = *(u16 *)(a0 + 6);
+    sp18.vy = *(u16 *)(a0 + 0xA);
+    sp18.vz = 0;
+    sp20.vx = D_80126B5E;
+    sp20.vy = D_80126B62;
+    sp20.vz = 0;
+
+    return func_800132BC((s32)&sp18, (s32)&sp20);
+}
+
 
 
 extern void (*D_801880FC[])(void);
@@ -3508,7 +3591,82 @@ void func_8017F880(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_8017F8C0);
+#include "common.h"
+
+
+
+extern void func_8004978C(s16 *a0, void *a1);
+extern void func_8017F228();
+
+void func_8017F8C0(void *a0) {
+    u8 *s0 = (u8 *)a0;
+    MTX_801749C8 mtx;
+    s16 angle[3];
+    s16 vec0[4];
+    s32 flags;
+
+    angle[2] = 0;
+    angle[0] = 0;
+    angle[1] = *(u16 *)(s0 + 0xFC);
+
+    vec0[1] = 0;
+    vec0[0] = 0;
+    vec0[2] = *(u16 *)(s0 + 0xDC);
+
+    mtx.t[0] = *(s16 *)(s0 + 0xFE);
+    mtx.t[1] = *(s16 *)(s0 + 0x100);
+    mtx.t[2] = *(s16 *)(s0 + 0x102);
+
+    func_8004978C(angle, &mtx);
+
+    __asm__ __volatile__(
+        "lw $12, 0(%0)\n"
+        "lw $13, 4(%0)\n"
+        "ctc2 $12, $0\n"
+        "ctc2 $13, $1\n"
+        "lw $12, 8(%0)\n"
+        "lw $13, 12(%0)\n"
+        "lw $14, 16(%0)\n"
+        "ctc2 $12, $2\n"
+        "ctc2 $13, $3\n"
+        "ctc2 $14, $4\n"
+        "lw $12, 20(%0)\n"
+        "lw $13, 24(%0)\n"
+        "ctc2 $12, $5\n"
+        "lw $14, 28(%0)\n"
+        "ctc2 $13, $6\n"
+        "ctc2 $14, $7\n"
+        : : "r"(&mtx) : "$12", "$13", "$14");
+
+    __asm__ __volatile__(
+        "lwc2 $0, 0(%0)\n"
+        "lwc2 $1, 4(%0)\n"
+        "nop\n"
+        "nop\n"
+        "mvmva 1, 0, 0, 0, 0\n"
+        : : "r"(vec0) : "memory");
+
+    __asm__ __volatile__(
+        "swc2 $25, 0(%0)\n"
+        "swc2 $26, 4(%0)\n"
+        "swc2 $27, 8(%0)\n"
+        : : "r"(s0 + 4) : "memory");
+
+    __asm__ __volatile__(
+        "cfc2 $12, $31\n"
+        "nop\n"
+        "sw $12, 0(%0)\n"
+        : : "r"(&flags) : "$12", "memory");
+
+    *(s32 *)(s0 + 4) <<= 16;
+    *(s32 *)(s0 + 8) <<= 16;
+    *(s32 *)(s0 + 0xC) <<= 16;
+
+    *(s16 *)(*(s32 *)(s0 + 0x20) + 0x12) = *(u16 *)(s0 + 0xFC) - 0x400;
+    *(u16 *)(s0 + 0xFC) = *(u16 *)(s0 + 0xFC) + 0x40;
+    func_8017F228(s0);
+}
+
 
 extern void func_8001CD9C(int, void *);
 extern void func_800233CC(void *, unsigned short);
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 91b55f661..12d2880a9 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -8003,7 +8003,40 @@ void func_8018911C(void *a0)
 void func_80189234(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_8018923C);
+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);
+
+void func_8018923C(void *a0)
+{
+    register void *s0 __asm__("$16");
+    s32 v0;
+
+    s0 = a0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)s0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(s0);
+    } else {
+        extern u8 D_801906D0;
+        extern u8 D_801906F4;
+        s16 t;
+
+        func_8001CA1C(v0, (s32)&D_801906D0);
+        func_8012A828((s32)s0, &D_801906F4);
+        *(s16 *)((s32)s0 + 0x2) = 1;
+
+        t = 0x1800;
+        *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x18) = t;
+        *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x1A) = t;
+        *(s16 *)(*(s32 *)((s32)s0 + 0x20) + 0x1C) = t;
+
+        *(u16 *)(*(s32 *)((s32)s0 + 0x20) + 0x2C) |= 0x10;
+    }
+}
+
 
 void func_801892E0(s32 arg0) {
     s16 var;
diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c b/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
index 995736627..5dd11d862 100644
--- a/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
+++ b/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
@@ -3658,7 +3658,26 @@ void func_8017FE54(void *arg)
 void func_8017FF18(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017FF20);
+extern u8 D_801202A0[];
+extern void func_8013C9C4(void *a0);
+extern u8 D_801862AC[];
+
+void func_8017FF20(void *a0) {
+    u8 *p = D_801202A0;
+    s32 i;
+
+    for (i = 0; i < 0x60; i++) {
+        if (*(u16 *)p == 0xE5) {
+            *(s16 *)((s32)p + 0xFC) = (s32)a0 + 1;
+        }
+        p += 0x10C;
+    }
+
+    if (a0 == NULL) {
+        func_8013C9C4(&D_801862AC);
+    }
+}
+
 
 
 extern void (*D_80186434[])(void);
@@ -3670,7 +3689,13 @@ void func_8017FF88(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017FFC4);
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_80180008);
+extern void (*D_801864FC[])(void);
+
+void func_80180008(void *a0) {
+    *(u16 *)((s32)a0 + 0xFC) = *(u16 *)((s32)a0 + 0xFC) + 1;
+    D_801864FC[*(u16 *)((s32)a0 + 2)]();
+}
+
 
 extern void (*D_80186560[])(void);
 
@@ -3767,7 +3792,32 @@ INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_801802E
 
 INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_801803AC);
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8018043C);
+extern void func_800183E0(s32 a0);
+extern void (*D_80186478[])(void *);
+extern s32 D_801A46CC;
+
+void func_8018043C(void *a0)
+{
+    s32 v1;
+    u16 h;
+
+    v1 = *(s32 *)(*(u32 *)((u8 *)a0 + 0x64) + 0xDC);
+    switch (v1) {
+    case 0:
+        func_800183E0((s32)&D_801A46CC);
+        break;
+    case 1:
+        h = *(u16 *)((u8 *)a0 + 0xFC);
+        func_800183E0(*(s32 *)((u8 *)D_80186478 + ((h << 1) & 0x1C)));
+        break;
+    case 2:
+        *(u16 *)((u8 *)a0 + 2) = 3;
+        *(u16 *)((u8 *)a0 + 0xFC) = 0;
+        *(s32 *)(*(u32 *)((u8 *)a0 + 0x64) + 0xDC) = 0;
+        break;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_801804EC);
 
@@ -4205,7 +4255,65 @@ int param_1;
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_801813F8);
+void func_801813F8(void *a0) {
+    extern s32 func_8012BEE8(s32 a0);
+    extern s32 func_8012B8E4(s32 a0, s32 a1);
+    extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+    extern void func_8012A828(s32*, s32);
+    extern u8 D_801B6EC4[];
+    extern u8 D_801BEF74[];
+    extern u8 D_801BF42C[];
+    extern short D_801BF01C;
+    s32 base = (s32)a0;
+    s32 ptr;
+    s32 ret;
+
+    switch (*(u16 *)(base + 0x34)) {
+    case 0:
+        if (*(s32 *)(base + 0x1C) == 7) {
+            func_8012D5E4(base, (s32)D_801B6EC4, (s32)D_801B6EC4 + 8, 0xB);
+        }
+        break;
+    case 1:
+        ret = func_8012B8E4(base, 6);
+        ptr = *(s32 *)(base + 0x20);
+        *(u16 *)(ptr + 0x12) += ret;
+        break;
+    case 2:
+        if (*(s32 *)(base + 0x1C) == 0xA) {
+            func_8012D5E4(base, (s32)D_801B6EC4, (s32)D_801B6EC4 + 8, 0xB);
+        }
+        break;
+    }
+
+    if (func_8012BEE8(base) == 0) {
+        return;
+    }
+
+    switch (*(u16 *)(base + 0x34)) {
+    case 0:
+        if (func_8012BD3C(base, 0x400, 0x4000) == 0) {
+            goto state_off;
+        }
+        *(u16 *)(base + 0x34) = 1;
+        func_8012A828((s32 *)base, (s32)D_801BEF74);
+        *(s32 *)(base + 0x1C) = 0xA;
+        break;
+    case 1:
+        *(u16 *)(base + 0x34) = 2;
+        *(s32 *)(base + 0x1C) = 0x18;
+        func_8012A828((s32 *)base, (s32)D_801BF42C);
+        break;
+    case 2:
+    state_off:
+        *(u16 *)(base + 0x2) = 2;
+        *(u16 *)(base + 0x34) = 0;
+        func_8012A828((s32 *)base, (s32)&D_801BF01C);
+        break;
+    }
+}
+
 
 void func_8018156C(void *a0) {
     extern u8 D_801B6ED8[];
diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c b/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
index b2b8e4914..2dd999f5e 100644
--- a/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
+++ b/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
@@ -3411,7 +3411,24 @@ void func_8017D374(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017D3B0);
+typedef struct {
+    s16 v[4];
+} Blk8_80126940_8017D3B0;
+
+extern void func_8017D420(s32 param_1, s16 *param_2);
+
+void func_8017D3B0(s32 a0) {
+    extern Blk8_80126940_8017D3B0 D_80126940;
+    Blk8_80126940_8017D3B0 sp10;
+
+    sp10 = D_80126940;
+    if (sp10.v[0] < -0x170) {
+        sp10.v[0] = -0x170;
+    }
+    sp10.v[2] = -0x20;
+    func_8017D420(a0, sp10.v);
+}
+
 
 
 // @class: schedule
@@ -3516,7 +3533,59 @@ void func_8017D7BC(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017D7CC);
+typedef struct {
+    s8 pad00[0x02];
+    u16 f002;
+    s8 pad04[0x1C];
+    s32 *f020;
+    s8 pad24[0x4C];
+    s16 f070;
+    s8 pad72[0x4E];
+    u8 f0C0;
+} Obj_8017D7CC;
+
+void func_8017D7CC(s32 a0) {
+    extern s32 func_8012C1B8();
+    extern void func_8001CA1C(s32 a0, s32 a1);
+    extern void (*D_80183F48[][2])(void);
+    extern s32 func_80029504(void);
+    extern void func_8012C218(void *a0);
+    extern void func_8012CAE4(void *a0);
+    extern s32 func_800291B4(s32 a0);
+    extern void func_8012B2CC(s32 a0);
+    extern void func_8012A828(s32 *a0, s32 a1);
+    extern void (*D_80183F70[][2])(void);
+    extern s32 func_801788B8(s32 a0, s32 a1);
+    extern void func_8017D9C4(void);
+
+    Obj_8017D7CC *obj = (Obj_8017D7CC *)a0;
+    s32 v0;
+
+    v0 = func_8012C1B8();
+    obj->f020 = (s32 *)v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+        return;
+    }
+    func_8001CA1C(v0, (s32)D_80183F48);
+    if ((u32)func_80029504() >= 0x294) {
+        func_8012C218((void *)a0);
+        return;
+    }
+    v0 = func_800291B4(0xDE);
+    if ((v0 & 0xFF) == obj->f070) {
+        obj->f070 = 0;
+        ((s32 *)obj->f020)[1] |= (s32)0x80000000;
+        func_8012B2CC((s32)a0);
+    }
+    func_8012A828((s32 *)a0, (s32)&D_80183F70[obj->f070]);
+    obj->f0C0 = 1;
+    obj->f002 = 1;
+    if ((u32)func_80029504() >= 0x280) {
+        func_801788B8((s32)a0, (s32)func_8017D9C4);
+    }
+}
+
 
 void func_8017D8C0(void) {
 }
@@ -3709,7 +3778,39 @@ void func_8017DCEC(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017DDB0);
+extern s32 func_8012BD3C(s32 a0, s32 a1, s32 a2);
+extern s32 func_8012BCCC(s32 a0);
+extern s32 func_8012B8E4(s32 a0, s32 a1);
+extern s32 func_8012B608(s32 a0, s32 a1, s32 a2);
+extern void func_8012B178(s32 a0, s32 a1);
+extern s32 func_8017EE7C(s32 a0, s32 a1);
+extern s32 func_8017EC80(s32 a0);
+extern s32 func_8012BEE8(s32 a0);
+extern void func_8017EBD8(s32 a0);
+
+void func_8017DDB0(s32 a0) {
+    if (func_8012BD3C(a0, 0x400, 0x20000) == 1) {
+        if (func_8012BCCC(a0) < 0x3001) {
+            *(s16 *)(a0 + 2) = 8;
+            return;
+        }
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 8);
+    } else {
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =
+            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) +
+            func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),
+                          *(s32 *)(a0 + 0xE0), 0xA);
+    }
+    func_8012B178(a0, *(s32 *)(a0 + 0xE8));
+    func_8017EE7C(a0, 0);
+    if (func_8017EC80(a0) != 0) {
+        if (func_8012BEE8(a0) != 0) {
+            func_8017EBD8(a0);
+        }
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017DE88);
 
@@ -3822,7 +3923,28 @@ void func_8017E0D8(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017E190);
+extern s32 func_8012B8E4(s32 arg0, s32 arg1);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_8017E190(s32 arg0)
+{
+    s32 v;
+
+    if ((*(s32 *)(arg0 + 0xDC) & 8) != 0) {
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) += 0x44;
+    } else {
+        v = func_8012B8E4(arg0, 8);
+        *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x12) += v;
+        if (v == 0) {
+            goto store5;
+        }
+    }
+    if (func_8012BEE8(arg0) != 0) {
+store5:
+        *(u16 *)(arg0 + 2) = 5;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017E220);
 
diff --git a/src/ov_SC03_124/ov_SC03_124_jr_80181B44.c b/src/ov_SC03_124/ov_SC03_124_jr_80181B44.c
index f320f5b72..cc736a132 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_80181B44.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_80181B44.c
@@ -2992,7 +2992,23 @@ void func_80181E88(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_80181EC4);
+extern s32 func_801842D4(s32 arg0, s32 arg1);
+extern u8 D_80078EBA;
+extern void func_80181E7C(void *a0);
+
+void func_80181EC4(void *a0) {
+    s32 v0;
+    *(s32 *)(*(s32 *)((s32)a0 + 0xcc) + 0xb0) = 1;
+    if (D_80078EBA == 3) {
+        v0 = 0;
+    } else {
+        v0 = func_801842D4(7, 0x13) != 0;
+    }
+    if (v0 == 0) {
+        func_80181E7C(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_80181F2C);
 
@@ -3038,7 +3054,25 @@ INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_8018209
 
 INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_801820DC);
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_8018211C);
+extern s32 func_8012E57C(s32 arg0, s32 arg1);
+extern s32 func_80182044(void);
+
+void func_8018211C(void *a0) {
+    s32 v0;
+
+    v0 = func_8012E57C(0x61, 0xC);
+    *(s32 *)((char *)a0 + 0xCC) = v0;
+    v0 = func_80182044();
+
+    if (v0 != 0) {
+        v0 = 1;
+    } else {
+        v0 = 2;
+    }
+
+    *(s16 *)((char *)a0 + 0x2) = v0;
+}
+
 
 void func_80182164(void *a0) {
         M2C_FIELD(a0, s16 *, 0x2) = 2;
@@ -3102,7 +3136,32 @@ INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_8018242
 
 INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_80182488);
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_801824DC);
+void func_801824DC(s32 a0, s32 a1)
+{
+    extern u8 D_8019066C[];
+    extern u16 D_800B99DA;
+    extern void func_80182598(u16 *a0, s32 a1);
+    s32 var_v1;
+    s32 var_v0;
+    s32 val;
+
+    var_v1 = (D_8019066C[D_800B99DA & 0xF] == 0) ? 0x60 : 0x50;
+    a1 += 1;
+    var_v1 = var_v1 * a1 / 32;
+    var_v0 = var_v1 / 2;
+    *(s8 *)&val = var_v1;
+    *((s8 *)&val + 1) = var_v1;
+    *((s8 *)&val + 2) = var_v0;
+    *((s8 *)&val + 3) = 0;
+
+    if (*(s16 *)(a0 + 6) != -1) {
+        do {
+            func_80182598(a0, val);
+            a0 += 8;
+        } while (*(s16 *)(a0 + 6) != -1);
+    }
+}
+
 
 
 /* func_80182598 (ov_SC04_018, ov_SC04_018_jr_8017AE2C) — MATCH (250 ins)
@@ -3792,7 +3851,30 @@ void func_80183454(u8 *arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_80183570);
+extern void func_8012AD80(s32 a0);
+extern s32 func_80128ED8(s32 param_1, s32 *param_2);
+extern void func_80016714(void *a0, s32 a1);
+extern void func_8012C218(void *a0);
+extern s32 func_8012BEE8(s32 a0);
+
+void func_80183570(s32 a0) {
+    s32 owner = *(s32 *)(a0 + 0xCC);
+    s32 obj;
+
+    func_8012AD80(a0);
+    obj = *(s32 *)(a0 + 0xCC);
+    *(u16 *)(obj + 8) = *(u16 *)(a0 + 6);
+    *(u16 *)(obj + 0xA) = *(u16 *)(a0 + 0xA);
+    *(u16 *)(obj + 0xC) = *(u16 *)(a0 + 0xE);
+    if ((*(u32 *)(a0 + 0x1C) & 7) == 0) {
+        func_80128ED8(owner, (s32 *)(a0 + 0xD0));
+    }
+    if (func_8012BEE8(a0) != 0) {
+        func_80016714((void *)owner, 0x38);
+        func_8012C218((void *)a0);
+    }
+}
+
 
 
 extern void func_8012B414(int a0);
@@ -3827,9 +3909,60 @@ extern void func_8012B414(int a0);
 
 INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_801836B8);
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_80183700);
+extern s32 func_80029504(void);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void func_8001D0E8(s32 a0, s32 a1, s32 a2);
+extern void func_8012E8E0(s32 a0, s32 a1);
+extern s32 D_801943AC[];
+extern s32 D_801906C8[];
+
+void func_80183700(s32 a0) {
+    s32 v0;
+    if ((u32)(func_80029504() - 0x181) < 0x55) {
+        func_8012CAE4((void *)a0);
+        return;
+    }
+    *(s32 *)(a0 + 0x20) = v0 = ((s32 (*)(void))func_8012C1B8)();
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+        return;
+    }
+    func_8001C810(v0, (s32)D_801943AC);
+    *(s32 *)(*(s32 *)(a0 + 0x20) + 4) |= 0x8000;
+    func_8001D0E8(*(s32 *)(a0 + 0x20), 0x7FFF, 0x7FFF);
+    func_8012E8E0(a0, (s32)D_801906C8);
+    *(s16 *)(a0 + 0x2) = 1;
+    return;
+}
+
+
+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_801837A4(s32 a0) {
+    extern s32 D_801948AC[];
+    extern s32 D_801906D8[];
+    s32 v0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)(a0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)a0);
+    } else {
+        func_8001C214(v0, (s32)D_801948AC);
+        func_8012E8E0(a0, (s32)D_801906D8);
+        *(s16 *)(a0 + 0x2) = 1;
+        *(s16 *)(a0 + 0x34) = 0;
+        *(s32 *)(a0 + 0xDC) = 0;
+        *(s32 *)(a0 + 0xE0) = 0;
+        *(s32 *)(a0 + 0xE4) = 0;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80181B44", func_801837A4);
 
 
 extern void (*D_80190700[])(void);
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 7b81e7556..71a3a280d 100644
--- a/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
+++ b/src/ov_SC04_002/ov_SC04_002_jr_8017BEBC.c
@@ -7097,7 +7097,41 @@ void func_80182424(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_801824A4);
+#include "common.h"
+
+extern void func_8012CBF4(s32 a0);
+extern void func_801319E0(s32 a0);
+extern s32 func_801826E8(s32 a0);
+extern s32 func_80182CBC(s32 a0, void *a1);
+extern void func_8012ADE4(u8 *a0);
+extern void func_80131E00(void *a0, s32 a1);
+extern void func_80131C78(s32 a0);
+
+void func_801824A4(s32 param_1) {
+    s32 flag;
+    s32 hit;
+
+    flag = ((s32 (*)(s32))func_8012CBF4)(param_1);
+    if ((flag & 0xFF) == 0x1A) {
+        func_801319E0(param_1);
+        return;
+    }
+    hit = func_801826E8(param_1);
+    if (hit != 0) {
+        func_80182CBC(param_1, hit);
+        func_8012ADE4((u8 *)param_1);
+    } else if (flag != 0x2000) {
+        func_8012ADE4((u8 *)param_1);
+    }
+    if (*(s16 *)(param_1 + 0x98) == 0) {
+        if (*(s16 *)(param_1 + 0x76) <= 0) {
+            func_80131E00((void *)param_1, 6);
+        } else {
+            func_80131C78(param_1);
+        }
+    }
+}
+
 
 extern s32 D_801A86E4;
 extern s32 func_801826E8(s32 arg0);
@@ -7986,7 +8020,17 @@ INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_8018379
 
 INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80183820);
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80183904);
+s32 func_80183904(s16 *a0, s16 *a1, s32 a2) {
+    s32 d;
+
+    d = a1[1] - a0[3];
+    if (d < 0) d = -d;
+    if (d > (a2 & 0xFFFF)) return 0;
+    d = a1[5] - a0[7];
+    if (d < 0) d = -d;
+    return d <= (a2 & 0xFFFF);
+}
+
 
 
 
@@ -8079,7 +8123,44 @@ void func_80183C54(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80183D94);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern void func_801835E0(s32 a0);
+extern void func_80183614(s32 a0);
+extern void func_80143994(s32 a0, s32 a1);
+extern s32 D_801A1F34;
+extern void (*D_801C16BC)(void);
+
+void func_80183D94(void *param_1) {
+    s32 v0;
+    s32 v1;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)param_1 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4(param_1);
+        return;
+    }
+
+    func_8001C810(v0, (s32)&D_801C16BC);
+
+    *(u16 *)(*(s32 *)((s32)param_1 + 0x20) + 0x2C) |= 0x10;
+    *(s32 *)(*(s32 *)((s32)param_1 + 0x20) + 0x4) |= 0x8040;
+
+    *(u16 *)((s32)param_1 + 0x5C) = 0xCC00;
+    *(u8 *)((s32)param_1 + 0x75) = 2;
+
+    *(s32 *)((s32)param_1 + 0x58) = (s32)&D_801A1F34 | 0x20000000;
+    if (*(s16 *)((s32)param_1 + 0x70) != 0) {
+        func_80183614((s32)param_1);
+        return;
+    }
+    func_801835E0((s32)param_1);
+    v1 = ((s32 (*)(s32, s32))func_80143994)((s32)param_1, 0x3000);
+    *(s32 *)((s32)param_1 + 0xD0) = v1;
+}
+
 
 extern void func_8012CBF4(s32 a0);
 extern void func_8012C218(void *a0);
@@ -9313,7 +9394,16 @@ tail_short:
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8017BEBC", func_80185A68);
+extern void func_8012B23C(s32 a0);
+extern void func_8012A828(s32 a0, void *a1);
+extern u8 D_801BE120[];
+
+void func_80185A68(s32 a0) {
+    func_8012B23C(a0);
+    func_8012A828(a0, &D_801BE120);
+    *(s16 *)((char *)a0 + 0x2) = 0xA;
+}
+
 
 extern void func_8012CBCC(s32 a0);
     void func_80185AA8(void *a0) {
diff --git a/src/ov_SC04_007/ov_SC04_007_jr_8017BEBC.c b/src/ov_SC04_007/ov_SC04_007_jr_8017BEBC.c
index 76afd1bbd..b8f3f30c2 100644
--- a/src/ov_SC04_007/ov_SC04_007_jr_8017BEBC.c
+++ b/src/ov_SC04_007/ov_SC04_007_jr_8017BEBC.c
@@ -5339,7 +5339,24 @@ s32 func_8017FC8C(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_8017FCFC);
+extern u8 D_801202A0[];
+
+void func_8017FCFC(void) {
+    extern void func_8012C218(void *a0);
+    u8 *p;
+    s32 i;
+    s32 t;
+
+    p = D_801202A0;
+    for (i = 0; i < 0x60; i++) {
+        t = *(u16 *)p;
+        if (t == 0x1FC || (t < 0x1FD ? t == 0x1DC : (t == 0x210 || t == 0x219))) {
+            func_8012C218(p);
+        }
+        p += 0x10C;
+    }
+}
+
 
 void func_8017FDB0(void *a0)
 {
@@ -6642,7 +6659,47 @@ void func_80181DE0(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80181F80);
+extern void func_8012B200(u8 *a0);
+extern void func_8012A828(s32, s32);
+extern s32 D_8011F730;
+extern u8 D_801A0E6C[];
+extern s32 D_801A0CE4;
+extern s32 D_801A0D4C;
+extern s16 D_801A0E04;
+
+s32 func_80181F80(s32 a0) {
+    s32 ret;
+
+    ret = 1;
+    switch (D_8011F730) {
+    case 1:
+        func_8012B200((u8 *)a0);
+        ((void (*)(s32, void *))func_8012A828)(a0, D_801A0E6C);
+        *(u16 *)((char *)a0 + 0x2) = 8;
+        *(u16 *)((char *)a0 + 0x34) = 0;
+        break;
+    case 2:
+        *(u16 *)((char *)a0 + 0x2) = 0xB;
+        break;
+    case 3:
+        ((void (*)(s32, void *))func_8012A828)(a0, (void *)&D_801A0CE4);
+        *(u16 *)((char *)a0 + 0x2) = 0xE;
+        break;
+    case 4:
+        ((void (*)(s32, void *))func_8012A828)(a0, (void *)&D_801A0D4C);
+        *(u16 *)((char *)a0 + 0x2) = 0x10;
+        break;
+    case 5:
+        *(u16 *)((char *)a0 + 0x2) = 0x12;
+        ((void (*)(s32, void *))func_8012A828)(a0, (void *)&D_801A0E04);
+        return ret;
+    default:
+        ret = 0;
+        break;
+    }
+    return ret;
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80182074);
 
@@ -7835,9 +7892,81 @@ void func_80183DDC(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80183E80);
+extern u8 D_801ABCF8[];
+extern void func_8012A828(s32, s32);
+extern void func_8012B1B4(s32, void *);
+extern s16 D_80126B96;
+extern s16 D_801A1474;
+extern s32 D_801A1590;
+extern s32 D_801A15AC;
+extern s32 D_801A15B4;
+extern void func_8002D4C8(s32, s32);
+extern s32 func_8012D5E4(s32, s32, s32, s32);
+
+void func_80183E80(s32 arg0) {
+    register s32 s0 __asm__("$16");
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+    register s32 a0 __asm__("$4");
+    register s32 a1 __asm__("$5");
+    register s32 a2 __asm__("$6");
+    register s32 a3 __asm__("$7");
+
+    s0 = arg0;
+
+    if (*(s16 *)(s0 + 0x98) == 0) {
+        func_8012A828(s0, (s32)D_801ABCF8);
+        *(s16 *)(s0 + 0xFC) = 0;
+    }
+
+    if (*(s32 *)(s0 + 0x94) == 15) {
+        func_8012B1B4(s0, (void *)&D_801A1590);
+        a0 = s0;
+        a1 = (s32)&D_801A15AC;
+        __asm__ __volatile__("" :: "r"(a1));
+        v0 = 0xFFF60000;
+        s0 = 4;
+        *(s32 *)(a0 + 0x14) = v0;
+        v0 = (s32)&D_801A1474;
+        v1 = 0x40000000;
+        v0 = v0 | v1;
+        v1 = 0x20000000;
+        v0 = v0 | v1;
+        a2 = (s32)&D_801A15B4;
+        a3 = 0x20;
+        *(s16 *)(a0 + 2) = s0;
+        *(s32 *)(a0 + 0x58) = v0;
+        if (func_8012D5E4(a0, a1, a2, a3) == 1) {
+            D_80126B96 = s0;
+        }
+        func_8002D4C8(0xA9D, 0);
+    }
+}
+
+
+extern void func_8012CBCC(s32);
+extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_8012A828(s32, s32);
+extern s16 D_80126B96;
+extern u8 D_801A1464[];
+extern u8 D_801A159C[];
+extern u8 D_801A15A4[];
+extern u8 D_801ABDA0[];
+
+void func_80183F4C(s32 a0) {
+    if (*(s32 *)(a0 + 0x94) < 0x3D) {
+        if (func_8012D5E4(a0, (s32)D_801A159C, (s32)D_801A15A4, 0x20) == 1) {
+            D_80126B96 = 4;
+        }
+    }
+    if (((s32 (*)(s32))func_8012CBCC)(a0) & 0x6000) {
+        *(s16 *)(a0 + 0x2) = 5;
+        ((void (*)(s32, void *))func_8012A828)(a0, D_801ABDA0);
+        *(s16 *)(a0 + 0xFC) = 0;
+        *(s32 *)(a0 + 0x58) = ((s32)D_801A1464 | 0x40000000) | 0x20000000;
+    }
+}
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80183F4C);
 
 typedef struct { s16 m[3][3]; s32 t[3]; } MTX_8017D7C0_8017F19C_8018259C_80183FF8; /* 0x20 bytes, align 4 */
 typedef struct {
@@ -8056,7 +8185,19 @@ void func_8018447C(s32 *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80184488);
+void func_80184488(s32 a0) {
+    extern s32 func_8012B8E4(s32 a0, s32 a1);
+
+    s32 ret = func_8012B8E4(a0, 8);
+
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + ret;
+    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) & 0xFFF;
+
+    if ((u32)(ret + 0x1F) < 0x3F) {
+        *(s16 *)(a0 + 0x2) = 3;
+    }
+}
+
 
 extern void func_8012B23C(s32 a0);
 
@@ -8612,7 +8753,27 @@ void func_80185010(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8017BEBC", func_80185060);
+extern void func_80147324(s32 a0);
+extern int func_801511E0(int arg);
+extern void func_80154274(s32 *a0, s32 a1);
+extern void func_80149020(s32 *a0);
+extern s32 func_80172630(u8 *a0);
+extern void func_80146CA0(void *a0);
+
+void func_80185060(s32 p)
+{
+    extern u8 D_801B2668;
+    func_80147324(0x451);
+    ((void (*)(s32))func_801511E0)(p);
+    ((void (*)(s32 *, s32))func_80154274)(p, (s32)&D_801B2668);
+    ((void (*)(s32 *))func_80149020)(p);
+    *(u8 *)(p + 0xDE) = 0x1E;
+    *(u8 *)(p + 0xDF) = 0;
+    func_80185274();
+    ((void (*)(u8 *))func_80172630)(p);
+    ((void (*)(void *))func_80146CA0)(p);
+}
+
 
 
 /* func_801850CC @ ov_SC02_016 (subseg ov_SC02_016_jr_8017DC70) — 85 ins.
diff --git a/src/ov_SC05_002/ov_SC05_002_jr_8017BEBC.c b/src/ov_SC05_002/ov_SC05_002_jr_8017BEBC.c
index ef494dad2..2184d7141 100644
--- a/src/ov_SC05_002/ov_SC05_002_jr_8017BEBC.c
+++ b/src/ov_SC05_002/ov_SC05_002_jr_8017BEBC.c
@@ -3987,7 +3987,28 @@ s32 func_8017E414(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017E41C);
+extern s32 D_8019FF34;
+extern s32 D_80196B4C;
+extern s32 D_8019FE48;
+extern s32 D_8019FF50;
+extern void func_8013C0F8();
+
+void func_8017E41C(void)
+{
+    switch (D_8019FF34) {
+    case 0:
+        func_8013C0F8(&D_80196B4C);
+        D_8019FE48 = 0;
+        D_8019FF34 = D_8019FF34 + 1;
+        break;
+    case 1:
+        func_8017CD9C(&D_8019FF50, &D_80196B4C, D_8019FE48, 0);
+        D_8019FE48 = D_8019FE48 + 0x14;
+        break;
+    }
+    return;
+}
+
 
 
 extern void func_8017F194(void *a0);
@@ -4486,7 +4507,51 @@ void func_8017F30C(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017F348);
 
-INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017F538);
+extern s32 func_80029178(s32 arg);
+extern s32 func_8012C588(s32 a0, s32 a1);
+extern s16 D_8019C7C4[];
+extern s16 D_8019C800[];
+extern s16 D_8019C7D4[];
+extern u16 D_8019C7DC[];
+
+void func_8017F538(void *a0) {
+    s16 step;
+    s32 ent;
+
+    if (*(s16 *)((s32)a0 + 0xFE) != 0 && (func_80029178(0xBA) & 0xFF) == 0) {
+        step = D_8019C800[*(s16 *)((s32)a0 + 0x70)];
+        if (step < D_8019C7C4[*(s16 *)((s32)a0 + 0x70)]) {
+            do {
+                ent = func_8012C588(0x1A4, (s32)a0);
+                if (ent != 0) {
+                    if (D_8019C7D4[*(s16 *)((s32)a0 + 0x70)] < 0) {
+                        *(u16 *)(ent + 0xA) = *(u16 *)(ent + 0xA) - step;
+                    } else {
+                        *(u16 *)(ent + 0xA) = *(u16 *)(ent + 0xA) + step;
+                    }
+                }
+                step += 0x100;
+            } while (step < D_8019C7C4[*(s16 *)((s32)a0 + 0x70)]);
+        }
+    } else {
+        step = 0;
+        if (D_8019C7C4[*(s16 *)((s32)a0 + 0x70)] > 0) {
+            do {
+                ent = func_8012C588(0x1A4, (s32)a0);
+                if (ent != 0) {
+                    if (D_8019C7D4[*(s16 *)((s32)a0 + 0x70)] < 0) {
+                        *(u16 *)(ent + 0xA) = *(u16 *)(ent + 0xA) - step;
+                    } else {
+                        *(u16 *)(ent + 0xA) = *(u16 *)(ent + 0xA) + step;
+                    }
+                }
+                step += 0x180;
+            } while (step < D_8019C7C4[*(s16 *)((s32)a0 + 0x70)]);
+        }
+        *(s32 *)((s32)a0 + 0x1C) = D_8019C7DC[*(s16 *)((s32)a0 + 0x70)];
+    }
+}
+
 
 
 extern void (*D_8019C818[])(void);
@@ -4496,12 +4561,86 @@ void func_8017F734(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017F770);
+extern void func_8012C194(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001CB6C(u8 *a0, s32 a1, s32 a2, s32 a3);
+extern void func_8017F538();
+extern s32 func_80029178(s32 arg);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 func_8012AD50(void *a0);
+
+void func_8017F770(void *a0) {
+    extern u8 D_8019C614[];
+    extern u16 D_8019C7CC[];
+    s32 node;
+
+    *(u16 *)((s32)a0 + 0xFE) = *(u16 *)((s32)a0 + 0x70) & 0x8000;
+    *(u16 *)((s32)a0 + 0x70) = *(u16 *)((s32)a0 + 0x70) & 3;
+    node = ((s32 (*)(void))func_8012C194)();
+    if (node == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+    *(s32 *)((s32)a0 + 0x20) = node;
+    func_8001CB6C((u8 *)node, (s32)D_8019C614, 0x300, 0x100);
+    *(u8 *)(node + 0x27) = 0x64;
+    *(u16 *)(node + 0x30) = *(u16 *)((s32)D_8019C7CC + *(s16 *)((s32)a0 + 0x70) * 2);
+    *(s16 *)(node + 0x32) = -0x20;
+    *(u16 *)(node + 0x2C) = 0x8004;
+    func_8017F538((s32)a0);
+    if (*(s16 *)((s32)a0 + 0xFE) != 0 && (func_80029178(0xBA) & 0xFF) == 0) {
+        func_8012AD44((s32 *)a0, 2);
+    } else {
+        func_8012AD50(a0);
+    }
+}
+
 
 void func_8017F860(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017F868);
+extern s32 func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C810(s32 a0, s32 a1);
+extern s32 func_80029178(s32 arg);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern s32 func_8012AD50(void *a0);
+extern s32 D_8019CA2C;
+extern u8 D_8019C808[];
+
+void func_8017F868(void *a0) {
+    register s32 v0 __asm__("$2");
+    s32 p;
+    u16 u;
+
+    *(s32 *)((s32)a0 + 0x20) = v0 = func_8012C1B8();
+
+    if (v0 == 0) {
+        func_8012CAE4(a0);
+        return;
+    }
+
+    func_8001C810(v0, (s32)&D_8019CA2C);
+
+    *(s32 *)((s32)a0 + 0x58) = (s32)D_8019C808 | 0x40000000;
+    *(u16 *)((s32)a0 + 0x5C) = 0x4400;
+    *(u8 *)((s32)a0 + 0x75) = 0x8;
+
+    u = *(u16 *)((s32)a0 + 0xE);
+    p = *(s32 *)((s32)a0 + 0x20);
+    *(u16 *)((s32)a0 + 0xE) = u - 0x18;
+    *(s32 *)(p + 4) |= 0x8040;
+
+    if (*(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0xFE) != 0) {
+        if ((func_80029178(0xBA) & 0xFF) == 0) {
+            func_8012AD44((s32 *)a0, 2);
+            return;
+        }
+    }
+
+    func_8012AD50(a0);
+}
+
 
 INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8017BEBC", func_8017F940);