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

Committed before the main batch: gate_main reverts on failure and would take these with it.
---
 src/md_MAIN_003/md_MAIN_003.c             | 128 +++++++++++++++++++++-
 src/md_MAIN_033/md_MAIN_033.c             |  36 +++++-
 src/md_SC03_134/md_SC03_134.c             |  16 ++-
 src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c |  27 ++++-
 src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c |   9 +-
 src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c |  38 ++++++-
 src/ov_SC04_006/ov_SC04_006_jr_8017BEBC.c |  48 +++++++-
 src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c |  37 ++++++-
 8 files changed, 329 insertions(+), 10 deletions(-)

diff --git a/src/md_MAIN_003/md_MAIN_003.c b/src/md_MAIN_003/md_MAIN_003.c
index 7a68c2f7e..a65b12058 100644
--- a/src/md_MAIN_003/md_MAIN_003.c
+++ b/src/md_MAIN_003/md_MAIN_003.c
@@ -94,7 +94,7 @@ extern s32 D_800EC6A4;
 extern s32 D_800EC690;
 extern u8 D_800DA48C[];
 extern void func_800CF3E8(void);
-extern s32 func_800CFC1C(u8 *arg0);
+extern s32 func_800CFC1C();
 extern void func_800118AC(void);
 
 void func_800CF078(void) {
@@ -230,7 +230,131 @@ void func_800CFB3C(u16 *arg0)
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003", func_800CFC1C);
+
+
+
+
+
+
+extern void func_800599B8();
+
+s32 func_800CFC1C(u16 *param_1)
+{
+    extern s32 D_800EC69C;
+
+    u8 buf[0x10];
+    register u16 *cursor __asm__("$18");
+    register s32 uVar13 __asm__("$16");
+    register u16 *psVar14 __asm__("$17");
+    register s32 uVar16 __asm__("$19");
+    register u32 mask __asm__("$20");
+    register u16 *puVar9 __asm__("$11");
+    register u16 *puVar10 __asm__("$12");
+    register s32 iVar11 __asm__("$13");
+    u16 tag;
+    u32 result;
+    u16 stored;
+    s32 gate;
+    register u32 acc __asm__("$2");
+    register u32 uVar5 __asm__("$7");
+    register u32 uVar7 __asm__("$6");
+    register u32 uVar1 __asm__("$4");
+    register u32 uVar6 __asm__("$3");
+    register u32 uVar8 __asm__("$8");
+    register u32 uVar3 __asm__("$10");
+
+    cursor = param_1;
+    uVar16 = 0;
+    D_800EC69C = D_800EC69C + 1;
+    gate = D_800EC69C < 2;
+    if (gate) {
+        return (u16 *)gate;
+    }
+    __asm__ __volatile__("" : "=r"(cursor) : "0"(cursor));
+    tag = *(u16 *)cursor;
+    D_800EC69C = 0;
+    if (tag != 0xff) {
+        mask = -0x8000;
+        psVar14 = param_1 + 5;
+        do {
+            iVar11 = 0;
+            if (tag == 9) {
+                uVar13 = 0;
+                puVar10 = *(u16 **)(psVar14 + 1);
+                {
+                    register s32 boff __asm__("$2") = (s32)((s16 *)psVar14)[-1] * 2;
+                    register u16 *pi __asm__("$5");
+                    pi = (u16 *)((s32)puVar10 + boff);
+                    __asm__ __volatile__("" : "=r"(pi) : "0"(pi));
+                    puVar9 = pi;
+                }
+                if (0 < (s32)((s16 *)psVar14)[-1]) {
+                    do {
+                        register u32 pix __asm__("$2");
+                        register u32 out __asm__("$9");
+                        pix = (u32)*puVar9;
+                        out = (u32)*puVar10;
+                        uVar5 = pix & 0x1f;
+                        uVar7 = pix & 0x3e0;
+                        uVar1 = pix & 0x7c00;
+                        uVar6 = out & 0x1f;
+                        uVar8 = out & 0x3e0;
+                        uVar3 = out & 0x7c00;
+                        if (uVar5 != uVar6) {
+                            register s32 c __asm__("$2");
+                            uVar13 = 1;
+                            if ((s32)uVar5 < (s32)uVar6) uVar5 = uVar5 + 1;
+                            c = (s32)uVar6 < (s32)uVar5;
+                            if (c) uVar5 = uVar5 - 1;
+                        }
+                        if (uVar7 != uVar8) {
+                            register s32 c __asm__("$2");
+                            uVar13 = 1;
+                            if ((s32)uVar7 < (s32)uVar8) uVar7 = uVar7 + 0x20;
+                            c = (s32)uVar8 < (s32)uVar7;
+                            if (c) uVar7 = uVar7 - 0x20;
+                        }
+                        if (uVar1 != uVar3) {
+                            register s32 c __asm__("$2");
+                            uVar13 = 1;
+                            if ((s32)uVar1 < (s32)uVar3) uVar1 = uVar1 + 0x400;
+                            c = (s32)uVar3 < (s32)uVar1;
+                            if (c) uVar1 = uVar1 - 0x400;
+                        }
+                        acc = uVar5 | uVar7;
+                        result = acc | uVar1 | (out & mask);
+                        stored = result;
+                        if ((stored & 0xFFFF) == 0 && out != 0) {
+                            stored = result | 0x8000;
+                        }
+                        *puVar9 = stored;
+                        puVar9 = puVar9 + 1;
+                        iVar11 = iVar11 + 1;
+                        puVar10 = puVar10 + 1;
+                    } while (iVar11 < (s32)((s16 *)psVar14)[-1]);
+                }
+                if (uVar13 != 0) {
+                    register u8 *argp __asm__("$4");
+                    argp = buf;
+                    *(u16 *)(buf + 0) = psVar14[-3];
+                    __asm__ __volatile__("" ::: "memory");
+                    *(u16 *)(buf + 2) = psVar14[-2];
+                    __asm__ __volatile__("" ::: "memory");
+                    *(u16 *)(buf + 4) = psVar14[-1];
+                    __asm__ __volatile__("" ::: "memory");
+                    *(u16 *)(buf + 6) = psVar14[0];
+                    func_800599B8(argp);
+                }
+                uVar16 = uVar16 | uVar13;
+            }
+            cursor = cursor + 8;
+            psVar14 = psVar14 + 8;
+            tag = *(u16 *)cursor;
+        } while (tag != 0xff);
+    }
+    return (u16 *)uVar16;
+}
+
 
 extern s16 D_800EC678;
 extern void func_800599B8(u16 *, u16 *);
diff --git a/src/md_MAIN_033/md_MAIN_033.c b/src/md_MAIN_033/md_MAIN_033.c
index 398418161..c9a6f5a45 100644
--- a/src/md_MAIN_033/md_MAIN_033.c
+++ b/src/md_MAIN_033/md_MAIN_033.c
@@ -143,7 +143,41 @@ void func_800CB190(void *arg0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_033/nonmatchings/md_MAIN_033", func_800CB2C8);
+void func_800CB2C8(void *arg0) {
+    extern void func_80146CA0(s32 *);
+    extern s32 func_80012ABC(s32, s32, s32);
+    extern void func_8001382C(s32, void *, void *);
+    extern void func_80162FC0(s32 *);
+
+    void *s1;
+    register void *p __asm__("$4");
+    register s32 raw __asm__("$3");
+    register s32 t __asm__("$2");
+    s32 r;
+    s32 buf[3];
+
+    s1 = *(void **)((u8 *)arg0 + 0x20);
+    p = *(void **)((u8 *)arg0 + 0x4C);
+    raw = *(u8 *)((u8 *)s1 + 0x24);
+    t = raw - 0x10;
+    if (t < 0) {
+        func_80146CA0((s32 *)arg0);
+        return;
+    }
+    raw = t;
+    __asm__("" : "=r"(raw) : "0"(raw));
+    t = raw;
+    *(u8 *)((u8 *)s1 + 0x24) = *(u8 *)((u8 *)s1 + 0x25) = *(u8 *)((u8 *)s1 + 0x26) = t;
+    r = func_80012ABC(*(s16 *)((u8 *)s1 + 0x12),
+                      *(s16 *)(*(void **)((u8 *)p + 0x20) + 0x12), 0x10);
+    *(s16 *)((u8 *)s1 + 0x12) = r;
+    func_8001382C((s16)r, (u8 *)arg0 + 0x24, buf);
+    *(s32 *)((u8 *)arg0 + 0x10) = buf[0];
+    *(s32 *)((u8 *)arg0 + 0x14) = buf[1];
+    *(s32 *)((u8 *)arg0 + 0x18) = buf[2];
+    func_80162FC0((s32 *)arg0);
+}
+
 
 extern void func_80162CCC(void);
 void func_800CB384(void) {
diff --git a/src/md_SC03_134/md_SC03_134.c b/src/md_SC03_134/md_SC03_134.c
index 5f1511bde..50a7b9946 100644
--- a/src/md_SC03_134/md_SC03_134.c
+++ b/src/md_SC03_134/md_SC03_134.c
@@ -581,7 +581,21 @@ void func_801E3424(s32 param_1) {
 
 INCLUDE_ASM("asm/md_SC03_134/nonmatchings/md_SC03_134", func_801E3448);
 
-INCLUDE_ASM("asm/md_SC03_134/nonmatchings/md_SC03_134", func_801E346C);
+void func_801E346C(s32 a0_) {
+
+    extern s32 D_801E9E38;
+    extern s32 D_801E9E3C;
+
+    register s32 c __asm__("$3") = 2;
+    register s32 a0 __asm__("$4") = a0_;
+    s32 p1 = D_801E9E38;
+
+    *(s16 *)((s32)a0 + 0xFC) = 0;
+    a0 = D_801E9E3C;
+    *(s16 *)(p1 + 0xFC) = c;
+    *(s16 *)((s32)a0 + 0xFC) = 0;
+}
+
 
 void func_801E3490(s32 arg0) {
     extern s32 D_801E9E38;
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 8c16045a9..43adc36db 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c
@@ -5287,7 +5287,32 @@ void func_8017FC04(s32 arg0) {
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017FCC0);
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017FCFC);
+extern u16 D_801C7600[];
+
+void func_8017FCFC(u16 *a0) {
+    register u16 *p __asm__("$5");
+    register s32 i __asm__("$6");
+    register s32 c __asm__("$7");
+    register u16 *q __asm__("$3");
+
+    p = D_801C7600;
+    i = 0;
+    c = 0x20;
+    q = p + 2;
+    do {
+        if (*(s16 *)(q + 1) == 0) {
+            *(s16 *)(q + 1) = c;
+            p[0] = a0[0];
+            q[-1] = a0[1];
+            q[0] = a0[2];
+            return;
+        }
+        i++;
+        q += 4;
+        p += 4;
+    } while (i < 0x100);
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017FD64);
 
diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
index e4a490321..9efbf60cc 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8017AE2C.c
@@ -8153,7 +8153,14 @@ void func_80184590(s32 param_1) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8017AE2C", func_801845C0);
+void func_801845C0(s32 param_1) {
+    extern u8 D_80126B5C;
+    extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2);
+
+    *(s32 *)&D_80126B5C = *(s32 *)(param_1 + 4);
+    func_8012C658(0xBA, 1, param_1);
+}
+
 
 s32 func_801845F4(s32 param_1) {
     extern s32 func_80172670(s32 *a0);
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
index df79c63ea..91b55f661 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8017DF98.c
@@ -7705,7 +7705,43 @@ void func_80188950(s32 arg0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8017DF98", func_80188A0C);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001CA1C(s32 a0, s32 a1);
+extern void func_8012A828(s32 a0, void *a1);
+extern void func_8012B23C(s32 a0);
+extern s32 rand(void);
+
+extern u8 D_801904A8;
+extern u8 D_801904B4;
+
+void func_80188A0C(s32 param_1)
+{
+    s32 v0;
+    s32 s0;
+
+    v0 = ((s32 (*)(void))func_8012C1B8)();
+    s0 = param_1;
+    *(s32 *)(s0 + 0x20) = v0;
+    if (v0 == 0) {
+        func_8012CAE4((void *)s0);
+    } else {
+        func_8001CA1C(v0, (s32)&D_801904A8);
+        func_8012A828((s32)s0, &D_801904B4);
+        *(s16 *)(s0 + 2) = 1;
+        func_8012B23C((s32)s0);
+
+        *(s32 *)(s0 + 0x10) = ((rand() & 0xFF) - 0x80) << 12;
+        *(s32 *)(s0 + 0x18) = ((rand() & 0xFF) - 0x80) << 12;
+
+        *(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) = 0x2000;
+        *(s16 *)(*(s32 *)(s0 + 0x20) + 0x1A) = 0x2000;
+        *(s16 *)(*(s32 *)(s0 + 0x20) + 0x1C) = 0x2000;
+
+        *(u16 *)(*(s32 *)(s0 + 0x20) + 0x2C) |= 0x10;
+    }
+}
+
 
 #include "common.h"
 
diff --git a/src/ov_SC04_006/ov_SC04_006_jr_8017BEBC.c b/src/ov_SC04_006/ov_SC04_006_jr_8017BEBC.c
index 711dd7e85..16c61d276 100644
--- a/src/ov_SC04_006/ov_SC04_006_jr_8017BEBC.c
+++ b/src/ov_SC04_006/ov_SC04_006_jr_8017BEBC.c
@@ -3403,7 +3403,28 @@ int func_8017D584(int param_1)
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_jr_8017BEBC", func_8017D5B4);
+extern void func_8012C1B8(void);
+extern void func_8012CAE4(void *a0);
+extern void func_8001C2C4(s32 a0);
+extern u8 D_801836F8;
+
+void func_8017D5B4(void *param_1) {
+    s32 ret;
+    if (*(u16 *)((s32)param_1 + 2) == 0) {
+        ret = ((s32 (*)(void))func_8012C1B8)();
+        *(s32 *)((s32)param_1 + 0x20) = ret;
+        if (ret == 0) {
+            func_8012CAE4(param_1);
+        } else {
+            func_8001C2C4(ret);
+            *(u16 *)((s32)param_1 + 0x5C) = 0x40;
+            *(s32 *)((s32)param_1 + 0x58) = (u32)&D_801836F8;
+            *(u8 *)((s32)param_1 + 0x75) = 2;
+            (*(u16 *)((s32)param_1 + 2))++;
+        }
+    }
+}
+
 
 extern s32 func_8017D638(void);
 
@@ -4403,7 +4424,30 @@ void func_8017E948(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_jr_8017BEBC", func_8017E9EC);
+extern u16 D_8019572A;
+
+void func_8017E9EC(s32 s0) {
+    s32 v0;
+    s32 v1;
+
+    if (func_8012BEE8(s0) != 0) {
+        v1 = *(s32 *)(s0 + 0x20);
+        v0 = *(u16 *)(v1 + 0x2C);
+        v0 &= 0xFFEF;
+        *(s16 *)(v1 + 0x2C) = v0;
+        *(s16 *)(s0 + 0x2) = 3;
+        *(u16 *)(s0 + 0x5C) = D_8019572A;
+    } else {
+        s32 a0 = *(s32 *)(s0 + 0x1C);
+        a0 = (a0 << 10) >> 4;
+        v0 = func_80047948(a0);
+        v1 = *(s32 *)(s0 + 0x20);
+        *(s16 *)(v1 + 0x1C) = v0;
+        *(s16 *)(v1 + 0x1A) = v0;
+        *(s16 *)(v1 + 0x18) = v0;
+    }
+}
+
 
 
 extern void func_8012A828(s32 a0, s32 a1);
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 84bdf2674..f04dd7597 100644
--- a/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
+++ b/src/ov_SC04_012/ov_SC04_012_jr_8017AE2C.c
@@ -3937,7 +3937,42 @@ void func_8017D248(s32 param_1, s16 *param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8017AE2C", func_8017D3E0);
+extern u16 D_80126B66;
+extern int func_80178970(void);
+extern void func_80178D18(void);
+extern s32 func_80178B18(s32 param_1, s32 param_2);
+extern void func_8012C218(void *a0);
+extern void (*D_80182154[])(s32);
+extern void (*D_801821A4[])(void);
+
+void func_8017D3E0(s32 a0) {
+    switch (*(u16 *)(a0 + 2)) {
+    case 0:
+        *(s32 *)(a0 + 0x1C) = 0x14;
+        *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1;
+        break;
+    case 1:
+        if (--*(s32 *)(a0 + 0x1C) == 0) {
+            if ((s16)D_80126B66 < 0x400) {
+                func_80178B18(a0, (s32)&D_80182154);
+            } else {
+                func_80178B18(a0, (s32)&D_801821A4);
+            }
+            *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1;
+        }
+        break;
+    case 2:
+        if (((s32 (*)(s32))func_80178970)(a0) == 0) {
+            return;
+        }
+        ((void (*)(s32))func_80178D18)(a0);
+        func_8012C218((void *)a0);
+        return;
+    default:
+        return;
+    }
+}
+
 
 INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8017AE2C", func_8017D4CC);