From d9a30167dd871746272c70896ecfcdc436d17d99 Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Sat, 29 Aug 2026 11:35:54 -0600
Subject: [PATCH] =?UTF-8?q?feat(t5):=20Claude=20wave=20t5r=20=E2=80=94=203?=
 =?UTF-8?q?0=20banked=20(sonnet=2022/37,=20opus=208/11,=20+recovery);=20fl?=
 =?UTF-8?q?eet=20213=20passed,=200=20failed=20of=20213=20(P31=20S62=20T5)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/md_MAIN_026/md_MAIN_026.c             |  37 ++++-
 src/md_MAIN_028/md_MAIN_028.c             |  23 +++-
 src/md_MAIN_034/md_MAIN_034.c             | 158 +++++++++++++++++++++-
 src/md_MAIN_043/md_MAIN_043.c             |  46 ++++++-
 src/ov_SC01_077/ov_SC01_077_jr_8017AE2C.c |  29 +++-
 src/ov_SC01_084/ov_SC01_084_jr_8017F690.c | 113 +++++++++++++++-
 src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c |  66 ++++++++-
 src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c |  90 +++++++++++-
 src/ov_SC03_028/ov_SC03_028_jr_801887A8.c |  22 ++-
 src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c |  55 +++++++-
 src/ov_SC03_097/ov_SC03_097_jr_8017D898.c |  25 +++-
 src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c | 122 ++++++++++++++++-
 src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c | 106 ++++++++++++++-
 src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c | 110 ++++++++++++++-
 src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c |  67 ++++++++-
 src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c |  21 ++-
 src/ov_SC03_125/ov_SC03_125_jr_8017D604.c |  23 +++-
 src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c |  20 ++-
 src/ov_SC04_011/ov_SC04_011_jr_8017D494.c |  58 +++++++-
 src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c |  43 +++++-
 src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c |  40 +++++-
 src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c |  67 ++++++++-
 src/ov_SC05_011/ov_SC05_011_jr_8017BEBC.c |  32 ++++-
 src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c |  42 +++++-
 src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c |  69 +++++++++-
 src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c |  40 +++++-
 src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c |  26 +++-
 src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c |  80 ++++++++++-
 28 files changed, 1599 insertions(+), 31 deletions(-)

diff --git a/src/md_MAIN_026/md_MAIN_026.c b/src/md_MAIN_026/md_MAIN_026.c
index fdbb22cc8b..7e58150f25 100644
--- a/src/md_MAIN_026/md_MAIN_026.c
+++ b/src/md_MAIN_026/md_MAIN_026.c
@@ -237,7 +237,42 @@ void func_800CB3C0(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_026/nonmatchings/md_MAIN_026", func_800CB470);
+void func_800CB470(void *arg0) {
+    extern void func_800CB5F4();
+    extern s32 func_80012F74(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern void func_80146CA0(void *a0);
+    extern u8 D_800CBBD8;
+    extern u8 D_800CBBD9;
+    extern u8 D_800CBBDA;
+    extern u8 D_800CBBDC;
+    extern u8 D_800CBBDD;
+    extern u8 D_800CBBDE;
+
+    s32 base;
+    void *s1;
+    s16 w;
+
+    s1 = *(void **)((u8 *)arg0 + 0x20);
+    func_800CB5F4(arg0);
+    base = (s32)&D_800CBBD8;
+    *(u8 *)base = func_80012F74(*(u8 *)base, 0, 10, 1);
+    D_800CBBD9 = func_80012F74(D_800CBBD9, 0, 10, 1);
+    D_800CBBDA = func_80012F74(D_800CBBDA, 0, 10, 1);
+    D_800CBBDC = func_80012F74(D_800CBBDC, 0, 10, 1);
+    D_800CBBDD = func_80012F74(D_800CBBDD, 0, 10, 1);
+    D_800CBBDE = func_80012F74(D_800CBBDE, 0, 10, 1);
+    if (*(s32 *)((u8 *)arg0 + 0x50) != 0) {
+        w = *(u16 *)((u8 *)s1 + 0x1e) + 0x20;
+        *(u16 *)((u8 *)s1 + 0x1e) = w;
+        if ((s16)w >= 0x1001) {
+            *(u16 *)((u8 *)s1 + 0x1e) = 0x1000;
+        }
+    }
+    if (*(s32 *)base == 0 && *(s32 *)&D_800CBBDC == 0) {
+        func_80146CA0(arg0);
+    }
+}
+
 
 extern void func_80162CCC(void);
 void func_800CB5D4(void) {
diff --git a/src/md_MAIN_028/md_MAIN_028.c b/src/md_MAIN_028/md_MAIN_028.c
index 11a2ea4086..c0c5f9b767 100644
--- a/src/md_MAIN_028/md_MAIN_028.c
+++ b/src/md_MAIN_028/md_MAIN_028.c
@@ -19,7 +19,28 @@ void func_800CAE88(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CAEC0);
+#include "common.h"
+
+extern s32 rand(void);
+extern void func_801466F0(s32, s32, s32, s32, s32, s32, s32, s32);
+extern void func_80147324(s32);
+extern s32 func_80146994(s32, s32, s32, s32);
+extern void func_801655E4(s32);
+extern s32 func_80165910(void);
+
+void func_800CAEC0(s32 a0) {
+    if (func_80165910() == 0) {
+        func_801655E4(a0);
+    }
+    func_80146994(0x35, a0, 0, 0);
+    func_80147324(0x838);
+    func_801466F0(0xE, a0, 0, 0, 0, ((((rand() % 16) + 0x10) << 12) / 360), 0, 1);
+    func_801466F0(0xE, a0, 0, 0, 0, -((((rand() % 16) + 0x10) << 12) / 360), 0, 1);
+    func_801466F0(0xE, a0, 0, 0, 0, ((((rand() % 16) + 0x10) << 12) / 360), 1, 1);
+    func_801466F0(0xE, a0, 0, 0, 0, -((((rand() % 16) + 0x10) << 12) / 360), 1, 1);
+    *(u8 *)(a0 + 0x197) += 1;
+}
+
 
 void func_800CB0D8(s32 a0) {
     typedef struct { u8 pad[0x50]; s32 f50; } Struct80078E78;
diff --git a/src/md_MAIN_034/md_MAIN_034.c b/src/md_MAIN_034/md_MAIN_034.c
index 40713cd678..7eb44aeffa 100644
--- a/src/md_MAIN_034/md_MAIN_034.c
+++ b/src/md_MAIN_034/md_MAIN_034.c
@@ -146,7 +146,163 @@ F3P_800CB1F8 *func_800CB1F8(Face10_800CB1F8 *f, SVEC8_800CB1F8 *verts,
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_034/nonmatchings/md_MAIN_034", func_800CB3C0);
+#include "common.h"
+
+/* func_800CB3C0 — md_MAIN_034 — flat-quad (POLY_F4 / OT tag 0x05000000)
+ * emitter with flat NCCS lighting.  Structural twin of func_800CB7BC in this
+ * same TU (the GT4 emitter): identical control flow, but a 0x18 flat packet
+ * with ONE colour word and a single NCCS instead of the NCCT+NCCS pair.
+ *
+ * Register map read off the target .s:
+ *   $s5 = face                 $s0 = &face->n0 giv (a0+8, stride 0x14)
+ *   $s3 = vtx                  a2 (nrm) spilled to 0x20(sp), reloaded in the
+ *                              NCCS arm only
+ *   $s1 = pkt (a3 + D_800C7C74*0x18, stride 0x30 = 2 packets)
+ *   $s2 = &pkt->rgb0 giv (pkt+4)
+ *   $s4 = loop counter (stack arg 4)
+ *   $s7 = &g.flag (sp+0x18)    $s6 = &g.opz (sp+0x1C)
+ *   $fp = ~0x1000, hoisted (used by both flag tests)
+ */
+
+/* ---- PsyQ inline_c.h GTE macros (same spellings as the matched siblings) -- */
+#define gte_ldv0(r0) __asm__ volatile (           \
+    "lwc2 $0, 0( %0 );"                           \
+    "lwc2 $1, 4( %0 )"                            \
+    :                                             \
+    : "r"( r0 ) )
+
+#define gte_ldv3(r0, r1, r2) __asm__ volatile (   \
+    "lwc2 $0, 0( %0 );"                           \
+    "lwc2 $1, 4( %0 );"                           \
+    "lwc2 $2, 0( %1 );"                           \
+    "lwc2 $3, 4( %1 );"                           \
+    "lwc2 $4, 0( %2 );"                           \
+    "lwc2 $5, 4( %2 )"                            \
+    :                                             \
+    : "r"( r0 ), "r"( r1 ), "r"( r2 ) )
+
+#define gte_ldrgb(r0) __asm__ volatile (          \
+    "lwc2 $6, 0( %0 )"                            \
+    :                                             \
+    : "r"( r0 ) )
+
+#define gte_rtps()  __asm__ volatile ("nop;nop;rtps")
+#define gte_rtpt()  __asm__ volatile ("nop;nop;rtpt")
+#define gte_nclip() __asm__ volatile ("nop;nop;nclip")
+#define gte_avsz4() __asm__ volatile ("nop;nop;avsz4")
+#define gte_nccs()  __asm__ volatile ("nop;nop;nccs")
+
+#define gte_stflg(r0) __asm__ volatile (          \
+    "cfc2 $12, $31;"                              \
+    "nop;"                                        \
+    "sw $12, 0( %0 )"                             \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "$12", "memory" )
+
+#define gte_stopz(r0) __asm__ volatile (          \
+    "swc2 $24, 0( %0 )"                           \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "memory" )
+
+#define gte_stotz(r0) __asm__ volatile (          \
+    "swc2 $7, 0( %0 )"                            \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "memory" )
+
+#define gte_stsxy(r0) __asm__ volatile (          \
+    "swc2 $14, 0( %0 )"                           \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "memory" )
+
+#define gte_stsxy3_f4(r0) __asm__ volatile (      \
+    "swc2 $12, 8( %0 );"                          \
+    "swc2 $13, 12( %0 );"                         \
+    "swc2 $14, 16( %0 )"                          \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "memory" )
+
+#define gte_strgb(r0) __asm__ volatile (          \
+    "swc2 $22, 0( %0 )"                           \
+    :                                             \
+    : "r"( r0 )                                   \
+    : "memory" )
+
+/* ---- types ------------------------------------------------------------- */
+typedef struct { s16 vx, vy, vz, pad; } SVEC8_800CB3C0;   /* 0x08 */
+
+typedef struct {          /* face record, 0x14 bytes */
+    /* 0x00 */ u32 unk00;
+    /* 0x04 */ u32 rgb;
+    /* 0x08 */ u16 n0;
+    /* 0x0A */ u16 v0;
+    /* 0x0C */ u16 v1;
+    /* 0x0E */ u16 v2;
+    /* 0x10 */ u16 v3;
+    /* 0x12 */ u16 pad12;
+} FaceF4_800CB3C0;                                        /* 0x14 */
+
+typedef struct {          /* flat quad packet, 0x18 bytes */
+    /* 0x00 */ u32 tag;
+    /* 0x04 */ u32 rgb0;
+    /* 0x08 */ u32 xy0;
+    /* 0x0C */ u32 xy1;
+    /* 0x10 */ u32 xy2;
+    /* 0x14 */ u32 xy3;
+} PktF4_800CB3C0;                                         /* 0x18 */
+
+extern s16 D_800C7C74;      /* double-buffer parity index */
+extern u32 D_800CC9FC;      /* flat colour used when func_800CC0A0() says so */
+
+extern s32 func_800CC0A0(void *prim);
+extern void func_800CC110(s32 ot, s32 otz, s32 shift, void *prim, u32 code);
+
+PktF4_800CB3C0 *func_800CB3C0(FaceF4_800CB3C0 *face, SVEC8_800CB3C0 *vtx,
+                              SVEC8_800CB3C0 *nrm, PktF4_800CB3C0 *prims,
+                              s32 count, s32 shift, s32 ot)
+{
+    struct { s32 flag, opz; } g;
+    PktF4_800CB3C0 *pkt;
+
+    pkt = &prims[D_800C7C74];
+
+    for (; count != 0; count--, face++, pkt += 2) {
+        gte_ldv3(&vtx[face->v0], &vtx[face->v1], &vtx[face->v2]);
+        gte_rtpt();
+        gte_stflg(&g.flag);
+        if (!(g.flag & ~0x1000)) {
+            gte_nclip();
+            gte_stopz(&g.opz);
+            if (g.opz > 0) {
+                gte_stsxy3_f4(pkt);
+                gte_ldv0(&vtx[face->v3]);
+                gte_rtps();
+                gte_stflg(&g.flag);
+                if (!(g.flag & ~0x1000)) {
+                    gte_stsxy(&pkt->xy3);
+                    gte_avsz4();
+                    gte_stotz(&g.opz);
+                    if (func_800CC0A0(pkt) != 0) {
+                        pkt->rgb0 = D_800CC9FC;
+                    } else {
+                        gte_ldrgb(&face->rgb);
+                        gte_ldv0(&nrm[face->n0]);
+                        gte_nccs();
+                        gte_strgb(&pkt->rgb0);
+                    }
+                    func_800CC110(ot, g.opz, shift, pkt, 0x05000000);
+                }
+            }
+        }
+    }
+
+    return pkt;
+}
+
 
 #include "common.h"
 
diff --git a/src/md_MAIN_043/md_MAIN_043.c b/src/md_MAIN_043/md_MAIN_043.c
index 99fb462403..3f949e8152 100644
--- a/src/md_MAIN_043/md_MAIN_043.c
+++ b/src/md_MAIN_043/md_MAIN_043.c
@@ -455,7 +455,51 @@ void func_800CD404(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_043/nonmatchings/md_MAIN_043", func_800CD57C);
+extern void func_800CD6D4(void);
+extern s32 func_80012FC8(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80146E98(s32 a0);
+extern void func_80146CA0(void *a0);
+extern u8 D_800CD764[];
+
+void func_800CD57C(void *arg0) {
+    s32 s0;
+    s32 v0;
+    s32 t;
+
+    s0 = *(s32 *)((s32)arg0 + 0x20);
+    ((void (*)(void *, void *))func_800CD6D4)(
+        arg0,
+        (void *)(D_800CD764 + (*(s32 *)((s32)arg0 + 0x50) << 6)));
+    v0 = func_80012FC8(*(s16 *)(s0 + 0x1A), 0x5000, 0xA, 1);
+    t = *(u16 *)(s0 + 0x1A) + v0;
+    *(u16 *)(s0 + 0x1A) = t;
+    *(u16 *)(s0 + 0x18) = t;
+    {
+        s32 x;
+        x = (s16)t;
+        v0 = func_8004787C(x / 10);
+    }
+    {
+        s32 adj;
+        s32 v1;
+        v1 = *(s16 *)((s32)arg0 + 0x62);
+        v0 = v0 * 2;
+        v1 = v1 * v0;
+        adj = v1 / 0x1000;
+        {
+            register s32 fld __asm__("$2");
+            fld = *(u16 *)((s32)arg0 + 0x60);
+            v0 = fld - adj;
+        }
+    }
+    *(u16 *)((s32)arg0 + 0xA) = v0;
+    v0 = func_80146E98((s32)arg0);
+    if (v0 != 0) {
+        func_80146CA0(arg0);
+    }
+}
+
 
 extern void func_80162CCC(void);
 void func_800CD650(void) {
diff --git a/src/ov_SC01_077/ov_SC01_077_jr_8017AE2C.c b/src/ov_SC01_077/ov_SC01_077_jr_8017AE2C.c
index e3910addab..10629a8dfb 100644
--- a/src/ov_SC01_077/ov_SC01_077_jr_8017AE2C.c
+++ b/src/ov_SC01_077/ov_SC01_077_jr_8017AE2C.c
@@ -5319,7 +5319,34 @@ void func_8017F780(s32 *arg0) {
     }
 }
 
-INCLUDE_ASM("asm/ov_SC01_077/nonmatchings/ov_SC01_077_jr_8017AE2C", func_8017F7E8);
+// @class: arith
+// @stuck: none — MATCH (177 ins)
+// ABS macro expanded THREE times (test + both ternary arms): func_80047948 is not
+// pure, so gcc cannot CSE across the calls and re-emits the whole expression in
+// each arm. `-(X - 0x800)` folds to `0x800 - X` in the negative arm.
+// D_8018A9D0 is read into a local BEFORE the first call — that is what parks it in
+// $s4 (callee-saved) and lets the scheduler drop its lui/lh into the mult hazard
+// slots at 8017F84C. `i` is a real local (live in $s1 across all six calls);
+// D_8018A9D2 is re-read at every use (6 lui/lh pairs), CSE merging only the two
+// uses in the first basic block.
+
+extern s32 func_80047948(s32 a0);
+
+s32 func_8017F7E8(s32 a0) {
+    extern s16 D_8018A9D0;
+    extern s16 D_8018A9D2;
+    s32 m = D_8018A9D0;
+    s32 i = *(s16 *)(a0 + 0xFC) & (D_8018A9D2 - 1);
+
+    return (((func_80047948((0x2000 / D_8018A9D2) * i) / 2
+              + func_80047948((0x4000 / D_8018A9D2) * i) * 3 / 8 - 0x800) < 0
+               ? -(func_80047948((0x2000 / D_8018A9D2) * i) / 2
+                   + func_80047948((0x4000 / D_8018A9D2) * i) * 3 / 8 - 0x800)
+               : (func_80047948((0x2000 / D_8018A9D2) * i) / 2
+                  + func_80047948((0x4000 / D_8018A9D2) * i) * 3 / 8 - 0x800))
+            * m >> 12) + 8;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_077/nonmatchings/ov_SC01_077_jr_8017AE2C", func_8017FAAC);
 
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c b/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
index 561c7fb7e6..9af8d83df0 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8017F690.c
@@ -3998,7 +3998,118 @@ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_801822A
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80182328);
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_801826C4);
+extern void func_8012DBD0(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_8012A828(s32 a0, void *a1);
+/* TU declares func_8012CBA4 / func_8012CBF4 `void` (lines 5136 / 6513); these call
+ * sites need the s32 return, so they cast at the use site — the TU's own idiom
+ * (see lines 5202, 5254, 6530). */
+extern void func_8012CBA4(s32 a0);
+extern void func_8012CBF4(s32 a0);
+extern s32  func_8012CC64(s32 a0, void *a1);
+extern s32  func_80143B6C(s32 arg0, s32 arg1);
+extern s32  func_80047D3C(s32 a0);
+extern s32  func_801807D8(s16 *a0);
+extern void func_80182DB4();
+extern void func_80182DF8(void *a0);
+extern s32  D_8018AAB4;
+extern s32  D_801A1A10;
+
+void func_801826C4(s32 param_1) {
+    s16 sp10[3];
+    s32 r;
+    s32 saved;
+    s32 t;
+    u16 m, y, f, g;
+
+    func_8012DBD0(param_1, 0x50,
+                  *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + 0x800, 0x1D);
+
+    switch (*(u8 *)(param_1 + 0xC2)) {
+    case 0:
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) -= 0x100;
+        if (++*(s32 *)(param_1 + 0x1C) < 0x29) {
+            if (*(s32 *)(param_1 + 0x14) <= 0) {
+                r = ((s32 (*)(s32))func_8012CBF4)(param_1);
+            } else {
+                r = func_8012CC64(param_1, &D_8018AAB4);
+            }
+            if (r & 0x2000) {
+                *(u8 *)(param_1 + 0xC2) = 1;
+                func_80143B6C(param_1, 1);
+                *(s32 *)(param_1 + 0x14) = 0xFFF30000;
+                *(s32 *)(param_1 + 0x1C) = 0;
+            }
+        } else {
+            func_80182DB4(param_1);
+        }
+        break;
+    case 1:
+        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) -= 0x100;
+        if (++*(s32 *)(param_1 + 0x1C) < 0x29) {
+            saved = *(s32 *)(param_1 + 0x14);
+            if (func_8012CC64(param_1, &D_8018AAB4) & 0x2000) {
+                func_80143B6C(param_1, 1);
+                *(s32 *)(param_1 + 0x14) = saved;
+                *(u8 *)(param_1 + 0xC2) = 2;
+                *(s32 *)(param_1 + 0x1C) = 0;
+                *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0;
+            }
+        } else {
+            func_80182DB4(param_1);
+        }
+        break;
+    case 2:
+        *(s32 *)(param_1 + 0x10) = *(s32 *)(param_1 + 0x10) * 15 / 16;
+        *(s32 *)(param_1 + 0x18) = *(s32 *)(param_1 + 0x18) * 15 / 16;
+        if ((*(u8 *)(param_1 + 0xC3) & 1) != 0) {
+            r = ((s32 (*)(s32))func_8012CBA4)(param_1);
+            if ((r & 0x2000) == 0) {
+                func_80182DB4(param_1);
+                break;
+            }
+        } else {
+            r = ((s32 (*)(s32))func_8012CBF4)(param_1);
+            if ((r & 0x2000) != 0) {
+                *(u8 *)(param_1 + 0xC3) |= 1;
+            }
+        }
+        if ((*(s32 *)(param_1 + 0x1C) & 3) == 3) {
+            func_80143B6C(param_1, 1);
+        }
+        if (++*(s32 *)(param_1 + 0x1C) >= 0x11) {
+            if ((r & 0x2000) == 0) {
+                func_80182DB4(param_1);
+            } else {
+                if (*(s16 *)(param_1 + 0x76) > 0 && *(s16 *)(param_1 + 0xA) < -0x28) {
+                    *(s16 *)(param_1 + 0xFC) = 0;
+                    *(u8 *)(param_1 + 0xC1) = 0;
+                    *(s16 *)(param_1 + 2) = 1;
+                    *(s16 *)(param_1 + 0x34) = 0;
+                    func_8012A828(param_1, &D_801A1A10);
+                    m = *(u16 *)(param_1 + 0x5C);
+                    y = *(u16 *)(param_1 + 6);
+                    f = *(u16 *)(param_1 + 0xFC);
+                    *(s32 *)(param_1 + 0x1C) = 0xA;
+                    t = (s32)(s16)y * (s32)(s16)y;
+                    *(u16 *)(param_1 + 0x5E) = 0;
+                    g = m | 0x8000;
+                    *(u16 *)(param_1 + 0x5C) = g;
+                    *(u16 *)(param_1 + 0xFC) = f ^ 1;
+                    sp10[0] = y;
+                    sp10[1] = *(u16 *)(param_1 + 0xA);
+                    sp10[2] = *(u16 *)(param_1 + 0xE);
+                    t += (s32)(s16)sp10[2] * (s32)(s16)sp10[2];
+                    *(s16 *)(param_1 + 0xDE) = func_80047D3C(t);
+                    *(s16 *)(param_1 + 0xDC) = func_801807D8(sp10);
+                } else {
+                    func_80182DF8((void *)param_1);
+                }
+            }
+        }
+        break;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8017F690", func_80182A00);
 
diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c b/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
index db8a195055..e2cdd7f7a6 100644
--- a/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
+++ b/src/ov_SC02_039/ov_SC02_039_jr_8017BEBC.c
@@ -4267,7 +4267,71 @@ void func_8017E758(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_jr_8017BEBC", func_8017E794);
+extern u8 D_801202A0[];
+extern void func_8017E910(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017E794(void *a0)
+{
+    s32 i;
+    u8 *p;
+    u8 *best;
+    s16 min_abs;
+    s16 best_val;
+    u16 counter;
+
+    min_abs = 0x7FFF;
+    best_val = 0x7FFF;
+    best = 0;
+    p = D_801202A0;
+
+    for (i = 0; i < 0x60; i++) {
+        if (*(u16 *)(p) == 0x1A8) {
+            s16 absdelta;
+
+            func_8017E910(p);
+            absdelta = *(s16 *)(p + 0x100);
+            if (absdelta < 0) {
+                absdelta = -absdelta;
+            }
+            if (min_abs > absdelta) {
+                best_val = *(u16 *)(p + 0x100);
+                min_abs = absdelta;
+                best = p;
+            }
+        }
+        p += 0x10C;
+    }
+
+    counter = *(u16 *)((u8 *)a0 + 0x84);
+    counter = counter + 1;
+    *(u16 *)((u8 *)a0 + 0x84) = counter;
+
+    if (min_abs < 0xA0) {
+        if (*(s32 *)(best + 0xE0) < 0x150) {
+            if ((counter & 3) == 0) {
+                s32 quotient;
+                s32 qc;
+                s32 pan;
+
+                quotient = (best_val + 0xA0) / 20;
+                pan = 0x7F - (min_abs >> 1);
+                qc = (quotient << 8) | 0x3000;
+                func_8002D4C8(0x6DA, (pan | qc) & 0xFFFF);
+                *(s16 *)((u8 *)a0 + 0x102) = 1;
+                return;
+            } else {
+                return;
+            }
+        }
+    }
+
+    if (*(s16 *)((u8 *)a0 + 0x102) == 1) {
+        func_8002D4C8(4, 0x6DA);
+        *(s16 *)((u8 *)a0 + 0x102) = 0;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
index 7cd0f7e082..92609710d3 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_8017AE2C.c
@@ -3319,7 +3319,95 @@ DEFINE_func_8017BEAC()  /* dedup: shared engine-core @0x8017BEAC (src/shared) */
 
 DEFINE_func_8017BEB4()  /* dedup: shared engine-core @0x8017BEB4 (src/shared) */
 
-INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8017AE2C", func_8017BEBC);
+#include "common.h"
+
+typedef struct { s16 vx, vy, vz, pad; } SVEC_BEBC;
+
+extern s32 func_800491EC(void);
+extern void func_8017C294(u16 *a0, void *a1);
+extern int func_8017C338(short *p1, short *p2, short *p3, int p4);
+extern void func_8017C530(s32 a0, s32 a1);
+
+#define MINB(a, b) ((a) > (b) ? (b) : (a))
+#define MAXB(a, b) ((a) < (b) ? (b) : (a))
+
+void func_8017BEBC(void *a0, void *a1, s32 a2)
+{
+    SVEC_BEBC corner[4];
+    SVEC_BEBC view[4];
+    SVEC_BEBC hit[4];
+    SVEC_BEBC org;
+    SVEC_BEBC eye;
+    s16 *rect = (s16 *)a0;
+    s32 i;
+    s32 x0, y0, x1, y1;
+    s16 m;
+    s32 d;
+    s32 z;
+    s16 u, v;
+    s32 mnx, mnz, mxx, mxz;
+
+    x0 = rect[0];
+    y0 = rect[1];
+    x1 = x0 + rect[2];
+    y1 = y0 + rect[3];
+    m = MAXB(rect[2], rect[3]);
+    d = (s16)(m / 20);
+    z = func_800491EC();
+
+    corner[0].vx = x0; corner[0].vy = y0; corner[0].vz = z;
+    corner[1].vx = x1; corner[1].vy = y0; corner[1].vz = z;
+    corner[2].vx = x0; corner[2].vy = y1; corner[2].vz = z;
+    corner[3].vx = x1; corner[3].vy = y1; corner[3].vz = z;
+
+    org.vx = 0;
+    org.vy = 0;
+    org.vz = 0;
+    func_8017C294((u16 *)&org, &eye);
+
+    for (i = 0; i < 4; i++) {
+        func_8017C294((u16 *)&corner[i], &view[i]);
+        if (func_8017C338((short *)&eye, (short *)&view[i], (short *)&hit[i], a2)) {
+            func_8017C530((s32)&hit[i], (s32)&corner[i]);
+            corner[i].vx = (corner[i].vx < x0 - d) ? (x0 - d)
+                : ((corner[i].vx > x1 + d) ? (x1 + d) : corner[i].vx);
+            corner[i].vy = (corner[i].vy < y0 - d) ? (y0 - d)
+                : ((corner[i].vy > y1 + d) ? (y1 + d) : corner[i].vy);
+            func_8017C294((u16 *)&corner[i], &view[i]);
+            func_8017C338((short *)&eye, (short *)&view[i], (short *)&hit[i], a2);
+        }
+    }
+
+    v = MINB(hit[2].vx, hit[3].vx);
+    u = MINB(hit[0].vx, hit[1].vx);
+    if (u > v) u = v;
+    mnx = u;
+    if (eye.vx < mnx) mnx = eye.vx;
+
+    v = MINB(hit[2].vz, hit[3].vz);
+    u = MINB(hit[0].vz, hit[1].vz);
+    if (u > v) u = v;
+    mnz = u;
+    if (eye.vz < mnz) mnz = eye.vz;
+
+    v = MAXB(hit[2].vx, hit[3].vx);
+    u = MAXB(hit[0].vx, hit[1].vx);
+    if (u < v) u = v;
+    mxx = u;
+    if (mxx < eye.vx) mxx = eye.vx;
+
+    v = MAXB(hit[2].vz, hit[3].vz);
+    u = MAXB(hit[0].vz, hit[1].vz);
+    if (u < v) u = v;
+    mxz = u;
+    if (mxz < eye.vz) mxz = eye.vz;
+
+    ((s16 *)a1)[0] = mnx;
+    ((s16 *)a1)[1] = mnz;
+    ((s16 *)a1)[2] = mxx - mnx;
+    ((s16 *)a1)[3] = mxz - mnz;
+}
+
 
 extern void ReadRotMatrix(void *a0);
 extern void PushMatrix(void);
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_801887A8.c b/src/ov_SC03_028/ov_SC03_028_jr_801887A8.c
index cae2dc6183..39a20e123a 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_801887A8.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_801887A8.c
@@ -3500,7 +3500,27 @@ void func_80188F4C(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_801887A8", func_80188FF0);
+extern volatile s32 D_801EC44C;
+
+void func_80188FF0(s32 a0)
+{
+    s16 *a2;
+
+    if (D_801EC44C != 0) {
+        a2 = (s16 *)D_801EC44C;
+        if ((*(s16 *)(a0 + 0xA) > a2[5] - 0x10) &&
+            (*(s16 *)(a0 + 0xA) < a2[5] + 0x10) &&
+            (*(s16 *)(a0 + 0x6) < a2[3] + 0x80) &&
+            (a2[3] - 0x80 < *(s16 *)(a0 + 0x6)) &&
+            (*(s16 *)(a0 + 0xE) < a2[7] + 0x80) &&
+            (a2[7] - 0x80 < *(s16 *)(a0 + 0xE)))
+        {
+            *(u16 *)(a0 + 0x5E) = 0x1D;
+            *(u16 *)(a0 + 0x5C) |= 1;
+        }
+    }
+}
+
 
 extern void func_8012C218(void *a0);
 
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 0be818f2ff..f0d3e2740e 100644
--- a/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
+++ b/src/ov_SC03_031/ov_SC03_031_jr_8017DB5C.c
@@ -3641,7 +3641,60 @@ s32 func_8017F860(void* a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8017DB5C", func_8017F95C);
+
+
+extern s32 RotMatrixX(s32 a0, void *a1);
+extern s32 D_800AE620[];
+extern s32 D_8018618C;
+
+void func_8017F95C(s32 a0) {
+    Mat32 mat;
+    u16 buf[3];
+
+    mat = *(Mat32 *)&D_800AE620;
+    RotMatrixX(-0x300, &mat);
+    __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"
+        :
+        : "r"(&mat)
+        : "$12", "$13", "$14", "memory"
+    );
+    __asm__ __volatile__(
+        "lwc2 $0, 0(%0)\n"
+        "lwc2 $1, 4(%0)\n"
+        "nop\n"
+        "nop\n"
+        "mvmva 1, 0, 0, 3, 0\n"
+        :
+        : "r"(&D_8018618C)
+        : "memory"
+    );
+    __asm__ __volatile__(
+        "mfc2 $12, $9\n"
+        "mfc2 $13, $10\n"
+        "mfc2 $14, $11\n"
+        "sh $12, 0(%0)\n"
+        "sh $13, 2(%0)\n"
+        "sh $14, 4(%0)\n"
+        :
+        : "r"(buf)
+        : "$12", "$13", "$14", "memory"
+    );
+
+    *(u16 *)(a0 + 6)  += buf[0];
+    *(u16 *)(a0 + 0xA) += buf[1];
+    *(u16 *)(a0 + 0xE) += buf[2];
+}
+
 
 
 extern void (*D_801861E0[])(void);
diff --git a/src/ov_SC03_097/ov_SC03_097_jr_8017D898.c b/src/ov_SC03_097/ov_SC03_097_jr_8017D898.c
index 1986559d35..c06bddd0ac 100644
--- a/src/ov_SC03_097/ov_SC03_097_jr_8017D898.c
+++ b/src/ov_SC03_097/ov_SC03_097_jr_8017D898.c
@@ -3742,7 +3742,30 @@ void func_8017F304(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_097/nonmatchings/ov_SC03_097_jr_8017D898", func_8017F3D4);
+
+
+extern s32 D_80126B58;
+extern s16 D_80189BC4[];
+extern Blk8_80126940_8017D6D0_8017F48C D_80126940;
+extern void func_8017F53C(s32 param_1, s16 *param_2);
+extern u16 func_80148800(s32 *a0);
+
+void func_8017F3D4(s32 a0) {
+    Blk8_80126940_8017D6D0_8017F48C sp10;
+    u8 t;
+
+    if (func_80148800(&D_80126B58) & 3) {
+        t = (*(u8 *)(a0 + 5) + 1) & 1;
+        *(u8 *)(a0 + 5) = t;
+        *(s32 *)(a0 + 0x14) = D_80189BC4[t];
+    }
+    sp10 = D_80126940;
+    sp10.v[0] = -0x1720;
+    sp10.v[1] = -0x202;
+    sp10.v[2] = 0xF00;
+    func_8017F53C(a0, sp10.v);
+}
+
 
 
 /* 8 bytes, align 2 -> lwl/lwr/swl/swr copy (cookbook §48-C2) */
diff --git a/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c b/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c
index 4aa8ca5425..19561dc27d 100644
--- a/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c
+++ b/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c
@@ -4206,7 +4206,80 @@ extern s32 rand(void);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8017BEBC", func_80180A38);
+void func_80180A38(s32 param_1)
+{
+    extern u16 D_80126B5E;
+    extern u16 D_80126B62;
+    extern u16 D_80126B66;
+    extern void func_8012BE98(s32 a0, u16 *a1);
+    extern s32 func_80181260(s32 param_1, s16 param_2);
+
+    typedef struct { s16 v[4]; } Blk8_80180A38;
+
+    Blk8_80180A38 pos;
+    u16 buf[3];
+    s32 d;
+    s32 timer;
+
+    buf[0] = D_80126B5E;
+    buf[1] = D_80126B62;
+    buf[2] = D_80126B66;
+
+    if (((s32 (*)(s32, u16 *))func_8012BE98)(param_1, buf) > 0x9C400) {
+        goto TAIL;
+    }
+
+    d = *(s16 *)(param_1 + 0xA) - *(s16 *)&buf[1];
+    if (d >= 0) {
+        if (d > 0x200) goto TAIL;
+    } else {
+        d = *(s16 *)&buf[1] - *(s16 *)(param_1 + 0xA);
+        if (d > 0x200) goto TAIL;
+        /* §5a zero-byte cross-jump barrier: keeps this arm's slti/beqz test
+         * a separate RTL block from the sibling arm's identical-looking test
+         * below, so gcc's cross-jump pass does not re-merge the two tails
+         * into one (which drops 2 instructions and swaps which arm is the
+         * branch target vs. the fallthrough). LOAD-BEARING — do not remove. */
+        __asm__ __volatile__("" ::: "memory");
+    }
+
+    timer = *(s32 *)(param_1 + 0xE0);
+    if (timer != 0) {
+        timer -= 1;
+        *(s32 *)(param_1 + 0xE0) = timer;
+        goto INCR;
+    }
+
+    if (*(s32 *)(param_1 + 0x1C) % *(s16 *)(param_1 + 0xFC) == 0) {
+        pos = *(Blk8_80180A38 *)(param_1 + 0x88);
+
+        func_80181260((s32)&pos, *(s16 *)(*(s32 *)(param_1 + 0x68) + 0xC));
+        pos.v[0] += 0x28;
+
+        func_80181260((s32)&pos, *(s16 *)(*(s32 *)(param_1 + 0x68) + 0xC));
+        pos.v[0] += -0x50;
+
+        func_80181260((s32)&pos, *(s16 *)(*(s32 *)(param_1 + 0x68) + 0xC));
+
+        *(s16 *)(param_1 + 0xFE) += 1;
+    }
+
+    if (*(s16 *)(param_1 + 0xFE) >= 3) {
+        *(s32 *)(param_1 + 0xE0) = 0x1E;
+        *(s16 *)(param_1 + 0xFE) = 0;
+    }
+
+TAIL:
+    timer = *(s32 *)(param_1 + 0xE0);
+    if (timer != 0) {
+        timer -= 1;
+        *(s32 *)(param_1 + 0xE0) = timer;
+    }
+
+INCR:
+    *(s32 *)(param_1 + 0x1C) += 1;
+}
+
 
 
 extern void (*D_80189C04[])(void);
@@ -4218,7 +4291,52 @@ void func_80180BFC(void *a0) {
 
 INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8017BEBC", func_80180C38);
 
-INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8017BEBC", func_80181030);
+#include "common.h"
+
+struct vec;
+
+typedef struct { s16 vx, vy, vz, pad; } SVECTOR_80181030;
+
+extern void func_8012931C(struct vec *a0);
+extern s32 func_80133784(s32 a0, void *a1, s32 a2);
+extern s32 func_801811F0(s32 a0);
+
+void func_80181030(s32 a0)
+{
+    SVECTOR_80181030 sv1, sv2;
+    s32 v0;
+
+    if (*(s32 *)(a0 + 0x2C) == 0) {
+        sv1.vx = *(u16 *)(a0 + 0x6);
+        sv1.vy = *(u16 *)(a0 + 0xA);
+        sv1.vz = *(u16 *)(a0 + 0xE);
+        *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) + 0x18000;
+        func_8012931C((struct vec *)a0);
+
+        sv2.vx = *(u16 *)(a0 + 0x6);
+        sv2.vy = *(u16 *)(a0 + 0xA);
+        sv2.vz = *(u16 *)(a0 + 0xE);
+        v0 = func_80133784(1, &sv1, (s32)&sv2);
+        if (v0 != 0) {
+            register s32 rv0 __asm__("$2");
+            register s16 rv1 __asm__("$3");
+
+            *(u16 *)(a0 + 0x6) = sv2.vx;
+            *(u16 *)(a0 + 0xA) = sv2.vy;
+            __asm__ __volatile__("" ::: "memory");
+            rv0 = *(s32 *)(a0 + 0x2C);
+            rv1 = sv2.vz;
+            rv0 = rv0 + 1;
+            *(s32 *)(a0 + 0x2C) = rv0;
+            rv0 = 0x1E;
+            *(s32 *)(a0 + 0x1C) = rv0;
+            *(u16 *)(a0 + 0xE) = rv1;
+        }
+    } else {
+        func_801811F0(a0);
+    }
+}
+
 
 
 
diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c b/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
index 95016ccf16..7de9c8f6c8 100644
--- a/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
+++ b/src/ov_SC03_108/ov_SC03_108_jr_8017BEBC.c
@@ -4080,7 +4080,111 @@ void func_8017E508(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8017BEBC", func_8017E71C);
+#include "common.h"
+
+extern s32 rand(void);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012C218(void *a0);
+extern s32 func_80132EF4(s32 a0, s32 a1);
+extern void func_8012E32C(void);
+extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3);
+extern void func_8012CC40(s32 a0, s32 a1);
+extern void func_8012CC64(s32 a0, s32 a1);
+extern void func_8017E9C0(s32 arg0);
+
+void func_8017E71C(void *a0) {
+    extern u8 D_80184818[];
+    extern s16 D_8018481A[][4];
+    extern u16 D_8018481E[];
+    s32 s0 = (s32)a0;
+    s32 v1;
+    s32 s1;
+    s16 v[4];      /* sp+0x10 */
+    s32 sxy;       /* sp+0x18 */
+    s32 z;         /* sp+0x1C */
+    s32 flag;      /* sp+0x20 */
+
+    if (*(s16 *)(s0 + 0x102) == 0) {
+        v1 = ((s32 (*)(void *, u8 *))func_8012CC64)(a0, D_80184818);
+    } else {
+        v1 = ((s32 (*)(s32, s32))func_8012CC40)(
+                 s0, (s32)&D_80184818[*(s16 *)(s0 + 0x102) * 8]);
+    }
+
+    if (*(s16 *)(s0 + 0xA) >= -0x200) {
+        func_8012C218((void *)s0);
+        return;
+    }
+
+    if (v1 != 0) {
+        v1 = v1 & 0x2000;
+        s1 = D_8018481E[*(s16 *)(s0 + 0x102) * 4];
+        if (v1 != 0) {
+            *(s16 *)(s0 + 0x16) = -*(u16 *)(s0 + 0x16);
+            if (*(s16 *)(s0 + 0xFE) == 0) {
+                *(s16 *)(s0 + 0xFE) = *(s16 *)(s0 + 0xFE) + 1;
+                *(s16 *)(s0 + 0x16) = *(u16 *)(s0 + 0x16) - 8;
+            }
+        } else {
+            *(s16 *)(s0 + 0xFE) = 0;
+            *(s16 *)(s0 + 0x16) = -4;
+            if (*(s16 *)(s0 + 0x102) < 2) {
+                if ((rand() & 0x7FFF) < (s16)s1) {
+                    func_8012C658(0x1A9, 2, s0);
+                }
+            }
+        }
+        if (s1 != 0) {
+            s32 e = func_80132EF4(s0, 0x22);
+            if (e != 0) {
+                *(s16 *)(e + 0xA) = *(u16 *)(e + 0xA)
+                                  + *(u16 *)&D_8018481A[*(s16 *)(s0 + 0x102)][0];
+                *(s16 *)(e + 0x34) = s1 + 1;
+            }
+        }
+
+        {
+            s32 f = *(u16 *)(s0 + 0x70);
+            s1 = (f & 0x80) ? 0x6DC : 0;
+            if (f & 0x40) {
+                s1 = 0x6DB;
+            }
+        }
+        if (s1 != 0) {
+            s32 sx;
+            s32 pan;
+            s32 vol;
+
+            v[0] = *(u16 *)(s0 + 0x6);
+            v[1] = *(u16 *)(s0 + 0xA);
+            v[2] = *(u16 *)(s0 + 0xE);
+            func_8012E32C();
+            RotTransPers((s32)v, (s32)&sxy, &z, &flag);
+            sx = (s16)*(u16 *)&sxy;
+            pan = (sx + 0xA0) / 0x14;
+            if (sx < 0) {
+                vol = (sx >> 1) + 0x7F;
+            } else {
+                vol = 0x7F - (sx >> 1);
+            }
+            if ((u32)(pan & 0xFFFF) < 0x10) {
+                s32 row = vol - 0x2F;
+                __asm__("" : "=r"(row) : "0"(row));
+                if ((u32)(row & 0xFFFF) < 0x51) {
+                func_8002D4C8(s1, (vol | 0x3000 | (pan << 8)) & 0xFFFF);
+                }
+            }
+        }
+    }
+
+    {
+        s32 p = *(s32 *)(s0 + 0x20);
+        *(s16 *)(p + 0x10) = *(u16 *)(p + 0x10) + *(u16 *)(s0 + 0x100);
+    }
+    func_8017E9C0(s0);
+}
+
 
 
 extern void (*D_80184868[])(void);
diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c b/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
index 9a829852b8..601a34ed8e 100644
--- a/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
+++ b/src/ov_SC03_111/ov_SC03_111_jr_8017EC58.c
@@ -3938,13 +3938,119 @@ void func_8018151C(u8 *a0) {
 }
 
 
-extern void func_80181574(s32 a0, s32 a1, s32 a2);
+extern void func_80181574();
     void func_8018154C(void * arg0) {
         func_80181574(arg0, *(s16 *)((char *)arg0 + 0xfc), 0x406040);
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8017EC58", func_80181574);
+#include "common.h"
+
+#ifndef gte_ldv3
+#define gte_ldv3(r0, r1, r2) __asm__ volatile (  \
+    "lwc2 $0, 0( %0 );"                          \
+    "lwc2 $1, 4( %0 );"                          \
+    "lwc2 $2, 0( %1 );"                          \
+    "lwc2 $3, 4( %1 );"                          \
+    "lwc2 $4, 0( %2 );"                          \
+    "lwc2 $5, 4( %2 )"                           \
+    :                                            \
+    : "r"( r0 ), "r"( r1 ), "r"( r2 ) )
+#endif
+#ifndef gte_rtpt
+#define gte_rtpt() __asm__ volatile ("nop;nop;rtpt")
+#endif
+#ifndef gte_stsxy3
+#define gte_stsxy3(r0, r1, r2) __asm__ volatile ( \
+    "swc2 $12, 0( %0 );"                         \
+    "swc2 $13, 0( %1 );"                         \
+    "swc2 $14, 0( %2 )"                          \
+    :                                            \
+    : "r"( r0 ), "r"( r1 ), "r"( r2 )            \
+    : "memory" )
+#endif
+
+typedef struct { s16 vx, vy, vz, pad; } SV_80181574;
+typedef struct { u16 vx, vy, vz, pad; } SXY_80181574;
+typedef struct { u16 u, v; } UV_80181574;
+typedef struct {
+    SV_80181574 v[4];  /* 0x00 */
+    UV_80181574 uv[4]; /* 0x20 */
+    u32 rgb[4];        /* 0x30 */
+    u32 flags;         /* 0x40 */
+    u8  clut;          /* 0x44 */
+} Desc_80181574;       /* 0x48 */
+typedef struct { s16 m[3][3]; s32 t[3]; } MTX_80181574;  /* 0x20 */
+typedef struct { u16 f0, f1, f2, f3; } Tbl_80181574;
+
+extern void func_80017D98(void *a0);
+extern void func_80017E8C(s32 a0);
+extern void func_800178EC(s32 a0);
+extern u8 D_80188B70[];
+extern u8 D_80188B78[];
+extern u8 D_80188B80[];
+extern Tbl_80181574 D_80188B88[];
+
+void func_80181574(s16 *arg0, s32 arg1, s32 arg2)
+{
+    SXY_80181574 sxy[6];
+    MTX_80181574 mtx;
+    Desc_80181574 desc;
+    Desc_80181574 *d;
+    Tbl_80181574 *p;
+    s32 t;
+    s32 i;
+
+    desc.v[0].vz = 3;
+    desc.rgb[0] = 0x00100101;
+    desc.clut = 0x31;
+    desc.rgb[1] = arg2;
+    desc.rgb[2] = 0;
+    desc.rgb[3] = 0x00101010;
+    desc.flags = 0x50000000;
+
+    func_80017D98(&mtx);
+    mtx.t[0] = arg0[3];
+    mtx.t[1] = arg0[5];
+    mtx.t[2] = arg0[7];
+    func_80017E8C((s32)&mtx);
+
+    t = arg1;
+    d = &desc;
+    gte_ldv3(D_80188B78, D_80188B80, D_80188B70);
+    gte_rtpt();
+    gte_stsxy3(&sxy[0], &sxy[1], &sxy[2]);
+
+    i = 0;
+    arg1 += 0xC40;
+    desc.v[0].vz = 3;
+    for (; i < 4; i++) {
+        p = &D_80188B88[i];
+        d->v[0].vx = sxy[1].vx;
+        d->v[0].vy = sxy[1].vy + p->f2;
+        d->v[1].vx = sxy[0].vx;
+        d->v[1].vy = sxy[0].vy;
+        d->v[2].vx = sxy[1].vx + p->f1;
+        d->v[2].vy = sxy[1].vy + p->f3;
+        d->v[3].vx = sxy[0].vx + p->f0;
+        d->v[3].vy = sxy[0].vy;
+        d->uv[0].u = arg1;
+        d->uv[0].v = 0x1FF;
+        d->uv[1].u = t + 0xC20;
+        d->uv[1].v = 0x100;
+        d->uv[2].u = p->f1 + arg1;
+        d->uv[2].v = 0x1FF;
+        d->uv[3].u = p->f0 + arg1;
+        d->uv[3].v = 0x100;
+        func_800178EC((s32)d);
+        d->v[2].vx = sxy[1].vx - p->f1;
+        d->v[3].vx = sxy[0].vx - p->f0;
+        d->uv[2].u = arg1 - p->f1;
+        d->uv[3].u = arg1 - p->f0;
+        func_800178EC((s32)d);
+    }
+}
+
 
 s32 func_801817CC(void) {
         return 0x4A;
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 80fd3ab568..964b9ed0a2 100644
--- a/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c
+++ b/src/ov_SC03_114/ov_SC03_114_jr_8017BEBC.c
@@ -3468,7 +3468,72 @@ void func_8017D110(s32 param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8017BEBC", func_8017D518);
+/* func_8017D518 (ov_SC03_114, jr_8017BEBC).
+ * Structure copied from the banked twins func_8017DB54 (ov_SC05_011_jr_8017BEBC.c:3604)
+ * and func_8017D588 (ov_SC04_016_jr_8017BEBC.c:3337): same `(pad & 0x840) || !func_800CF8B4()`
+ * guard, same `func_80029178(id) & 0xFF` cascade, same shared `+2` increment tail.
+ * Arity mismatches vs the TU's file-scope decls (func_8017B368 / func_8017B490 declared with one
+ * parameter, func_80178D18 declared (void)) are resolved by CASTING AT THE USE — the idiom this
+ * TU family already banks — so nothing here conflicts with the decls at lines 2536/2546/2623. */
+
+void func_8017D518(void *a0)
+{
+    extern s32 func_800149E0(s32 a0);
+    extern s32 func_800CF8B4();
+    extern s32 func_80029178(s32 arg);
+    extern void func_80029124(s32, s32);
+    extern s32 func_8017B368(s32 param);
+    extern s32 func_8017B490(s32 param);
+    extern void func_800183E0(s32 a0);
+    extern s32 func_801789AC(s32 arg0);
+    extern void func_80178D18(void);
+    extern u8 D_801830F0[];
+    extern u8 D_80183110[];
+    extern u8 D_80183120[];
+    extern s32 D_80182AB0;
+    extern s32 D_80182B60;
+    extern void (*D_80182F88[])(void);
+    extern s32 D_8019A6CC;
+    s32 ent;
+
+    if ((func_800149E0(0) & 0x840) == 0 || func_800CF8B4() == 0) {
+        ent = *(s32 *)((s32)a0 + 0xCC);
+        if ((u8)func_80029178(0x125) != 0) {
+            func_80029124(0x125, 0);
+            ((void (*)(s32, void *))func_8017B368)(*(s32 *)((s32)a0 + 0xCC), D_801830F0);
+        }
+        if ((u8)func_80029178(0x126) != 0) {
+            func_80029124(0x126, 0);
+            ((void (*)(s32, void *))func_8017B368)(*(s32 *)((s32)a0 + 0xCC), D_80183110);
+        }
+        if ((u8)func_80029178(0x127) != 0) {
+            func_80029124(0x127, 0);
+            ((void (*)(s32, void *))func_8017B490)(*(s32 *)((s32)a0 + 0xCC), D_80183120);
+        }
+        if ((u8)func_80029178(0x128) != 0) {
+            func_80029124(0x128, 0);
+            *(s32 *)(*(s32 *)(*(s32 *)(*(s32 *)((s32)a0 + 0xCC) + 0x64) + 0xD8) + 0xF8) = (s32)D_80182F88;
+        }
+        if ((u8)func_80029178(0x129) != 0) {
+            func_80029124(0x129, 0);
+            *(s32 *)(*(s32 *)(*(s32 *)(*(s32 *)((s32)a0 + 0xCC) + 0x64) + 0xD4) + 0xF8) = (s32)&D_80182AB0;
+        }
+        if ((u8)func_80029178(0x12A) != 0) {
+            func_80029124(0x12A, 0);
+            *(s32 *)(*(s32 *)(*(s32 *)(*(s32 *)((s32)a0 + 0xCC) + 0x64) + 0xD4) + 0xF8) = (s32)&D_80182B60;
+        }
+        if ((u8)func_80029178(0x12B) != 0) {
+            func_80029124(0x12B, 0);
+            func_800183E0((s32)&D_8019A6CC);
+        }
+        if (func_801789AC(ent) == 0) {
+            return;
+        }
+        ((void (*)(s32))func_80178D18)(ent);
+    }
+    *(u16 *)((s32)a0 + 2) = *(u16 *)((s32)a0 + 2) + 1;
+}
+
 
 
 extern void (*D_80183228[])(void);
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 7652bd92a3..e4d2e7e380 100644
--- a/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
+++ b/src/ov_SC03_115/ov_SC03_115_jr_8017BEBC.c
@@ -3521,7 +3521,26 @@ void func_8017D628(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8017BEBC", func_8017D684);
+extern s32 func_800291B4(s32 arg);
+extern void func_800291A0(s32, s32);
+extern void func_800D0F0C(s32, s32);
+
+void func_8017D684(s32 param_1) {
+    extern void func_800D0F4C(s32);
+    extern void func_8012A828(s32 *a0, s32 a1);
+    extern void (*D_80183F70[][2])(void);
+
+    s32 v0;
+    s32 v1;
+
+    v0 = func_800291B4(0xDE);
+    v1 = ((s32 (*)(s32))func_800D0F4C)((v0 + 0x62) & 0xFF);
+    func_800291A0(0xDE, *(u8 *)(param_1 + 0x70));
+    func_800D0F0C(v1, *(s16 *)(param_1 + 0x70) + 0x62);
+    *(s16 *)(param_1 + 0x70) = v0 & 0xFF;
+    func_8012A828((s32 *)param_1, (s32)&D_80183F70[v0 & 0xFF]);
+}
+
 
 extern s32 func_8017D058(void);
     void func_8017D710(void) {
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 f9a21118bf..b77cdcb94e 100644
--- a/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c
+++ b/src/ov_SC03_125/ov_SC03_125_jr_8017D604.c
@@ -3678,7 +3678,28 @@ void *a0;
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8017D604", func_8017F258);
+extern s32 func_80029504(void);
+extern s32 func_80029178(s32 a0);
+extern void func_8012CAE4(void *a0);
+
+void func_8017F258(void *a0) {
+    s32 v0;
+
+    v0 = func_80029504();
+    if ((u32)(v0 - 0xC8) >= 10) {
+        goto L28;
+    }
+    if ((func_80029178(0xF4) & 0xFF) == 0) {
+        goto L38;
+    }
+L28:
+    func_8012CAE4(a0);
+    return;
+L38:
+    *(s16 *)((s32)a0 + 0x2) = 1;
+    *(u16 *)((s32)a0 + 0x34) = 0;
+}
+
 
 extern s32 func_80029178(s32 arg);
 extern void func_800D06CC(void);
diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
index 5cf3e90627..07e3a003ff 100644
--- a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
+++ b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c
@@ -8528,7 +8528,25 @@ extern void func_80016714(void *a0, s32 a1);
     }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80183B9C);
+extern s32 func_8012BCCC(s32 a0);
+extern void func_801833EC(s32 a0);
+
+void func_80183B9C(s32 a0) {
+    s32 iVar1;
+
+    if (*(s16 *)(a0 + 0x70) & 0x8000) {
+        iVar1 = func_8012BCCC(a0);
+        if (iVar1 <= 0x90000) {
+            func_801833EC(a0);
+        }
+    } else {
+        iVar1 = func_8012BCCC(a0);
+        if (iVar1 <= 0x24000) {
+            func_801833EC(a0);
+        }
+    }
+}
+
 
 extern s32 func_8012BEE8(s32 arg);
     extern void func_8018342C(s32 a0);
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
index 16e80b5830..e639491875 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8017D494.c
@@ -9550,7 +9550,63 @@ s32 func_80187940(s32 arg0, s32 arg1, s32 arg2, s16 arg3)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8017D494", func_80187A04);
+#include "common.h"
+
+extern void func_8004914C(void *a0);
+extern void func_800491AC(void *a0);
+extern void RotTransSV(void *a0, void *a1, void *a2);
+extern s32 func_8012B70C(s16 *a0, s16 *a1);
+extern void func_80188B78(u8 *a0);
+extern u8 D_801202A0[];
+
+typedef struct { s16 vx, vy, vz, pad; } SV_80187A04;
+
+void func_80187A04(void *a0)
+{
+    SV_80187A04 self;
+    SV_80187A04 probe;
+    s32 unused;
+    u16 *p;
+    s32 i;
+    s32 dist0;
+    s32 dist;
+    s16 diff;
+
+    func_8004914C((void *)(*(s32 *)((s32)a0 + 0x20) + 0x54));
+    func_800491AC((void *)(*(s32 *)((s32)a0 + 0x20) + 0x54));
+
+    self.vx = *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x68);
+    self.vy = *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x6C);
+    self.vz = *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x70);
+
+    probe.vx = 0;
+    probe.vy = 0;
+    probe.vz = -0x280;
+    RotTransSV(&probe, &probe, &unused);
+
+    dist0 = func_8012B70C((s16 *)&self, (s16 *)&probe);
+
+    p = (u16 *)D_801202A0;
+    i = 0;
+    do {
+        if (*p == 0x2A9) {
+            probe.vx = p[3];
+            probe.vy = p[5];
+            probe.vz = p[7];
+            dist = func_8012B70C((s16 *)&self, (s16 *)&probe);
+            diff = dist - dist0;
+            if (diff < 0) {
+                diff = -diff;
+            }
+            if (diff < 0x80) {
+                func_80188B78((u8 *)p);
+            }
+        }
+        i = i + 1;
+        p = (u16 *)((u8 *)p + 0x10C);
+    } while (i < 0x60);
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c b/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
index e0763c60dd..4a8c524780 100644
--- a/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
+++ b/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
@@ -4328,7 +4328,48 @@ void func_8017DE74(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8017AE2C", func_8017DED4);
+extern s32 rand(void);
+extern void func_800139C8(s32 a0, void *a1, void *a2);
+extern s32 D_801930C8;
+
+typedef struct {
+    s16 vx, vy, vz, pad;
+} UVec_8017DED4;
+
+void func_8017DED4(s32 param_1)
+{
+    UVec_8017DED4 v;
+    s16 lim;
+
+    v.vx = ((rand() & 1) << 8) + ((rand() & 0x1F) << 3) + (rand() & 0x1F);
+    v.vz = 0;
+    v.vy = 0;
+
+    func_800139C8(((rand() & 3) << 10) + ((rand() & 0x1F) << 5) + ((rand() & 3) << 8) + (rand() & 0xFF), &v, &v);
+
+    if (v.vx > *(s16 *)D_801930C8) {
+        lim = *(s16 *)D_801930C8;
+        v.vx = v.vx - lim;
+    } else if (v.vx < -*(s16 *)D_801930C8) {
+        lim = *(s16 *)D_801930C8;
+        v.vx = lim + v.vx;
+    }
+
+    if (v.vz > *(s16 *)(D_801930C8 + 2)) {
+        lim = *(s16 *)(D_801930C8 + 2);
+        v.vz = v.vz - lim;
+    } else if (v.vz < -*(s16 *)(D_801930C8 + 2)) {
+        lim = *(s16 *)(D_801930C8 + 2);
+        v.vz = lim + v.vz;
+    }
+
+    *(u16 *)(param_1 + 6) += v.vx;
+    *(u16 *)(param_1 + 0xA) += v.vy;
+    *(u16 *)(param_1 + 0xE) += v.vz;
+
+    *(u16 *)(param_1 + 0x16) = (rand() & 7) + 8;
+}
+
 
 
 
diff --git a/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c b/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c
index fa4bb521a8..76971b5c04 100644
--- a/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c
+++ b/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c
@@ -4617,7 +4617,45 @@ void func_8017EC60(s32 a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_jr_8017BEBC", func_8017ECC4);
+extern void Square0(s32 *a0, s32 *a1);
+extern s32 D_80126B58;
+extern u16 D_80126B5E;
+extern u16 D_80126B62;
+extern u16 D_80126B66;
+extern s32 D_80126B8C;
+
+void func_8017ECC4(s16 *a0) {
+    s32 in[3];
+    s32 out[3];
+    s32 *p = &D_80126B58;
+    s32 v1;
+
+    if (a0[0x7E] == 0) {
+        return;
+    }
+    in[0] = a0[3] - *(s16 *)&D_80126B5E;
+    in[1] = 0;
+    in[2] = a0[7] - *(s16 *)&D_80126B66;
+    Square0(in, out);
+    if (0x3C100 < out[0] + out[2]) {
+        return;
+    }
+    out[1] = a0[5] - *(s16 *)&D_80126B62;
+    if ((u32)(out[1] + 8) >= 0x1C9) {
+        return;
+    }
+    if ((u32)*(u16 *)p - 2 >= 2) {
+        D_80126B8C = 0;
+        D_80126B62 = *(s16 *)&D_80126B62 - 4;
+    }
+    if (a0[0x7E] >= 0x81) {
+        v1 = -0x40000;
+    } else {
+        v1 = -(a0[0x7E] << 11);
+    }
+    p[13] += v1;
+}
+
 
 
 extern void (*D_80198728[])(void);
diff --git a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
index f5b7a52dfc..708d84a2fe 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c
@@ -5705,7 +5705,72 @@ s32 func_80187F48(s32 arg0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80187FCC);
+extern void func_80149020(s32 *a0);
+extern void func_80148038(s32 a0, s32 a1);
+extern void func_80147460(s32 a0);
+extern s32 func_801535F4(void *a0);
+extern s32 func_80146E98(s32 a0);
+extern int func_801511E0(int arg);
+extern void func_80146E90(s32 *a0, s32 a1);
+extern void func_8013C9C4(void *a0);
+extern void func_80146CA0(void *a0);
+extern s32 D_801C3D28;
+
+void func_80187FCC(s32 arg0)
+{
+    s32 s0 = arg0;
+    s32 v0;
+    s32 v1;
+    s32 pad[8];
+
+    func_80149020((s32 *)arg0);
+
+    v1 = *(s32 *)(s0 + 0x20);
+    *(u16 *)(v1 + 0x12) = (*(u16 *)(v1 + 0x12) + 0x5B) & 0xFFF;
+
+    v1 = *(s32 *)(s0 + 0x20);
+    *(u16 *)(v1 + 0x10) = (*(u16 *)(v1 + 0x10) - 0x16) & 0xFFF;
+
+    v1 = *(s32 *)(s0 + 0x20);
+    if (*(s16 *)(v1 + 0x10) < 0xC00) {
+        v0 = -0x400;
+        *(u16 *)(v1 + 0x10) = v0;
+    }
+
+    func_80148038((s32)s0, 0x10000);
+    func_80147460((s32)s0);
+
+    if (*(s32 *)(s0 + 0x234) == 0) {
+        if (*(s32 *)(s0 + 0x34) >= 0) {
+            if ((*(u16 *)(s0 + 0xB8) & 0x8000) != 0) {
+                *(u16 *)(s0 + 0xB8) = *(u16 *)(s0 + 0xBA);
+            }
+        }
+    }
+
+    v0 = func_801535F4((void *)s0);
+    if (v0 == 0) {
+        goto L801880AC;
+    }
+    if (v0 < 0) {
+        goto L801880AC;
+    }
+    if (v0 < 3) {
+        goto L801880BC;
+    }
+L801880AC:
+    v0 = func_80146E98((s32)s0);
+    if (v0 == 0) {
+        return;
+    }
+L801880BC:
+    func_801511E0((s32)s0);
+    func_80146E90((s32 *)s0, 0x1E);
+    func_8013C9C4((void *)&D_801C3D28);
+    func_80146CA0((void *)s0);
+    (void)pad;
+}
+
 
 extern s32 func_80146E98(s32 a0);
 extern s32 func_80188168();
diff --git a/src/ov_SC05_011/ov_SC05_011_jr_8017BEBC.c b/src/ov_SC05_011/ov_SC05_011_jr_8017BEBC.c
index 10c038b8ad..a5de2de6ff 100644
--- a/src/ov_SC05_011/ov_SC05_011_jr_8017BEBC.c
+++ b/src/ov_SC05_011/ov_SC05_011_jr_8017BEBC.c
@@ -3319,7 +3319,37 @@ void func_8017D0EC(s32 param_1, s16 *param_2) {
 
 INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_011_jr_8017BEBC", func_8017D118);
 
-INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_011_jr_8017BEBC", func_8017D174);
+void func_8017D174(void)
+{
+    extern s32 D_8019D068;
+    s16 sp10[4];
+    s16 sp18[4];
+    s32 temp;
+
+    if (*(u8 *)&D_8019D068 == 0) {
+        sp10[0] = 0x300;
+        sp10[1] = 0x180;
+        sp10[2] = 0x100;
+        sp10[3] = 0x80;
+        MoveImage(sp10, 0x300, 0x100);
+    } else {
+        temp = *(u8 *)&D_8019D068;
+        sp10[0] = temp + 0x300;
+        sp10[1] = 0x180;
+        sp10[2] = 0x100 - temp;
+        sp10[3] = 0x80;
+        MoveImage(sp10, 0x300, 0x100);
+
+        sp18[0] = 0x300;
+        sp18[1] = 0x180;
+        sp18[2] = temp;
+        sp18[3] = 0x80;
+        MoveImage(sp18, 0x400 - temp, 0x100);
+    }
+
+    D_8019D068 -= 1;
+}
+
 
 typedef struct {
     s16 unk00;
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 aa1e56508d..355d41470d 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8017BEBC.c
@@ -4777,7 +4777,47 @@ void func_8018096C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8017BEBC", func_801809A8);
+extern s32 func_8012C354(s32 a0, void *a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B2CC(s32 a0);
+extern s32 func_8012C658(s32 a0, s32 a1, s32 a2);
+extern u8 D_80193688[];
+extern u8 D_801936C8[];
+
+void func_801809A8(s32 a0)
+{
+    register s32 s0 __asm__("$16") = a0;
+    s32 v1;
+
+    if (func_8012C354(a0, &D_80193688) != 0) {
+        *(u8 *)(s0 + 0xC0) = 1;
+        *(s32 *)(s0 + 0xB4) = -1;
+        *(s16 *)(s0 + 0xAE) = -1;
+        *(u8 *)(s0 + 0x75) = 8;
+        func_8012A828(s0, &D_801936C8);
+        __asm__("" : "=r"(s0) : "0"(s0));
+        if (*(s16 *)(s0 + 0x70) != 0) {
+            *(s16 *)(s0 + 2) = 4;
+        } else {
+            *(s16 *)(s0 + 2) = 1;
+            *(u32 *)(*(s32 *)(s0 + 0x20) + 4) |= 0x80000000;
+            func_8012B2CC(s0);
+            v1 = func_8012C658(0x346, 1, s0);
+            if (v1 != 0) {
+                *(s16 *)(v1 + 6) = -0x660;
+                *(s16 *)(v1 + 0xA) = -0x682;
+                *(s16 *)(v1 + 0xE) = 0x80;
+            }
+            v1 = func_8012C658(0x346, 1, s0);
+            if (v1 != 0) {
+                *(s16 *)(v1 + 6) = -0xA60;
+                *(s16 *)(v1 + 0xA) = -0x882;
+                *(s16 *)(v1 + 0xE) = 0x80;
+            }
+        }
+    }
+}
+
 
 extern u8 D_801202A0[];
 
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
index 0f94ccb207..32c420465a 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c
@@ -3842,7 +3842,74 @@ s32 func_8017E21C(void) {
 
 INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017E224);
 
-INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017E3EC);
+extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012CBCC(s32 a0);
+extern void func_8012BE54(s32 a0);
+extern s32 func_8012B8A4(s16 *a0);
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80047948(s32 a0);
+
+void func_8017E3EC(s32 a0)
+{
+    extern u8 D_80126B5C;
+    extern s32 D_80126B64;
+
+    s32 s0;
+    s32 v0;
+    s32 v1;
+
+    switch (*(u16 *)(a0 + 0x34)) {
+    case 0:
+        s0 = func_8012C658(0x263, 1, a0);
+        if (s0 != 0) {
+            *(u16 *)(s0 + 0xFC) = 0x60;
+            *(s32 *)(a0 + 0xD0) = s0;
+            v1 = *(u16 *)(s0 + 0x36);
+            *(u16 *)(a0 + 0x34) = 1;
+            *(u16 *)(a0 + 0x108) = v1;
+            func_8002D4C8(0xB23, 0);
+        }
+        break;
+    case 1:
+        v0 = *(u16 *)(a0 + 0xA) - 4;
+        *(u16 *)(a0 + 0xA) = v0;
+        if ((s16)v0 < -0x3DF) {
+            *(u16 *)(a0 + 0x34) = 2;
+        }
+        v0 = *(u16 *)(a0 + 0xA) - 0x20;
+        s0 = *(s32 *)(a0 + 0xD0);
+        *(u16 *)(s0 + 0xA) = v0;
+        break;
+    case 2:
+        s0 = *(s32 *)(a0 + 0xD0);
+        v0 = -0x18;
+        *(u16 *)(s0 + 0x16) = v0;
+        v0 = -8;
+        *(u16 *)(s0 + 0x12) = v0;
+        v0 = 3;
+        *(u16 *)(a0 + 0x34) = v0;
+        break;
+    case 3:
+        s0 = *(s32 *)(a0 + 0xD0);
+        if (((s32 (*)(s32))func_8012CBCC)(s0) != 0 || *(s16 *)(s0 + 0xFC) == 0) {
+            *(u16 *)(a0 + 0x2) = 4;
+            *(u16 *)(a0 + 0x34) = 0;
+        }
+        break;
+    }
+
+    if (((s32 (*)(s32))func_8012BE54)(a0) <= 0x9000) {
+        s0 = func_8012B8A4((s16 *)a0);
+        v1 = func_8004787C(s0);
+        v0 = *(s32 *)(a0 + 4) - (v1 + v1 * 2) * 0x400;
+        *(s32 *)&D_80126B5C = v0;
+        v1 = func_80047948(s0);
+        v0 = *(s32 *)(a0 + 0xC) - (v1 + v1 * 2) * 0x400;
+        D_80126B64 = v0;
+    }
+}
+
 
 
 extern void func_8012DFD4(void *a0);
diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c b/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c
index 2db551a4b4..cf10d50167 100644
--- a/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c
+++ b/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c
@@ -5021,7 +5021,45 @@ void func_801801F4(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8017BEBC", func_80180230);
+extern s32 func_8012C354(s32 a0, s32 a1);
+extern void func_8012B0B4(u32 *a0, s32 a1, s32 a2);
+extern u8 D_801853A0;
+extern void D_801853D4(void *a0);
+
+void func_80180230(s32 param_1)
+{
+    s32 v0;
+    s32 v1;
+    s32 angle;
+    s16 mod;
+    s32 val;
+    s32 sp10;
+
+    if (func_8012C354(param_1, (s32)&D_801853A0) != 0) {
+        v0 = *(s32 *)(*(s32 *)(param_1 + 0x78) + 8) | 0x40000000;
+        *(s32 *)(param_1 + 0x58) = v0;
+        v1 = *(s32 *)(param_1 + 0x20);
+        *(s32 *)(v1 + 0x20) = (s32)D_801853D4;
+
+        angle = (s16)*(u16 *)(param_1 + 0x70);
+        mod = angle % 12;
+        val = 0x800 - (mod + 1) * 341;
+
+        func_8012B0B4((u32 *)&sp10, (s16)val, 0x29C);
+
+        *(s16 *)(param_1 + 6) = (s16)sp10;
+        *(s16 *)(param_1 + 0xE) = (s16)(sp10 >> 16);
+        {
+            s32 v70 = *(s16 *)(param_1 + 0x70);
+            s32 shifted = v70 << 6;
+            *(s16 *)(param_1 + 0xA) = -0x552 - shifted;
+        }
+        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = val + 0x800;
+        *(u8 *)(param_1 + 0x75) = 2;
+        *(s16 *)(param_1 + 2) = 1;
+    }
+}
+
 
 void func_80180350(s32 a0)
 {
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
index b15e82dfef..45cb2ba75c 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -8689,7 +8689,31 @@ void func_8018637C(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_801863B0);
+extern s32 func_8004787C(s32 a0);
+extern s32 func_80047948(s32 a0);
+
+void func_801863B0(s32 param_1) {
+
+    extern u8 *func_8012913C(s32 a0);
+    extern void func_800159E4(s32 a0, s32 a1);
+
+    u8 *s0;
+    s32 i;
+    s32 v1;
+
+    for (i = 0; i < 0x1000; i += 0x100) {
+        s0 = func_8012913C(0x22);
+        if (s0 != 0) {
+            func_800159E4(param_1 + 4, (s32)s0 + 4);
+            *(s32 *)(s0 + 0x10) = func_80047948(i) * 0x140;
+            *(s32 *)(s0 + 0x18) = func_8004787C(i) * 0x140;
+            *(s16 *)(s0 + 0x34) = 0x3000;
+            v1 = *(s32 *)(s0 + 0x20);
+            *(u16 *)(v1 + 0x2c) = 0xc002;
+        }
+    }
+}
+
 
 
 extern void (*D_80198BA0[])(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 b0e475d8cd..33fe146477 100644
--- a/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c
+++ b/src/ov_SC07_011/ov_SC07_011_jr_8017BEBC.c
@@ -4340,7 +4340,29 @@ void func_8017DB54(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8017BEBC", func_8017DB90);
+void func_8017DB90(void *param_1) {
+    extern s32 func_80014C54(s32 a0, s32 a1, s32 a2);
+    extern s32 func_800CF8B4();
+    extern s32 D_80182314[];
+    extern void func_800D1724(s32 a0);
+    extern void func_80029514(s32);
+    extern void func_8002AC00(s32 a0);
+    extern s32 func_8012AD50(void *a0);
+
+    if (((s16)func_80014C54(0, 0, 0x800) != 0 ||
+         (s16)func_80014C54(0, 0, 0x40) != 0) &&
+        func_800CF8B4() != 0) {
+        func_800D1724(D_80182314[*(s16 *)((s32)param_1 + 0x70)]);
+        if (*(s16 *)((s32)param_1 + 0x70) != 1 &&
+            *(s16 *)((s32)param_1 + 0x70) >= 2 &&
+            *(s16 *)((s32)param_1 + 0x70) == 2) {
+            func_80029514(0x398);
+            func_8002AC00(0x1D);
+        }
+        func_8012AD50(param_1);
+    }
+}
+
 
 void func_8017DC50(void) {
 }
@@ -4395,7 +4417,61 @@ void func_8017DD78(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8017BEBC", func_8017DDB4);
+extern void func_8012C1B8(void);
+extern void func_8001C2C4(s32 a0);
+extern void func_8017DF70(void *a0, void *a1, s32 a2);
+extern void func_8017E294(void *param_1);
+extern s32 func_8012AD50(void *a0);
+extern s32 rand(void);
+
+extern u8 D_8018D244;
+extern s32 D_8018D51C;
+extern s32 D_8018D7F4;
+
+void func_8017DDB4(void *param_1) {
+    s32 iVar2;
+
+    *(s32 *)((s32)param_1 + 0x20) = 0;
+    *(s32 *)((s32)param_1 + 0xCC) = 0;
+    *(s32 *)((s32)param_1 + 0xD0) = 0;
+
+    iVar2 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)param_1 + 0x20) = iVar2;
+    if (iVar2 == 0) {
+        goto fail;
+    }
+    func_8001C2C4(iVar2);
+
+    iVar2 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)param_1 + 0xCC) = iVar2;
+    if (iVar2 == 0) {
+        goto fail;
+    }
+    func_8001C2C4(iVar2);
+
+    iVar2 = ((s32 (*)(void))func_8012C1B8)();
+    *(s32 *)((s32)param_1 + 0xD0) = iVar2;
+    if (iVar2 == 0) {
+        goto fail;
+    }
+    func_8001C2C4(iVar2);
+
+    goto body;
+
+fail:
+    func_8017E294(param_1);
+    return;
+
+body:
+    func_8017DF70(param_1, *(void **)((s32)param_1 + 0x20), (s32)&D_8018D244);
+    func_8017DF70(param_1, *(void **)((s32)param_1 + 0xCC), (s32)&D_8018D51C);
+    func_8017DF70(param_1, *(void **)((s32)param_1 + 0xD0), (s32)&D_8018D7F4);
+
+    *(u16 *)((s32)param_1 + 0xFC) = (rand() & 3) << 10;
+    *(u16 *)((s32)param_1 + 0xFE) = 0;
+    func_8012AD50(param_1);
+}
+
 
 void func_8017DE9C(void *param_1) {
     extern void func_8017DFE8();