From 4c7550f97e722d421ad0f4afa3fe08b1ca56ea70 Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Sun, 30 Aug 2026 11:15:07 -0600
Subject: [PATCH] =?UTF-8?q?feat(decomp):=20parallel=20gate=20=E2=80=94=202?=
 =?UTF-8?q?1=20fns=20across=2021=20binaries=20(10=20workers)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

  md_MAIN_003    func_800D05B4
  md_MAIN_016    func_800CB158
  ov_SC01_009    func_8017F2A0
  ov_SC02_016    func_80182D54
  ov_SC01_080    func_80181918
  ov_SC03_001    func_80186A8C
  ov_SC03_029    func_80181600
  ov_SC03_101    func_80180864
  ov_SC03_091    func_801826C8
  ov_SC03_092    func_8017DF40
  ov_SC03_102    func_8018153C
  ov_SC03_103    func_8017E830
  ov_SC03_124    func_8018A3C8
  ov_SC03_105    func_801839A4
  ov_SC04_008    func_8017D8C4
  ov_SC04_012    func_8017DAE4
  ov_SC04_018    func_80180284
  ov_SC05_004    func_8017EF0C
  ov_SC06_025    func_801808AC
  ov_SC06_016    func_801813B0
  ov_SC07_002    func_801804D4
---
 src/md_MAIN_003/md_MAIN_003.c             | 72 ++++++++++++++++++++++-
 src/md_MAIN_016/md_MAIN_016.c             | 33 ++++++++++-
 src/ov_SC01_009/ov_SC01_009_jr_8017E590.c | 38 +++++++++++-
 src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c | 24 +++++++-
 src/ov_SC02_016/ov_SC02_016_jr_801810C8.c | 41 ++++++++++++-
 src/ov_SC03_001/ov_SC03_001_jr_8018631C.c | 29 ++++++++-
 src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c | 43 +++++++++++++-
 src/ov_SC03_091/ov_SC03_091_jr_80182268.c | 32 +++++++++-
 src/ov_SC03_092/ov_SC03_092_jr_8017AE2C.c | 36 +++++++++++-
 src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c | 34 ++++++++++-
 src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c | 27 ++++++++-
 src/ov_SC03_103/ov_SC03_103_jr_8017C294.c | 29 ++++++++-
 src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c | 28 ++++++++-
 src/ov_SC03_124/ov_SC03_124_jr_80188544.c | 29 ++++++++-
 src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c | 30 +++++++++-
 src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c | 37 +++++++++++-
 src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c | 44 +++++++++++++-
 src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c | 37 +++++++++++-
 src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c | 49 ++++++++++++++-
 src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c | 35 ++++++++++-
 src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c | 30 +++++++++-
 21 files changed, 735 insertions(+), 22 deletions(-)

diff --git a/src/md_MAIN_003/md_MAIN_003.c b/src/md_MAIN_003/md_MAIN_003.c
index 8b595749b..1014e9cb1 100644
--- a/src/md_MAIN_003/md_MAIN_003.c
+++ b/src/md_MAIN_003/md_MAIN_003.c
@@ -627,7 +627,77 @@ __asm__(".text\n.align 2\n.globl func_800D0440\n.ent\tfunc_800D0440\n"
 ".set\treorder\n.end\tfunc_800D0440\n");
 
 
-INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D05B4);
+/* func_800D05B4 - VERBATIM-ASM BANK (cookbook sec 265, file-scope form #1).
+ * -O0 body (addu $fp,$sp,$zero prologue) stranded inside md_MAIN_003's -O2 object
+ * (sec 261/6 -- nothing under src/md_ globs -O0 yet). Recovered C semantics for the
+ * eventual real decomp (register u8 *s0 = D_800AF630):
+ *
+ *     func_8001C044();
+ *     func_80015310();
+ *     s0[0xA3E1] = 0;
+ *     D_800EC890 = 0;
+ *     D_800EC8A0 = 1;
+ *     func_800183E0((s32)&D_800D4E6C);
+ *     func_800183E0((s32)&D_800D52BC);
+ *     D_800EC894 = 0;
+ *     D_800EC88C = -1;
+ *     *(u16 *)(s0 + 0xA3B8) = 0;
+ *     func_800118AC();
+ *
+ * Siblings func_800D0440/func_800D06BC/func_800D09A0 (same TU) are the same shape
+ * banked the same way; frame/mask (48/0xC0010000,-16) matches the ra/fp/s0 save set
+ * used throughout this file's verbatim-asm blocks. No C externs shipped (link-time
+ * resolution).
+ */
+__asm__(".text\n.align 2\n.globl func_800D05B4\n.ent\tfunc_800D05B4\n"
+"func_800D05B4:\n.frame $sp,48,$31\n.mask 0xC0010000,-16\n.fmask 0,0\n"
+".set\tnoreorder\n"
+"addiu $sp, $sp, -48\n"
+"sw $ra, 40($sp)\n"
+"sw $fp, 36($sp)\n"
+"sw $s0, 32($sp)\n"
+"addu $fp, $sp, $zero\n"
+"lui $s0, %hi(D_800AF630)\n"
+"addiu $s0, $s0, %lo(D_800AF630)\n"
+"jal func_8001C044\n"
+"nop\n"
+"jal func_80015310\n"
+"nop\n"
+"lui $at, 1\n"
+"addu $at, $s0, $at\n"
+"sb $zero, -23583($at)\n"
+"lui $at, %hi(D_800EC890)\n"
+"sw $zero, %lo(D_800EC890)($at)\n"
+"addiu $v0, $zero, 1\n"
+"lui $at, %hi(D_800EC8A0)\n"
+"sw $v0, %lo(D_800EC8A0)($at)\n"
+"lui $a0, %hi(D_800D4E6C)\n"
+"addiu $a0, $a0, %lo(D_800D4E6C)\n"
+"jal func_800183E0\n"
+"nop\n"
+"lui $a0, %hi(D_800D52BC)\n"
+"addiu $a0, $a0, %lo(D_800D52BC)\n"
+"jal func_800183E0\n"
+"nop\n"
+"lui $at, %hi(D_800EC894)\n"
+"sh $zero, %lo(D_800EC894)($at)\n"
+"addiu $v0, $zero, -1\n"
+"lui $at, %hi(D_800EC88C)\n"
+"sw $v0, %lo(D_800EC88C)($at)\n"
+"lui $at, 1\n"
+"addu $at, $s0, $at\n"
+"sh $zero, -23624($at)\n"
+"jal func_800118AC\n"
+"nop\n"
+"addu $sp, $fp, $zero\n"
+"lw $ra, 40($sp)\n"
+"lw $fp, 36($sp)\n"
+"lw $s0, 32($sp)\n"
+"addiu $sp, $sp, 48\n"
+"jr $ra\n"
+"nop\n"
+".set\treorder\n.end\tfunc_800D05B4\n");
+
 
 INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800D0664);
 
diff --git a/src/md_MAIN_016/md_MAIN_016.c b/src/md_MAIN_016/md_MAIN_016.c
index 01a977cd6..10e289b89 100644
--- a/src/md_MAIN_016/md_MAIN_016.c
+++ b/src/md_MAIN_016/md_MAIN_016.c
@@ -74,7 +74,38 @@ void func_800CAF28(void *arg0) {
 
 INCLUDE_ASM("asm/md_MAIN_016/nonmatchings/md_MAIN_016", func_800CAF84);
 
-INCLUDE_ASM("asm/md_MAIN_016/nonmatchings/md_MAIN_016", func_800CB158);
+extern void func_800CAF84();
+
+void func_800CB158(s32 arg0) {
+    typedef struct { s32 w[4]; } Struct16;
+    s32 a0;
+    s32 v0;
+
+    s32 cnt;
+
+    a0 = *(s32 *)(arg0 + 0x34);
+
+    if ((*(s32 *)(arg0 + 0x2C) & 0x8000) == 0) {
+        cnt = *(s32 *)(arg0 + 0x1C);
+        *(s32 *)(arg0 + 0x1C) = cnt + 1;
+
+        if (cnt < 8) {
+            *(u16 *)(arg0 + 0x28) += 0x120;
+        } else {
+            *(s32 *)(arg0 + 0x1C) = 0;
+            *(u16 *)(arg0 + 0x2) = 4;
+        }
+
+        v0 = *(s32 *)(a0 + 0x20);
+        *(Struct16 *)(arg0 + 0x38) = *(Struct16 *)(v0 + 0x34);
+        *(Struct16 *)(arg0 + 0x48) = *(Struct16 *)(v0 + 0x44);
+
+        func_800CAF84(arg0);
+    } else {
+        *(u16 *)(arg0 + 0x2) += 1;
+    }
+}
+
 
 INCLUDE_ASM("asm/md_MAIN_016/nonmatchings/md_MAIN_016", func_800CB228);
 
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 21757ffe9..7bf96b892 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8017E590.c
@@ -3422,7 +3422,43 @@ ret0:
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8017E590", func_8017F2A0);
+extern void func_8012AD80(s32 a0);
+extern void func_8012B1B4(s32 a0, s32 a1);
+extern void func_8012B200(u8 *a0);
+extern void func_8012B2CC(s32 a0);
+
+s32 func_8017F2A0(a0)
+s32 a0;
+{
+    s32 cmd;
+    s32 v;
+
+    cmd = *(s32 *)(a0 + 0xCC);
+    if (cmd == 0) {
+        return 0;
+    }
+    if (*(s32 *)(a0 + 0x1C) == 0) {
+        v = *(s16 *)cmd;
+        cmd += 2;
+        if (v == 0) {
+            func_8012B200((u8 *)a0);
+            *(s32 *)(a0 + 0xCC) = 0;
+            return 0;
+        }
+        *(s32 *)(a0 + 0x1C) = v;
+        *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)cmd;
+        cmd += 2;
+        *(u16 *)(a0 + 0xE6) = *(u16 *)cmd;
+        cmd += 2;
+        func_8012B2CC(a0);
+        *(s32 *)(a0 + 0xCC) = cmd;
+    }
+    *(s32 *)(a0 + 0x1C) -= 1;
+    func_8012B1B4(a0, a0 + 0xDC);
+    func_8012AD80(a0);
+    return 1;
+}
+
 
 
 extern void (*D_801E9A18[])(void);
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
index 553038e37..f84802578 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
@@ -6173,7 +6173,29 @@ void func_801817CC(s32 *a0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181854);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181918);
+extern s32 rand(void);
+extern u16 D_80126B6A;
+extern u16 D_80126B72;
+extern u16 D_80126B5E;
+extern u16 D_80126B62;
+extern u16 D_80126B66;
+
+void func_80181918(s32 arg0) {
+    s32 pad[12];
+    u16 t;
+    register u16 cnt __asm__("$6");
+
+    t = rand();
+    *(u16 *)(arg0 + 6) = D_80126B5E + D_80126B6A * 32 + (t & 0x1FF) - 0xFF;
+    *(u16 *)(arg0 + 0xA) = D_80126B62 - 0x120;
+    cnt = *(u16 *)(arg0 + 2);
+    *(u16 *)(arg0 + 0xE) = D_80126B66 + D_80126B72 * 32 + (t >> 7) - 0xFF;
+    *(s32 *)(arg0 + 0x14) += 0x50000;
+    *(u16 *)(arg0 + 2) = cnt + 1;
+    *(s32 *)(arg0 + 0x1C) = 0x60;
+    *(s32 *)(arg0 + 0x30) = 0x88;
+}
+
 
 extern void func_800D20C0(void *a0, void *a1, s32 a2);
 extern void func_800D23D0(void *a0);
diff --git a/src/ov_SC02_016/ov_SC02_016_jr_801810C8.c b/src/ov_SC02_016/ov_SC02_016_jr_801810C8.c
index 364be8807..1ea9de77e 100644
--- a/src/ov_SC02_016/ov_SC02_016_jr_801810C8.c
+++ b/src/ov_SC02_016/ov_SC02_016_jr_801810C8.c
@@ -4100,7 +4100,46 @@ void func_801829D8(int a, s16 *b, SVECTOR_8017E6D8 *c, SVECTOR_8017E6D8 *d,
 
 
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_801810C8", func_80182D54);
+
+
+extern void func_8012A418(void);
+extern void func_8012A598(void);
+extern void func_8012A018(s32 a, s32 b);
+extern void func_80182E34(void *a0);
+
+extern s32 D_80126954;
+extern s32 D_8012695C;
+extern Blk8 D_80126968;
+extern s16 D_80126976;
+extern s16 D_80126978;
+extern s16 D_8012697A;
+extern s32 D_801269E4;
+
+void func_80182D54(void *a0)
+{
+    u8 *s1;
+    u8 *s0;
+
+    s1 = (u8 *)a0;
+    s0 = *(u8 **)(s1 + 0xDC);
+
+    func_8012A418();
+    func_8012A598();
+
+    D_80126954 = *(s32 *)(s0 + 0);
+    D_8012695C = *(s32 *)(s0 + 4);
+
+    D_80126968 = *(Blk8 *)(s0 + 8);
+
+    D_80126976 = *(s16 *)(s0 + 0x10);
+    D_80126978 = *(s16 *)(s0 + 0x12);
+    D_8012697A = *(s16 *)(s0 + 0x14);
+
+    func_8012A018((s32)func_80182E34, 0);
+
+    D_801269E4 = *(s32 *)(s1 + 0xDC);
+}
+
 
 extern void func_8012A4BC(void);
     void func_80182E14(void) {
diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8018631C.c b/src/ov_SC03_001/ov_SC03_001_jr_8018631C.c
index 42e8554a9..cf0c4de9e 100644
--- a/src/ov_SC03_001/ov_SC03_001_jr_8018631C.c
+++ b/src/ov_SC03_001/ov_SC03_001_jr_8018631C.c
@@ -3423,7 +3423,34 @@ void func_80186A7C(void) {
 void func_80186A84(void) {
 }
 
-INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_jr_8018631C", func_80186A8C);
+void func_80186A8C(void *arg0) {
+    extern s32 D_80192A6C;
+    extern s32 D_80192A64;
+    extern s32 D_801C3C90;
+    extern s32 D_801EB318;
+    extern void func_80186C54(void);
+    if (func_8018727C(arg0, &D_80192A6C) != 0) {
+        s32 v0;
+        s32 v1 = func_80029504();
+        if (v1 < 0x1E) {
+            v0 = 1;
+        } else if (v1 < 0x46) {
+            v0 = 4;
+        } else {
+            func_8012CAE4(arg0);
+            return;
+        }
+        *(s16 *)((char *)arg0 + 2) = v0;
+        __asm__ __volatile__("" ::: "memory");
+        func_8012E8E0((s32)arg0, (s32)&D_80192A64);
+        func_80187750((s32)arg0);
+        func_8012A828((s32)arg0, (s32)&D_801C3C90);
+        func_8001C97C(&D_801EB318);
+        *(s16 *)(*(s32 *)((char *)arg0 + 0x68) + 0xC) = 0x7FFF;
+        *(s32 *)((char *)arg0 + 0xD4) = func_801788B8((s32)arg0, (s32)func_80186C54);
+    }
+}
+
 
 extern void func_8012C218(void *a0);
 
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c b/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
index 4525b8b97..e8854dff0 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8017FF7C.c
@@ -3687,7 +3687,48 @@ void func_80181598(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8017FF7C", func_80181600);
+#include "common.h"
+
+extern u8 func_8014BF6C(void);
+extern void func_8012B23C(s32 a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern void func_8012BF4C(s32 *a0, s32 a1);
+extern s32 func_8012AD50(void *a0);
+extern void func_80181708(void *a0);
+extern void func_801817D8(u8 *a0, u8 *a1);
+extern u16 D_800B99DA;
+
+/* Packed struct to trigger lwl/lwr unaligned block copy (same idiom as the
+ * banked twin ov_SC02_011:func_8018754C's BlockData). */
+typedef struct {
+    u32 w0;
+    u32 w1;
+} __attribute__((packed, aligned(1))) Block8_80181600;
+
+extern Block8_80181600 D_801D80B0;
+
+void func_80181600(void *a0)
+{
+    u8 result;
+    Block8_80181600 buffer;
+
+    buffer = D_801D80B0;
+
+    result = func_8014BF6C();
+
+    if (!(*(s16 *)((u8 *)a0 + 0x70) < (result & 0xFF))) {
+        func_8012B23C((s32)a0);
+        func_8002D4C8(0x580, 0);
+        func_8012BF4C((s32 *)a0, 0x10);
+        func_8012AD50(a0);
+    } else {
+        func_80181708(a0);
+        if ((D_800B99DA & 0x3) == 0) {
+            func_801817D8((u8 *)a0, (u8 *)&buffer);
+        }
+    }
+}
+
 
 extern void func_8012AD80(s32 a0);
 extern s32 func_8012BEE8(s32 a0);
diff --git a/src/ov_SC03_091/ov_SC03_091_jr_80182268.c b/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
index 95d12bd74..2ca8e6198 100644
--- a/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
+++ b/src/ov_SC03_091/ov_SC03_091_jr_80182268.c
@@ -2891,7 +2891,37 @@ void func_8018268C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_jr_80182268", func_801826C8);
+#include "common.h"
+
+extern u16 func_80148800(s32 *a0);
+extern void func_80182B48(s32 param_1, s16 *param_2);
+
+void func_801826C8(s32 a0) {
+
+    typedef struct { s16 v[4]; } Blk8_80126940_8017D6D0_801826C8;
+
+    extern s32 D_80126B58;
+    extern s16 D_80190710[];
+    extern Blk8_80126940_8017D6D0_801826C8 D_80126940;
+    Blk8_80126940_8017D6D0_801826C8 sp10;
+    u8 t;
+
+    if (func_80148800(&D_80126B58) & 3) {
+        t = (*(u8 *)(a0 + 5) + 1) & 1;
+        *(u8 *)(a0 + 5) = t;
+        *(s32 *)(a0 + 0x14) = D_80190710[t];
+    }
+    sp10 = D_80126940;
+    sp10.v[0] = 0x340;
+    {
+        s16 lim = -0x740;
+        if (sp10.v[2] < lim) {
+            sp10.v[2] = lim;
+        }
+    }
+    func_80182B48(a0, sp10.v);
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_jr_80182268", func_80182788);
 
diff --git a/src/ov_SC03_092/ov_SC03_092_jr_8017AE2C.c b/src/ov_SC03_092/ov_SC03_092_jr_8017AE2C.c
index 293072a75..c001d4945 100644
--- a/src/ov_SC03_092/ov_SC03_092_jr_8017AE2C.c
+++ b/src/ov_SC03_092/ov_SC03_092_jr_8017AE2C.c
@@ -4789,7 +4789,41 @@ void func_8017DE74(void) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_092/nonmatchings/ov_SC03_092_jr_8017AE2C", func_8017DF40);
+#include "common.h"
+
+
+
+extern void func_8012A018(s32 a0, s32 a1);
+extern void func_8017E008(void *a0);
+
+extern Blk8 D_80126940;
+extern Blk8 D_801274E8;
+extern u8 D_80126948[];
+extern s32 D_80126954;
+extern s32 D_8012695C;
+extern s16 D_80126968;
+extern s16 D_8012696A;
+extern s16 D_8012696C;
+extern s16 D_80126976;
+extern s16 D_80126978;
+extern s16 D_8012697A;
+extern u8 D_80127504;
+
+void func_8017DF40(void) {
+    D_80126954 = 0x190;
+    D_8012695C = 0x258;
+    D_80126968 = 0x9F;
+    D_8012696A = 0x600;
+    D_8012696C = 0;
+    D_80126976 = 0;
+    D_80126978 = -0x50;
+    D_8012697A = 0;
+    func_8012A018((s32)func_8017E008, 0);
+    D_801274E8 = D_80126940;
+    func_8017E008(D_80126948);
+    D_80127504 = 0x30;
+}
+
 
 
 extern void (*D_801889B4[])(void);
diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c b/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
index 7981e7c78..f0c60c27e 100644
--- a/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
+++ b/src/ov_SC03_101/ov_SC03_101_jr_8017CA80.c
@@ -5106,7 +5106,39 @@ void func_80180814(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8017CA80", func_80180864);
+
+
+
+extern void func_80181E3C(void);
+extern void func_80181F00(s32 arg0, s32 arg1, s32 arg2);
+extern void func_8012B2CC(s32 a0);
+extern void func_80181F30(s32 a0);
+extern s32 func_80178B18(s32, s32);
+extern void func_8012AD44(s32 *a0, s16 a1);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_80180864(void *arg0) {
+
+    extern Blk4_80181EDC_80180400 D_8019C978;
+    extern u8 D_8019DCF8;
+    extern s32 D_8019A9B8;
+    Rec_8018A6A4_80181E60 sp10;
+
+    *(u8 *)((s32)arg0 + 0xC1) = 0;
+    *(s16 *)((s32)arg0 + 0x5E) = 0;
+    *(s16 *)((s32)arg0 + 0x5C) = 0x800;
+    *(Blk4_80181EDC_80180400 *)&D_8019DCF8 = *(Blk4_80181EDC_80180400 *)&D_8019C978;
+    func_80181E3C();
+    func_80181F00((s32)&sp10, 0x1000, 0);
+    func_8012B2CC((s32)arg0);
+    func_80181F30((s32)arg0 + 0x4);
+    *(s16 *)((s32)arg0 + 0xFC) = 0;
+    *(s32 *)((s32)arg0 + 0x1C) = 0x40;
+    func_80178B18((s32)arg0, (s32)&D_8019A9B8);
+    func_8012AD44((s32 *)arg0, 2);
+    func_8002D4C8(0x700, 0);
+}
+
 
 extern void func_8012B2CC(s32 a0);
 extern void func_80181F30(s32 a0);
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 19561dc27..d8280fcf5 100644
--- a/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c
+++ b/src/ov_SC03_102/ov_SC03_102_jr_8017BEBC.c
@@ -4469,7 +4469,32 @@ void func_80181500(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8017BEBC", func_8018153C);
+void func_8018153C(void *a0)
+{
+    extern s32 func_8012C194(void);
+    extern void func_8001CEC0(s32 a0, s32 a1);
+    extern void func_80015978(s32 a0, s32 *a1);
+    extern void func_801815D4(void *a0);
+    extern s32 func_8012AD50(void *a0);
+    extern s32 D_80189CB8[];
+
+    s32 v2;
+    s32 s0;
+
+    v2 = D_80189CB8[*(s16 *)((u8 *)a0 + 0x70)];
+    s0 = func_8012C194();
+    if (s0 != 0) {
+        *(s32 *)((u8 *)a0 + 0x20) = s0;
+        func_8001CEC0(s0, v2);
+        *(s16 *)(s0 + 0x2E) = 0;
+        *(s16 *)(s0 + 0x30) = 0;
+        *(s16 *)(s0 + 0x2C) = 1;
+        func_80015978((s32)((u8 *)a0 + 4), (s32 *)((u8 *)a0 + 0xFC));
+        func_801815D4(a0);
+        func_8012AD50(a0);
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8017BEBC", func_801815D4);
 
diff --git a/src/ov_SC03_103/ov_SC03_103_jr_8017C294.c b/src/ov_SC03_103/ov_SC03_103_jr_8017C294.c
index 7f0711212..26a541049 100644
--- a/src/ov_SC03_103/ov_SC03_103_jr_8017C294.c
+++ b/src/ov_SC03_103/ov_SC03_103_jr_8017C294.c
@@ -4011,7 +4011,34 @@ void func_8017E80C(void *a0) {
     }
 
 
-INCLUDE_ASM("asm/ov_SC03_103/nonmatchings/ov_SC03_103_jr_8017C294", func_8017E830);
+extern void func_8017E8F4(void *a0, s32 a1);
+extern void func_800183E0(s32 a0);
+extern u8 D_80199260[];
+extern s32 D_8018806C[];
+
+void func_8017E830(void *a0)
+{
+    s16 v0;
+
+    v0 = *(u16 *)((char *)a0 + 0xDC);
+    v0--;
+    *(u16 *)((char *)a0 + 0xDC) = v0;
+    if (v0 == 0) {
+        *(u16 *)((char *)a0 + 0xDC) = 2;
+        func_8017E8F4(D_80199260, *(s16 *)((char *)a0 + 0xDE) * 6);
+        *(u16 *)((char *)a0 + 0xDE) = (*(u16 *)((char *)a0 + 0xDE) + 1) & 7;
+    }
+
+    v0 = *(u16 *)((char *)a0 + 0xE0);
+    v0--;
+    *(u16 *)((char *)a0 + 0xE0) = v0;
+    if (v0 == 0) {
+        *(u16 *)((char *)a0 + 0xE0) = 8;
+        func_800183E0(D_8018806C[*(s16 *)((char *)a0 + 0xE2)]);
+        *(u16 *)((char *)a0 + 0xE2) = (*(u16 *)((char *)a0 + 0xE2) + 1) & 0xF;
+    }
+}
+
 
 
 void func_8017E8F4(void *a0, s32 a1)
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
index ac8222bc7..692e0615b 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8017C8D0.c
@@ -5030,7 +5030,33 @@ s32 func_8018388C(void *a0, s32 a1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8017C8D0", func_801839A4);
+extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+extern s32  func_80135888(s32 a0, s32 a1, s32 a2, s32 a3);
+extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5);
+extern s32 *D_80126B78;
+extern s32  D_8018E8AC;
+extern u8   D_801152A8[];
+
+s32 func_801839A4(s32 param_1, s32 param_2)
+{
+    SVECTOR out1;
+    SVECTOR out2;
+    s32 iVar1;
+
+    func_8012F14C((s32)D_80126B78 + 0x34, (s32)&D_8018E8AC, (s32)&out1);
+    func_8012F14C((s32)D_80126B78 + 0x34, (s32)&D_8018E8AC + 8, (s32)&out2);
+
+    iVar1 = func_80135888(*(s32 *)(param_1 + 0x20), *(s32 *)(param_1 + 0x58),
+                           (s32)&out1, (s32)&out2);
+
+    if (iVar1 != 0) {
+        func_8012F568(1, 0x4201, *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12),
+                      param_2, (s32)&out2, (s32)D_801152A8);
+        return 1;
+    }
+    return 0;
+}
+
 
 s32 func_80183A64(s32 *a0, s32 a1, s32 a2) {
         s32 v1 = a0[0x4 / 4];
diff --git a/src/ov_SC03_124/ov_SC03_124_jr_80188544.c b/src/ov_SC03_124/ov_SC03_124_jr_80188544.c
index 30d1b8000..4a22434de 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_80188544.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_80188544.c
@@ -4400,7 +4400,34 @@ void func_8018A250(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_80188544", func_8018A3C8);
+extern s16 D_80126B62;
+extern s32 D_801DE434;
+extern s32 D_801DE444;
+extern void (*D_801DE4DC[])(s32);
+
+void func_8018A3C8(s32 arg0) {
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+
+    if (*(s16 *)(arg0 + 0xFC) != 0) {
+        *(s16 *)(arg0 + 0xFC) -= 1;
+        *(s32 *)(*(s32 *)(arg0 + 0x20) + 4) ^= 0x80000000;
+    }
+    v0 = *(s16 *)(arg0 + 0xA) - 0x30;
+    v1 = D_80126B62 < v0;
+    v0 = (s32)&D_801DE434;
+    if (v1) {
+        v0 = (s32)&D_801DE444;
+    }
+    v1 = 0x40000000;
+    v0 |= v1;
+    v1 = 0x20000000;
+    v0 |= v1;
+    *(s32 *)(arg0 + 0x58) = v0;
+    __asm__ __volatile__("" ::: "memory");
+    D_801DE4DC[*(u16 *)(arg0 + 0x2)](arg0);
+}
+
 
 
 extern void func_8012E8E0(s32 a0, s32 a1);
diff --git a/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c b/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
index 6ce342815..91b3c9540 100644
--- a/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
+++ b/src/ov_SC04_008/ov_SC04_008_jr_8017AE2C.c
@@ -4143,7 +4143,35 @@ void func_8017D77C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_jr_8017AE2C", func_8017D8C4);
+void func_8017D8C4(s32 a0) {
+    extern u8 D_80126B5C;
+    extern s32 D_80193340;
+    extern s8 D_80191EF0;
+
+    s16 buf[4];
+    s32 i;
+    s32 id;
+    u8 *obj;
+
+    id = -1;
+    func_80015978((s32)&D_80126B5C, (s32 *)buf);
+    buf[1] = *(u16 *)(a0 + 0xA);
+
+    for (i = 0; i < D_80193340 && id == -1; i++) {
+        if (*(u8 *)(&D_80191EF0 + i) == 0) {
+            id = i;
+        }
+    }
+
+    if (id != -1) {
+        obj = func_801290DC(0x61, (u8 *)buf);
+        if (obj != 0) {
+            *(&D_80191EF0 + id) = 1;
+            *(s32 *)(obj + 0x34) = id;
+        }
+    }
+}
+
 
 
 extern void (*D_80182564[])(void);
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 f97ae6de8..813cd679a 100644
--- a/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
+++ b/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
@@ -4270,7 +4270,42 @@ void func_8017D99C(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8017AE2C", func_8017DAE4);
+extern void func_80015978(s32 a0, s32 *a1);
+extern u8 *func_801290DC(s32 a0, u8 *a1);
+
+void func_8017DAE4(s32 a0) {
+    extern u8 D_80126B5C;
+    extern s32 D_801930C0;
+    extern s8 D_80191C70;
+
+    s16 buf[4];
+    s32 i;
+    s32 j;
+    s32 slot;
+    u8 *obj;
+
+    slot = -1;
+    func_80015978((s32)&D_80126B5C, (s32 *)buf);
+    buf[1] = *(u16 *)(a0 + 0xA);
+
+    for (j = 0, i = 0; j < D_801930C0; j++, i++) {
+        if (slot != -1) {
+            break;
+        }
+        if (*((u8 *)&D_80191C70 + i) == 0) {
+            slot = i;
+        }
+    }
+
+    if (slot != -1) {
+        obj = func_801290DC(0x61, (u8 *)buf);
+        if (obj != 0) {
+            *(&D_80191C70 + slot) = 1;
+            *(s32 *)(obj + 0x34) = slot;
+        }
+    }
+}
+
 
 
 extern void (*D_801822B8[])(void);
diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c
index eea6fe20b..00f0b6a68 100644
--- a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c
+++ b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c
@@ -6050,7 +6050,7 @@ DEFINE_func_80180190()  /* dedup: shared engine-core @0x80180190 (src/shared) */
 
 extern s32 func_80029504(void);
 extern s32 func_801788B8(s32 arg0, s32 arg1);
-extern s32 func_80180284(void);
+extern s32 func_80180284();
 extern short D_8019181C;
 extern void func_8001C214(s32, s32);
 extern void func_8012C1B8(void);
@@ -6084,7 +6084,47 @@ void *arg0;
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80180284);
+extern s32 func_800133E4(s16 *a0, s16 *a1);
+extern s32 func_80178BF8();
+extern void func_80172710(void);
+extern s32 D_80126B58;
+extern s32 D_80126B9C;
+extern u16 D_80126B5E;
+extern u16 D_80126B66;
+
+s32 func_80180284(void *a0)
+{
+    extern s16 D_8019181C;
+    s16 *p;
+    s32 r;
+
+    if (*(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) != 1) {
+        return 0;
+    }
+    p = (s16 *)&D_80126B58;
+    if ((D_80126B9C & 0x8000000) == 0) {
+        r = 0;
+        goto chain_fail;
+    }
+    p += 2;
+    if (func_800133E4((s16 *)&D_8019181C, p) >= 0x6401) {
+        r = 0;
+        goto chain_fail;
+    }
+    if (*(s16 *)&D_80126B5E >= 0x281) {
+        r = 0;
+        goto chain_fail;
+    }
+    r = *(s16 *)&D_80126B66 >= -0x380;
+chain_fail:
+    if (r) {
+        *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 2;
+        func_80178BF8();
+        return (s32)func_80172710;
+    }
+    return 0;
+}
+
 
 #include "common.h"
 
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 ee9eeef27..d852807af 100644
--- a/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c
+++ b/src/ov_SC05_004/ov_SC05_004_jr_8017BEBC.c
@@ -4771,7 +4771,42 @@ void func_8017EEBC(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_jr_8017BEBC", func_8017EF0C);
+extern void func_8017EBA0(void *a0);
+extern void func_8002D4C8(s32 a0, s32 a1);
+
+void func_8017EF0C(s32 a0)
+{
+    register s32 v0 __asm__("$2");
+    register s32 v1 __asm__("$3");
+    s32 pad;
+
+    if (func_8012BEE8() != 0) {
+        *(u16 *)(a0 + 0xFC) = *(u16 *)(a0 + 0xFC) + 4;
+        if ((s16)*(u16 *)(a0 + 0xFC) >= 0x11) {
+            func_8017EBA0((void *)a0);
+        }
+    } else {
+        v0 = *(s16 *)(a0 + 0xFC);
+        if (v0 != 0) {
+            v1 = v0;
+            __asm__ volatile("" : "=r"(v0) : "0"(v0), "m"(pad));
+            if (v0 < 3) {
+                v0 = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);
+                v0 = (v0 + 2) & 0x3FF;
+                if (v0 < 4) {
+                    *(s16 *)(a0 + 0xFC) = 0;
+                }
+            } else {
+                v0 = v1 - 2;
+                *(s16 *)(a0 + 0xFC) = v0;
+            }
+        }
+        if (*(s32 *)(a0 + 0x1C) == 1) {
+            func_8002D4C8(0x720, 0);
+        }
+    }
+}
+
 
 
 void func_8017EFD4(s32 *a0) {
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
index ce484e35c..507540385 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c
@@ -5718,7 +5718,54 @@ void func_80181290(void *a0)
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801813B0);
+extern void *D_801937DC;
+extern s16 D_8019FD70[];
+extern s32 D_8019FEF8;
+extern u8 D_8019FB68[];
+
+typedef struct { u8 c[8]; } Blk8_801813B0;
+
+void func_801813B0(s32 param_1) {
+    u8 *dst;
+    u8 *src;
+    s16 *idx;
+    s32 i;
+    s32 v;
+
+    dst = D_8019FB68;
+    D_8019FEF8 = 0;
+    src = *(u8 **)((u8 *)D_801937DC + 0xC);
+    idx = D_8019FD70;
+
+    for (i = 0; i < 65; i++) {
+        *(Blk8_801813B0 *)(dst + i * 8) = *(Blk8_801813B0 *)(src + i * 8);
+        v = *(s16 *)((u8 *)src + i * 8 + 2);
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        __asm__("" : "=r"(v) : "0"(v));
+        if (v == -150) {
+            idx[i] = 4;
+        } else if (v == -139) {
+            idx[i] = 3;
+        } else if (v == -106) {
+            idx[i] = 2;
+        } else if (v == -57) {
+            idx[i] = 1;
+        } else {
+            idx[i] = 0;
+        }
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
index bdbce7661..53c32854e 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8017EEC4.c
@@ -3862,7 +3862,40 @@ s32 func_80180808() {
 }
 
 
-INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8017EEC4", func_801808AC);
+void func_801808AC(void *arg0)
+{
+    /* Declarations kept BLOCK-scope on purpose, matching this TU's house style
+     * (see the comment above func_80180300 in the same file): a file-scope
+     * prototype for func_8012A828 here would become visible to func_80181C74,
+     * which deliberately calls `func_8012A828()` with no arguments behind a
+     * no-prototype decl -- a file-scope prototype turns that into a hard
+     * "too few arguments" error and fails the whole-binary gate even though
+     * this function's own body is byte-identical. */
+    extern void func_8012E8E0(s32 a0, s32 a1);
+    extern void func_8012A828(s32 a0, void *a1);
+    extern s32 func_80137614(s32 a0, s32 a1, s32 a2);
+    extern void func_80029124(s32 a0, s32 a1);
+    extern void func_801746A4(void);
+
+    extern u8 D_801889F8[];
+    extern u8 D_801A1FDC[];
+    extern void (*D_80189BE4[])(void);
+    extern s32 D_801270C8;
+    extern s32 D_801B1B54;
+    extern s16 D_801B1714;
+
+    *(u16 *)((s32)arg0 + 2) = 5;
+    *(u16 *)((s32)arg0 + 0x34) = 0;
+    func_8012E8E0((s32)arg0, (s32)&D_801889F8);
+    func_8012A828((s32)arg0, &D_801A1FDC);
+    *(s32 *)((s32)arg0 + 0x1C) = 0;
+    D_801270C8 = 2;
+    D_801B1B54 = func_80137614((s32)D_80189BE4, 0, 0xC0);
+    func_80029124(0x120, 0);
+    func_801746A4();
+    D_801B1714++;
+}
+
 
 void func_80180950(void *arg0) {
 
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 e2cf577bd..cb0d4c3e5 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -4930,7 +4930,35 @@ void func_80180090(s32 a0)
 
 INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_80180248);
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_801804D4);
+typedef struct { u16 w[4]; } __attribute__((aligned(2))) DBlock_8019F04C;
+
+extern s16 D_8019F048;
+extern s16 D_8019F04A;
+extern s16 D_8019F04C;
+extern s16 D_8019F054;
+extern s16 D_8019F056;
+extern s16 D_8019F058;
+extern s32 D_8019F03C;
+extern s32 D_8019F05C;
+extern s32 *D_8019F040;
+extern s32 D_8018A31C[];
+extern s32 func_8018059C(s32 arg0);
+
+void func_801804D4(void *a0, s32 a1) {
+    D_8019F048 = *(s32 *)((s32)a0 + 8);
+    D_8019F04A = *(s32 *)((s32)a0 + 0x10);
+    *(DBlock_8019F04C *)(void *)&D_8019F04C = *(DBlock_8019F04C *)(void *)((s32)a0 + 0x18);
+    D_8019F054 = *(u16 *)((s32)a0 + 0x28);
+    D_8019F056 = *(u16 *)((s32)a0 + 0x2A);
+    D_8019F03C = 0;
+    D_8019F05C = 0;
+    D_8019F058 = *(u16 *)((s32)a0 + 0x2C);
+    D_8019F040 = (s32 *)((u8 *)D_8018A31C + a1 * 0x18);
+    if (*D_8019F040 == 1) {
+        func_8018059C((s32)a0);
+    }
+}
+
 
 extern s32 *D_8019F040;
 extern s32 D_8019F03C;