From 514383de6a5b0db9393fcd0e1e560be840e60bfa Mon Sep 17 00:00:00 2001
From: Drew T <50529377+Druthulu@users.noreply.github.com>
Date: Sat, 18 Jul 2026 12:33:39 -0600
Subject: [PATCH] chore(phase-29 crack-wave): log wave2+fable+type-lift outcome
 (fleet 74.6% instr) + preserve drafts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Session-total 72.1->74.6% instr (+2.5pp). 8 exemplars + ~815 members banked; 3 Fable source-read cracks
(cse.c address-CSE, post-reload sched, reorg j-slot). Follow-ups: 801670e4/8016cbc0 per-sibling decl-norm,
8013d53c caller-thread, 801412a8 §29 wall, 4 permuter near-misses. All drafts preserved (R20).
---
 .run/giants/fable_func_8012956C.c   | 133 +++++++++++++
 .run/giants/fable_func_8013D53C.c   | 138 ++++++++++++++
 .run/giants/fable_func_801670E4.c   | 189 ++++++++++++++++++
 .run/giants/func_8014D820.close11.c | 238 +++++++++++++++++++++++
 .run/giants/func_80175DA8.close11.c | 133 +++++++++++++
 .run/giants/wave2_func_801412A8.c   |  56 ++++++
 .run/giants/wave2_func_8014FFDC.c   |  40 ++++
 .run/giants/wave2_func_8015D738.c   |  97 ++++++++++
 .run/giants/wave2_func_8015EA3C.c   | 109 +++++++++++
 .run/giants/wave2_func_8015F448.c   | 108 +++++++++++
 .run/giants/wave2_func_8016CBC0.c   | 177 +++++++++++++++++
 docs/family-hseq.md                 |  90 ++++-----
 docs/progress.fleet.md              | 286 ++++++++++++++--------------
 phase-ends/CURRENT_PHASE.md         |  27 +++
 14 files changed, 1633 insertions(+), 188 deletions(-)
 create mode 100644 .run/giants/fable_func_8012956C.c
 create mode 100644 .run/giants/fable_func_8013D53C.c
 create mode 100644 .run/giants/fable_func_801670E4.c
 create mode 100644 .run/giants/func_8014D820.close11.c
 create mode 100644 .run/giants/func_80175DA8.close11.c
 create mode 100644 .run/giants/wave2_func_801412A8.c
 create mode 100644 .run/giants/wave2_func_8014FFDC.c
 create mode 100644 .run/giants/wave2_func_8015D738.c
 create mode 100644 .run/giants/wave2_func_8015EA3C.c
 create mode 100644 .run/giants/wave2_func_8015F448.c
 create mode 100644 .run/giants/wave2_func_8016CBC0.c

diff --git a/.run/giants/fable_func_8012956C.c b/.run/giants/fable_func_8012956C.c
new file mode 100644
index 000000000..425d990f9
--- /dev/null
+++ b/.run/giants/fable_func_8012956C.c
@@ -0,0 +1,133 @@
+#include "common.h"
+
+typedef struct { s32 a, b, c, d; } Blk16;
+
+typedef struct {
+    u8 pad0[0x1C];
+    s16 f1C;
+    s16 f1E;
+    u8 pad20[0x14];
+    u16 f34;
+    u16 f36;
+    u16 f38;
+    u16 f3A;
+    u8 pad3C[2];
+    s16 f3E;
+    u16 f40;
+    u16 f42;
+    u8 pad44[0x10];
+} Ent;
+
+extern s16 D_80114EE0;
+extern u8 D_800B9A78[];
+extern u8 D_801D9484[];
+extern u8 D_801D9485[];
+extern u8 D_801D9486[];
+extern u8 D_801D9488[];
+extern u8 D_801D9489[];
+extern u8 D_801D948A[];
+extern u8 D_801DAAA0;
+extern u8 D_800AF630[];
+extern u8 D_800A6518[];
+
+extern void func_801299C8();
+extern void func_80015B6C(s32, s16, s32, s16, s32, s32, s32, s32, s32, s32);
+extern void GsSortBg(s32 *, void *, u16, s32 *);
+extern void GsSortFastBg(s32 *, void *, u16, s32 *);
+
+void func_8012956C(void) {
+    register s32 *sp10 __asm__("$21");
+    register u8 *afbase __asm__("$22");
+    register s32 *sp0 __asm__("$23");
+    Ent *base;
+    s32 i;
+    s16 a1;
+    register u32 temp_a3 __asm__("$7");
+    register u32 arg0 __asm__("$4");
+    register u32 s __asm__("$2");
+    register u32 s2 __asm__("$3");
+    register u32 t6 __asm__("$8");
+    s32 code;
+
+    sp10 = (s32 *)0x1F800010;
+    sp0 = (s32 *)0x1F800000;
+    afbase = (u8 *)&D_800AF630;
+    if (D_80114EE0 == 0) {
+        return;
+    }
+    base = (Ent *)&D_800B9A78;
+    __asm__("" : "=r"(base) : "0"(base));
+    i = 0;
+    do {
+        s32 idx = i * 8 + 4;
+        code = base->f34;
+        if (code == 0x7FFE) {
+            goto case_7FFE;
+        }
+        if (code < 0x7FFF) {
+            a1 = i + 3;
+            if (code == 0x7FFD) {
+                goto case_7FFD;
+            }
+            goto do_default;
+        }
+        a1 = i + 3;
+        if (code != 0x7FFF) {
+            goto do_default;
+        }
+        goto next;
+    case_7FFD:
+        if (i == 0) {
+            func_801299C8(D_801DAAA0, 1, base);
+        }
+        func_80015B6C(-0xA0, -0x74, 0x140, 0x8C,
+                      D_801D9488[0], D_801D9488[1], D_801D9488[2],
+                      D_801D9488[4], D_801D9488[5], D_801D9488[6]);
+        func_80015B6C(-0xA0, 0x18, 0x140, 0x3C,
+                      D_801D9488[4], D_801D9488[5], D_801D9488[6],
+                      D_801D9488[8], D_801D9488[9], D_801D9488[0xA]);
+        func_80015B6C(-0xA0, 0x54, 0x140, 0x28,
+                      D_801D9488[8], D_801D9488[9], D_801D9488[0xA],
+                      D_801D9488[0xC], D_801D9488[0xD], D_801D9488[0xE]);
+        goto next;
+    case_7FFE:
+        func_801299C8(D_801DAAA0, (s16)(i * 2), base);
+        func_80015B6C(-0xA0, *(s16 *)&base->f3A, 0x140, base->f3E,
+                      D_801D9484[idx], D_801D9485[idx], D_801D9486[idx],
+                      D_801D9488[idx], D_801D9489[idx], D_801D948A[idx]);
+        goto next;
+    do_default:
+        __asm__("");
+        arg0 = D_801DAAA0;
+        s = base->f40;
+        temp_a3 = base->f38;
+        s += temp_a3;
+        base->f1C = s;
+        s2 = base->f42;
+        t6 = base->f3A;
+        s2 += t6;
+        base->f1E = s2;
+        func_801299C8(arg0, a1, base, temp_a3);
+        *(Blk16 *)sp0 = *(Blk16 *)base;
+        {
+            s32 *dst = sp10;
+            s32 *src = (s32 *)((u8 *)base + 0x10);
+            s32 *end = (s32 *)((u8 *)base + 0x30);
+            do {
+                *(Blk16 *)dst = *(Blk16 *)src;
+                src += 4;
+                dst += 4;
+            } while (src != end);
+            *dst = *src;
+            sp10[5] = (s32)sp0;
+            if (base->f36 == 0) {
+                GsSortFastBg(sp10, &D_800A6518[(*(u16 *)(afbase + 0xA3D2)) * 0x14], base->f34, dst);
+            } else {
+                GsSortBg(sp10, &D_800A6518[(*(u16 *)(afbase + 0xA3D2)) * 0x14], base->f34, dst);
+            }
+        }
+    next:
+        base += 1;
+        i += 1;
+    } while (i < 2);
+}
diff --git a/.run/giants/fable_func_8013D53C.c b/.run/giants/fable_func_8013D53C.c
new file mode 100644
index 000000000..a38b3103f
--- /dev/null
+++ b/.run/giants/fable_func_8013D53C.c
@@ -0,0 +1,138 @@
+#include "common.h"
+
+typedef struct { u8 b[9]; } S9;   /* 9-byte, align-1 -> unaligned block copy */
+
+typedef struct {
+    u16 cmd;        /* 0x0 */
+    u16 pad2;       /* 0x2 */
+    u16 pad4;       /* 0x4 */
+    u16 pad6;       /* 0x6 */
+    s16 w;          /* 0x8 */
+    s16 h;          /* 0xA */
+    u16 *data;      /* 0xC */
+} Cmd;              /* 0x10 */
+
+extern s32 D_801D95A0;
+extern u8 D_80078EAF;
+extern s32 D_801D9588;
+
+extern u8 D_80187484[];   /* stride 12 */
+extern u8 D_80187488[];
+extern u8 D_8018748C[];
+extern S9 D_8018744C[];    /* stride 9 */
+
+extern u8 D_801DAABA;
+extern u8 D_801DAB2E;
+extern u8 D_801DA9C2;
+extern u8 D_801DAA9C;
+extern u8 D_801DA998;
+extern u8 D_801DA9C1;
+
+extern S9 D_801DA9B8;
+extern S9 D_801DAA78;
+
+extern s32 D_801DAAA0;
+extern s32 D_801D959C;
+extern s32 D_801D9598;
+extern s32 D_801D9594;
+extern s32 D_801D9580;
+extern s32 D_801D958C;
+extern s32 D_801D9590;
+
+extern s32 *D_801D9570;
+extern Cmd *D_801D957C;
+extern s32 D_801D95A8;
+extern s32 *D_801D9578;
+extern s32 D_801D95AC;
+extern s32 D_801D95B0;
+extern s32 D_801D95B4;
+
+void func_8013D53C(Cmd *arg0) {
+    s32 s0v;
+    s32 t9v;
+    s32 t8v;
+    u8 b0, b1, b2;
+    u8 pad[8];   /* dead BLKmode local: frame 0x10 -> 0x18, zero code */
+
+    if (!(D_801D95A0 & 1)) {
+        D_801D9588 = 1;
+    } else {
+        D_801D9588 = D_80078EAF;
+    }
+
+    b0 = D_80187484[D_801D9588 * 12];
+    D_801DAABA = b0;
+    D_801DAB2E = b0;
+    b1 = D_80187488[D_801D9588 * 12];
+    D_801DA9C2 = b1;
+    D_801DAA9C = b1;
+    b2 = D_8018748C[D_801D9588 * 12];
+    D_801DA998 = b2;
+    D_801DA9C1 = b2;
+
+    D_801DA9B8 = D_8018744C[D_801D9588];
+    D_801DAA78 = *(S9 *)(&D_801DA998 + 0x20);  /* same addr as D_801DA9B8; distinct sym defeats cse, keeps %hi/%lo */
+
+    D_801DAAA0 = 1;
+    D_801D959C = -1;
+    D_801D9598 = 0;
+    D_801D9594 = -1;
+    D_801D9580 = 0;
+    D_801D958C = 0;
+    D_801D9590 = 0;
+
+    if ((D_801D95A0 & 2) && (D_801D9588 == 4)) {
+        s0v = D_801D9570[18];
+        t9v = D_801D9570[19];
+        t8v = D_801D9570[20];
+    } else {
+        s32 *p = (s32 *)(D_801D9588 * 12 + (s32) D_801D9570);  /* block-local: local-alloc ties sum into mul chain */
+        s0v = p[0];
+        t9v = p[1];
+        t8v = p[2];
+    }
+
+    D_801D957C = arg0;
+    if (arg0 != 0) {
+        if (D_801D95A8 != 0) {
+            s32 *p = (s32 *)(D_801D9588 * 12 + (s32) D_801D9578);
+            D_801D95AC = p[0];
+            D_801D95B0 = p[1];
+            D_801D95B4 = p[2];
+        } else {
+            while ((arg0->cmd & 0xFFFF) != 0xFF) {
+                if ((arg0->cmd & 0xFFFF) == 9) {
+                    s32 n;
+                    s32 i;
+                    u16 *src;
+                    u16 *dst;
+                    n = arg0->w * arg0->h;
+                    i = 0;
+                    src = arg0->data;
+                    __asm__("" :: "r"(src));  /* +2 refs on src (depth-2): keeps src above i, below the mfhi temp */
+                    dst = src + n;
+                    if (n > 0) {
+                        do {
+                            u16 px;
+                            s32 r, g, b, out;
+                            __asm__("" :: "r"(i));  /* +3 refs on i (depth-3): lifts i over dst in the $t2 race */
+                            px = *src;
+                            r = ((px & 0x1F) * s0v) / 2560;
+                            g = (((px & 0x3E0) * t9v) / 2560) & 0x3E0;
+                            b = (((px & 0x7C00) * t8v) / 2560) & 0x7C00;
+                            out = r | g | b | (px & 0x8000);
+                            if (out == 0 && px != 0) {
+                                out = 0x8000;
+                            }
+                            *dst = out;
+                            dst++;
+                            i++;
+                            src++;
+                        } while (i < n);
+                    }
+                }
+                arg0++;
+            }
+        }
+    }
+}
diff --git a/.run/giants/fable_func_801670E4.c b/.run/giants/fable_func_801670E4.c
new file mode 100644
index 000000000..01d7bb47d
--- /dev/null
+++ b/.run/giants/fable_func_801670E4.c
@@ -0,0 +1,189 @@
+// @class: schedule
+// @stuck: 16/279 masked. 3 runs, ONE residual class: gcc's list-scheduler puts `la $s2` (p=DATA) + `addu $s4,$zero,$zero` (i=0) BEFORE the callee-arg address setup (addiu $a1,$sp,0x10 / addu $a2,$a1,$zero); the target emits them AFTER. Inert to ~40 statement-order permutations + pin/barrier combos (sched priority dominates the LUID tie-break, sched.c rank_for_schedule). Runs: 19-24 (blk1), 111-114 (region-B cx-load rotation), 177-182 (blk3). Permuter fuel.
+
+typedef signed char s8;
+typedef unsigned char u8;
+typedef short s16;
+typedef unsigned short u16;
+typedef int s32;
+typedef unsigned int u32;
+
+typedef struct { s16 x, y, z, pad; } SVec_801670E4;   /* 8 bytes */
+
+typedef struct {
+    /* 0x00 */ u16 cx, cy, cz;
+    /* 0x06 */ u16 _p06;
+    /* 0x08 */ u16 a8[4];
+    /* 0x10 */ s32 pos[3];
+    /* 0x1C */ s32 _p1C;
+    /* 0x20 */ SVec_801670E4 v[4];
+    /* 0x40 */ struct { u8 r, g, b, cd; } col[4];
+    /* 0x50 */ u32 code;
+    /* 0x54 */ s32 _p54;
+    /* 0x58 */ u8 m1[0x20];
+    /* 0x78 */ u8 m2[0x20];
+} Fr_801670E4;   /* 0x98 bytes -> sp+0x10 .. sp+0xA8 */
+
+extern void func_80149350(s32 a0, void *a1, void *a2);
+extern void func_800D20C0(void *a0, void *a1, s32 a2);
+extern void func_80017E68(void *a0, void *a1);
+extern void func_800D23D0(void *a0);
+extern void RotMatrixYXZ(void *a0, void *a1);
+extern s32  func_80017758(void *a0, void *a1);
+extern s32  func_80017DC4(void *a0, void *a1);
+extern void func_80048EAC(void *a0, void *a1);
+
+extern u8  D_80189A20[];
+extern u8  D_80189A0C[];
+extern u8  D_80189A34[];
+extern s32 D_801269A4;
+extern s32 D_801269A8;
+extern s32 D_801269AC;
+extern u16 D_80126CE0;
+
+s32 func_801670E4(s32 arg0, s32 arg1, s32 arg2, s32 arg3) {
+    Fr_801670E4 f;
+    register u8 *p   __asm__("$18");   /* $s2 */
+    register s32 ent __asm__("$19");   /* $s3 */
+    s16 i;
+    s32 d;
+    s32 node;
+    u16 c;
+    u8 cv;
+    u8 cv2;
+    register s32 gA __asm__("$2");
+    register s32 cxv __asm__("$4");
+    register s32 czv __asm__("$5");
+    u8 *vc;
+    u8 *ap;
+    u8 *mp;
+    u8 *va;
+    u8 *vb;
+
+    ent = arg0;
+    node = *(s32 *)(ent + 0x34);
+    f.v[1].z = 0;
+    f.v[1].y = 0;
+    f.v[1].x = 0;
+    f.v[3].z = 0;
+    f.v[2].z = 0;
+    f.v[0].z = 0;
+    f.col[1].b = 0x70;
+    cv = *(u8 *)(ent + 0x12);
+    f.cx = arg1;
+    __asm__ __volatile__("");
+    va = (u8 *)&f.cx;
+    __asm__ __volatile__("" : "=r"(va) : "0"(va));
+    f.cy = arg2;
+    vb = va;
+    __asm__ __volatile__("" : "=r"(vb) : "0"(vb));
+    p = D_80189A20;
+    i = 0;
+    f.col[0].b = 0;
+    f.col[0].g = 0;
+    f.col[0].r = 0;
+    f.col[2].b = 0;
+    f.col[2].g = 0;
+    f.col[2].r = 0;
+    f.col[3].b = 0;
+    f.col[3].g = 0;
+    f.col[3].r = 0;
+    f.code = 0x50000000;
+    f.cz = arg3;
+    f.col[1].r = cv;
+    f.col[1].g = cv;
+    func_80149350(node, va, vb);
+
+    c = f.cx;
+    *(s16 *)(ent + 0x06) = c;
+    *(s32 *)(ent + 0x4C) = (s16)c;
+    c = f.cy;
+    *(s16 *)(ent + 0x0A) = c;
+    *(s32 *)(ent + 0x50) = (s16)c;
+    c = f.cz;
+    *(s16 *)(ent + 0x0E) = c;
+    *(s32 *)(ent + 0x54) = (s16)c;
+    func_800D20C0(&f.cx, f.a8, 7);
+    func_80017E68(&f.cx, f.m1);
+    func_800D23D0(f.a8);
+    RotMatrixYXZ(f.a8, f.m1);
+
+    do {
+        f.v[0].x = (s8)*p++;
+        f.v[0].y = (s8)*p++;
+        f.v[2].x = (s8)*p++;
+        f.v[2].y = (s8)*p++;
+        f.v[3].x = (s8)*p++;
+        f.v[3].y = (s8)*p--;
+        func_80017758(f.v, f.m1);
+    } while ((i = i + 1) < 4);
+
+    p = D_80189A0C;
+    gA = 0xA0;
+    cxv = (s16)f.cx;
+    f.col[1].g = gA;
+    gA = D_801269A4;
+    czv = (s16)f.cz;
+    f.col[1].b = 0x10;
+    f.col[1].r = 0x10;
+    f.pos[0] = gA - cxv;
+    i = 0;
+    f.v[3].y = 0;
+    f.v[2].y = 0;
+    f.v[0].y = 0;
+    f.pos[1] = D_801269A8 - (s16)f.cy;
+    f.pos[2] = D_801269AC - czv;
+
+    do {
+        f.v[0].x = (s8)*p++;
+        f.v[0].z = (s8)*p++;
+        f.v[2].x = (s8)*p++;
+        f.v[2].z = (s8)*p++;
+        f.v[3].x = (s8)*p++;
+        f.v[3].z = (s8)*p--;
+        func_80017758(f.v, (void *)(ent + 0x38));
+    } while ((i = i + 1) < 4);
+
+    if (*(s32 *)(ent + 0x30) > 0) {
+        vc = (u8 *)&f.cx;
+        __asm__ __volatile__("" : "=r"(vc) : "0"(vc));
+        mp = f.m1;
+        ap = mp;
+        __asm__ __volatile__("" : "=r"(ap) : "0"(ap));
+        p = D_80189A34;
+        i = 0;
+        d = (s16)f.a8[0] >> 6;
+        f.cx += d;
+        f.cy += d;
+        f.cz += d;
+        func_80017E68(vc, ap);
+        f.cx = f.cy = f.cz = ((u32)*(s32 *)(ent + 0x30) >> 1) + D_80126CE0 * 0x20;
+        func_80017DC4(&f.cx, f.m2);
+        func_80048EAC(f.m2, mp);
+        f.v[3].z = 0;
+        f.v[2].z = 0;
+        f.v[0].z = 0;
+        cv2 = *(u8 *)(ent + 0x12);
+        f.col[1].b = 0x20;
+        f.col[1].r = 0x20;
+        f.col[3].b = 0;
+        f.col[3].r = 0;
+        f.col[2].b = 0;
+        f.col[2].r = 0;
+        f.col[0].b = 0;
+        f.col[0].r = 0;
+        f.col[3].g = 0;
+        f.col[2].g = 0;
+        f.col[0].g = 0;
+        f.col[1].g = cv2 + 0x60;
+        do {
+            f.v[0].x = (s8)*p++;
+            f.v[0].y = (s8)*p++;
+            f.v[2].x = (s8)*p++;
+            f.v[2].y = (s8)*p++;
+            f.v[3].x = (s8)*p++;
+            f.v[3].y = (s8)*p--;
+            func_80017758(f.v, f.m1);
+        } while ((i = i + 1) < 8);
+    }
+}
diff --git a/.run/giants/func_8014D820.close11.c b/.run/giants/func_8014D820.close11.c
new file mode 100644
index 000000000..0c6458220
--- /dev/null
+++ b/.run/giants/func_8014D820.close11.c
@@ -0,0 +1,238 @@
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef signed char s8;
+typedef short s16;
+typedef int s32;
+typedef float f32;
+typedef unsigned long long u64;
+typedef long long s64;
+typedef double f64;
+typedef s32 M2C_UNK;
+typedef s8 M2C_UNK8;
+typedef s16 M2C_UNK16;
+typedef s32 M2C_UNK32;
+typedef s64 M2C_UNK64;
+typedef struct 
+{
+  u16 x;
+  u16 y;
+  u16 z;
+  u16 w;
+} V4;
+typedef struct 
+{
+  u16 x;
+  u16 y;
+  u16 z;
+  u16 w;
+  s32 pad[4];
+  s32 f18;
+  s32 f1C;
+  s32 f20;
+} Desc;
+typedef struct Ent
+{
+  u16 f0;
+  u16 f2;
+  u16 f4;
+  u16 x;
+  u16 f8;
+  u16 y;
+  u16 fC;
+  u16 z;
+  u8 p10[0x10];
+  s32 f20;
+  u8 p24[0x34];
+  s32 f58;
+  u16 f5C;
+  u16 f5E;
+  u8 p60[0x10C - 0x60];
+} Ent;
+extern s16 currentLocationId;
+extern Ent D_801202A0[];
+extern u8 D_8018876C[];
+extern u16 D_801152A8;
+extern u16 D_801152AC;
+extern s32 ratan2(s32 a0, s32 a1);
+extern s32 func_80135A4C(s32 a0, s32 a1, s32 *a2, s32 a3);
+extern s32 func_80012A60(s32 a0, s32 a1);
+extern void func_800139C8(s32 a0, void *a1, void *a2);
+extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3);
+extern s32 func_8014DCE0(s32 a0, s32 a1, s32 a2);
+extern s32 func_80133784(s32 a0, void *a1, s32 a2);
+s32 func_8014D820(s32 a0, u16 *a1, u16 *a2x)
+{
+register u16 *a2 __asm__("$7") = a2x;
+  V4 out[3];
+  V4 pos;
+  Desc desc;
+  Ent *ent;
+  Ent *p;
+  s32 dx;
+  s32 dz;
+  s32 ex;
+  s32 ez;
+  s32 r1;
+  s32 r2;
+  s32 r3;
+  s32 ang;
+  s32 x0;
+  s32 y0;
+  s32 z0;
+  s32 tx;
+  s32 tz;
+  s32 r;
+  s32 t;
+  s32 ap;
+  s32 loc;
+register s32 u __asm__("$2");
+register s32 w __asm__("$4");
+  __asm__ __volatile__("" : "=r"(a2) : "0"(a2));
+  t = a2[0];
+  u = a1[0];
+  dx = t - u;
+  ap = a0;
+  __asm__ __volatile__("" :: "r"(ap));
+  t = a2[2];
+  u = a1[2];
+  dz = t - u;
+  if (((s16) (dx | dz)) == 0)
+  {
+    goto fail;
+  }
+  w = dx;
+  desc.x = w;
+  desc.y = a2[1] - a1[1];
+  desc.z = a2[2] - a1[2];
+  ent = *((Ent **) (ap + 0x170));
+  if (ent->f0 == 0)
+  {
+    goto fail;
+  }
+  if ((ent->f5C & 0x1000) == 0)
+  {
+    goto fail;
+  }
+  if (ent->f58 == 0)
+  {
+    goto fail;
+  }
+  if (((s32 (*)(s32, s32, s32)) func_80135A4C)(ent->f20, ent->f58, (s32) a1) == 0)
+  {
+    goto fail;
+  }
+  ex = ent->x - (*((u16 *) (ap + 6)));
+  ez = ent->z - (*((u16 *) (ap + 0xE)));
+  r1 = (s16) ratan2((s16) dz, (s16) dx);
+  r2 = (s16) ratan2((s16) ez, (s16) ex);
+  r3 = (s16) func_80012A60(r1, r2);
+  if (r3 >= 0x400)
+  {
+    goto fail;
+  }
+  desc.f20 = 0;
+  desc.f1C = 0;
+  desc.f18 = 0;
+  pos.x = (x0 = ent->x);
+  z0 = ent->z;
+  tx = x0 + desc.x;
+  u = ent->y;
+  pos.y = u;
+  desc.y = (u + desc.y) + 8;
+  tz = z0 + desc.z;
+  loc = currentLocationId;
+  desc.x = tx;
+  pos.z = z0;
+  desc.z = tz;
+  if (loc != 0x3008)
+  {
+    for (p = D_801202A0; p < (D_801202A0 + 96); p++)
+    {
+      if (p == ent)
+      {
+        continue;
+      }
+      if (p->f0 == 0)
+      {
+        continue;
+      }
+      if (p->f5C == 0)
+      {
+        continue;
+      }
+      if (p->f58 == 0)
+      {
+        continue;
+      }
+      func_80135888(p->f20, p->f58, (s32) (&pos), (s32) (&desc));
+    }
+
+  }
+  else
+  {
+    ang = ratan2(((s16) x0) - ((s16) tx), ((s16) z0) - ((s16) tz)) & 0xFFF;
+    func_800139C8(ang, D_8018876C, &out[0]);
+    func_800139C8((s16) (ang - 0x155), D_8018876C, &out[1]);
+    func_800139C8((s16) (ang + 0x155), D_8018876C, &out[2]);
+    out[0].x += pos.x;
+    out[0].y = pos.y;
+    out[0].z += pos.z;
+    out[1].x += pos.x;
+    out[1].y = pos.y;
+    out[1].z += pos.z;
+    out[2].x += pos.x;
+    out[2].y = pos.y;
+    out[2].z += pos.z;
+    for (p = D_801202A0; p < (D_801202A0 + 96); p++)
+    {
+      if (p == ent)
+      {
+        continue;
+      }
+      if (p->f0 == 0)
+      {
+        continue;
+      }
+      if (p->f5C == 0)
+      {
+        continue;
+      }
+      if (p->f58 == 0)
+      {
+        continue;
+      }
+      if (func_8014DCE0((s32) p, (s32) (&pos), (s32) (&out[0])) != 0)
+      {
+        __builtin_memcpy((void *) ((s32) (&desc)), (void *) ((s32) (&pos)), 8);
+      }
+    }
+
+  }
+  r = func_80133784(0, &pos, (s32) (&desc));
+  if ((r == 0) || ((r == 0x2000) && ((D_801152A8 | D_801152AC) == 0)))
+  {
+    ent->x = desc.x - desc.f18;
+    ent->y = desc.y;
+    ent->z = desc.z - desc.f20;
+    desc.x -= pos.x;
+    desc.y -= pos.y;
+    desc.z -= pos.z;
+    *((u16 *) (ap + 6)) = a1[0] + desc.x;
+    u = desc.y + 0x10;
+  *((u16 *) (ap + 0xA)) = a1[1] + u;
+    *((u16 *) (ap + 0xE)) = a1[2] + desc.z;
+  }
+  else
+  {
+    *((u16 *) (ap + 6)) = a1[0];
+    *((u16 *) (ap + 0xA)) = a1[1] + 0x10;
+    *((u16 *) (ap + 0xE)) = a1[2];
+  }
+  return 1;
+  fail:
+  *((s32 *) (ap + 0x170)) = 0;
+
+  return 0;
+}
diff --git a/.run/giants/func_80175DA8.close11.c b/.run/giants/func_80175DA8.close11.c
new file mode 100644
index 000000000..03a7bd5c5
--- /dev/null
+++ b/.run/giants/func_80175DA8.close11.c
@@ -0,0 +1,133 @@
+#include "common.h"
+
+extern u8 D_8011F7F0;
+extern u8 D_8018A1DC[];
+typedef struct { s32 unk0; s32 count; s32 buf; } AFEntry;
+extern AFEntry D_800AF630[];
+extern u8 D_800B9A13;
+extern u16 D_8018A238;
+extern u16 D_8018A22C[];
+extern u8 D_8018A2CC[];
+extern u8 D_8018A2B8[];
+extern s32 D_8018A2E4[];
+extern u8 D_800D45D4;
+extern u8 D_800D43D4;
+extern u8 D_800D4414;
+
+extern s32 *func_8017742C(s32 *a0, s16 a1, s16 a2, s32 a3);
+extern void func_8005A600(s32 *a0, s32 a1, s32 a2, s32 a3, s32 a4);
+extern void func_800183E0(void *a0, void *a1);
+
+void func_80175DA8(s16 arg0) {
+    register u8 *base __asm__("$18");
+    u8 *s1;
+    u8 *src = D_8018A1DC;
+    u8 *s0;
+    s32 i;
+    register s32 t __asm__("$3");
+    s32 cond;
+
+    base = &D_8011F7F0;
+    s1 = base - 0x48;
+    s0 = (u8 *)(D_800AF630[arg0].buf + (D_800AF630[arg0].count << 2));
+    *(s32 *)(s1 + arg0 * 4 + 0x28) = (s32)s0;
+    i = 0;
+    do {
+        *(u32 *)s0 = (((u32)s0 - 0x14) & 0xFFFFFF) | 0x4000000;
+        *(u32 *)(s0 + 4) = *(u32 *)src;
+        __asm__("" : "=r"(i) : "0"(i));
+        src += 4;
+        if ((s16)i < 2) {
+            *(s16 *)(s0 + 8) = *(u16 *)src + *(u16 *)(s1 + 0xC);
+            src += 2;
+            *(s16 *)(s0 + 0xA) = *(u16 *)src + *(u16 *)(s1 + 0xE);
+            src += 2;
+        } else if ((s16)i == 2) {
+            *(s16 *)(s0 + 8) = *(u16 *)src + *(u16 *)(s1 + 0x10);
+            src += 2;
+            *(s16 *)(s0 + 0xA) = *(u16 *)src + *(u16 *)(s1 + 0x12);
+            src += 2;
+        } else {
+            *(s16 *)(s0 + 8) = *(u16 *)src + *(u16 *)(s1 + 0x14);
+            src += 2;
+            *(s16 *)(s0 + 0xA) = *(u16 *)src + *(u16 *)(s1 + 0x16);
+            src += 2;
+        }
+        *(u32 *)(s0 + 0xC) = *(u32 *)src;
+        src += 4;
+        t = i + 1;
+        cond = (s16)t < 5;
+        i = t;
+        *(u32 *)(s0 + 0x10) = *(u32 *)src;
+        src += 4;
+        s0 += 0x14;
+    } while (cond);
+
+    *(u8 *)(s1 + 7) = D_800B9A13;
+    s0 = (u8 *)func_8017742C((s32 *)s0,
+                             (s16)(*(u16 *)(s1 + 0x10) - 0x98),
+                             (s16)(*(u16 *)(s1 + 0x12) + 9),
+                             i);
+    func_8005A600((s32 *)s0, 0, 0, 0x16, 0);
+    *(u32 *)s0 = (((u32)s0 - 0x14) & 0xFFFFFF) | 0x2000000;
+    *(s32 *)(s1 + arg0 * 4 + 0x30) = (s32)s0;
+    s0 += 0x14;
+    D_800AF630[arg0].count +=
+        ((s32)s0 - *(s32 *)(s1 + arg0 * 4 + 0x28)) >> 2;
+    s0 = (u8 *)*(s32 *)(s1 + arg0 * 4 + 0x28);
+    if (base[0x48] != 0) {
+        *(u8 *)(s0 + 0xD) = 0;
+    } else {
+        *(u8 *)(s0 + 0xD) = 0xA0;
+    }
+
+    {
+        void *arg;
+        u8 *q = (u8 *)*(s32 *)(s1 + arg0 * 4 + 0x28);
+        s32 c;
+        *(s16 *)(q + 0x22) = 0x6CD6;
+        c = base[0x48];
+        if (c & 0x80) {
+            arg = &D_800D45D4;
+            *(s16 *)(q + 0x20) = D_8018A238;
+        } else {
+            u16 *p = &D_8018A22C[0];
+            if ((c & 0xFF) != 0) {
+                p = (u16 *)((u8 *)&D_8018A22C[0] + ((c & 0xFF) - 1) * 2);
+            }
+            *(s16 *)(q + 0x20) = *p;
+            arg = (void *)D_8018A2E4[base[0x48]];
+        }
+        func_800183E0(arg, q);
+    }
+
+    {
+        u8 *q = (u8 *)*(s32 *)(s1 + arg0 * 4 + 0x28);
+        s32 h = *(u16 *)(base + 0x2E) << 16;
+        if (h != 0) {
+            *(u8 *)(q + 0x49) = D_8018A2CC[h >> 20];
+        } else {
+            *(u8 *)(q + 0x49) = 0xA0;
+        }
+    }
+
+    {
+        u8 *q = (u8 *)*(s32 *)(s1 + arg0 * 4 + 0x28);
+        void *arg;
+        u16 w = *(u16 *)(base + 0x40);
+        if (w < 0x64) {
+            *(u8 *)(q + 0x5D) = D_8018A2B8[w / 5];
+        } else {
+            *(u8 *)(q + 0x5D) = 0;
+        }
+        {
+            s32 flag = *(s16 *)(base + 0x1E) & 0x8000;
+            __asm__("");
+            arg = &D_800D43D4;
+            if (flag) {
+                arg = &D_800D4414;
+            }
+        }
+        func_800183E0(arg, q);
+    }
+}
diff --git a/.run/giants/wave2_func_801412A8.c b/.run/giants/wave2_func_801412A8.c
new file mode 100644
index 000000000..7967b4fd3
--- /dev/null
+++ b/.run/giants/wave2_func_801412A8.c
@@ -0,0 +1,56 @@
+#include "common.h"
+typedef struct { u32 addr : 24; u32 len : 8; } PTag_1412A8;
+typedef struct { u32 *ot; u32 pad[4]; } Env_1412A8;
+typedef struct { u32 tag; u32 w1; u32 w2; u32 w3; } Prim_1412A8;
+extern Env_1412A8 D_800AE7BC[];
+extern short D_800B9A02;
+extern u16 D_80115116;
+#define OT_1412A8            (D_800AE7BC[*(volatile u16 *)&D_800B9A02].ot)
+#define getaddr_1412A8(t)    (((PTag_1412A8 *)(t))->addr)
+#define setaddr_1412A8(t, v) (((PTag_1412A8 *)(t))->addr = (u32)(v))
+#define addPrim_1412A8(ot, p) (setaddr_1412A8(p, getaddr_1412A8(ot)), setaddr_1412A8(ot, p))
+Prim_1412A8 *func_801412A8(Prim_1412A8 *out, int a1, int a2, int a3, u16 a4, u16 a5) {
+    Prim_1412A8 *p = out;
+    int y = a5;
+    
+    int color = 0xF800F8;
+    int val;
+    if ((short)a1) {
+        val = 0x5E;
+        if (D_80115116 & 1) { color = 0xF89C00; }
+    } else if ((short)a2) {
+        val = (short)a3 * 0x5E / (short)a2;
+    } else {
+        val = 0x5E;
+        color = 0xF89C00;
+    }
+    p->tag = 0x03000000;
+    p->w1 = color | 0x60000000;
+    p->w2 = a4 | (((short)y + 0xA) << 16);
+    p->w3 = val | 0x20000;
+    addPrim_1412A8(&OT_1412A8[2], p);
+    p++;
+    p->w1 = 0x60080808;
+    p->tag = 0x03000000;
+    p->w2 = a4 | (((short)y + 0xA) << 16);
+    p->w3 = 0x2005E;
+    addPrim_1412A8(&OT_1412A8[2], p);
+    p++;
+    p->w1 = 0x60FFFFFF;
+    p->tag = 0x03000000;
+    p->w2 = (((short)y + 9) << 16) | (u16)(a4 - 1);
+    p->w3 = 0x20060;
+    addPrim_1412A8(&OT_1412A8[2], p);
+    p++;
+    p->tag = 0x03000000;
+    p->w1 = 0x60E0C0A0;
+    p->w2 = (((short)y + 0xB) << 16) | (u16)(a4 - 1);
+    p->w3 = 0x20060;
+    addPrim_1412A8(&OT_1412A8[2], p);
+    return p + 1;
+}
+/* BANK BLOCKER (Phase-29, 2026-07-18): match_one MATCH (198) but §29 narrow-param def-side wall.
+ * Def needs u16 a4/a5 (lhu reloads, the crack depends on it); caller func_80141100's canonical decl
+ * is int(6). Changing the caller decl to u16 compiles but ADDS masking insns in the callers (SHA fail
+ * 072fd9af vs d19c9580) — not byte-neutral. Genuine §29 wall (return-widen has a macro escape, param
+ * narrow does not). Fable/careful caller-threading follow-up. Draft above is the byte-correct body. */
diff --git a/.run/giants/wave2_func_8014FFDC.c b/.run/giants/wave2_func_8014FFDC.c
new file mode 100644
index 000000000..2874c8140
--- /dev/null
+++ b/.run/giants/wave2_func_8014FFDC.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+extern u8 D_801202A0[];
+extern u8 D_80126720[];
+extern u8 D_801152A8[];
+extern s32 func_80135D20(s32 a0, s32 a1, void *a2);
+
+typedef struct { s16 unk0, unk2, unk4, unk6; } Vec8;
+
+s32 func_8014FFDC(s32 e, void *a1, void *a2) {
+    Vec8 save;
+    Vec8 test;
+    s32 found;
+    u8 *p;
+
+    found = 0;
+    __builtin_memcpy(&save, a1, 8);
+    *(s16 *)((s32)a1 + 2) = 0x7fff;
+    p = D_801202A0;
+    if (p < p + 0x6480) {
+        do {
+            if (*(u16 *)p != 0) {
+                if ((*(u16 *)(p + 0x5C) & 0x400) != 0) {
+                    if (*(s32 *)(p + 0x58) != 0) {
+                        test = save;
+                        if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) {
+                            found = 1;
+                            if (test.unk2 < *(s16 *)((s32)a1 + 2)) {
+                                __builtin_memcpy(a1, &test, 8);
+                                __builtin_memcpy(a2, D_801152A8, 8);
+                            }
+                        }
+                    }
+                }
+            }
+            p += 0x10C;
+        } while (p < D_80126720);
+    }
+    return found;
+}
diff --git a/.run/giants/wave2_func_8015D738.c b/.run/giants/wave2_func_8015D738.c
new file mode 100644
index 000000000..99a183e13
--- /dev/null
+++ b/.run/giants/wave2_func_8015D738.c
@@ -0,0 +1,97 @@
+#include "common.h"
+
+extern void func_80148AFC(void);
+extern s32 func_80161B18(void *);
+extern s32 func_80161B84(void *);
+extern s32 func_80148800(void *);
+extern s32 func_8014BEF8(void *);
+extern s32 func_80165624(void *);
+extern s32 func_801488A8(void *);
+extern s32 func_8014D738(void *);
+extern s32 func_80161208(void *);
+extern void func_80154A74(void *, s32);
+extern void func_8015DAC4(void *);
+extern void func_8015DE24(void *);
+extern void func_8015DA5C(void *);
+extern void func_8015F948(void *);
+extern void func_800CAF14(void *);
+extern void func_80154150(void *, s32);
+extern void func_80146DB8(void *, void *);
+extern void func_80147A84(void *);
+extern void func_801473EC(void *);
+extern void func_80149374(void *, void *);
+extern void func_80147078(void *, s32);
+extern void func_80159B70(void *);
+extern void func_8015C714(void *);
+extern void func_801483E8(void *);
+
+extern void (*D_801891B8[])(void *);
+extern u8 D_80078E78[];
+extern u8 D_801893FC[];
+extern u8 D_8018917C[];
+extern u8 D_8018918C[];
+
+void func_8015D738(void *arg0) {
+    u8 *p = D_80078E78;
+    s32 s1;
+    func_80148AFC();
+    if (func_80161B18(arg0) != 0) return;
+    if (func_80161B84(arg0) != 0) return;
+    s1 = *(s32 *)((char *)arg0 + 0x178);
+    if (s1 != 0) {
+        if (*(u16 *)s1 == 0x360) goto block_808;
+    }
+    __asm__ __volatile__("");
+    if (s1 != 0) {
+        if (*(u16 *)s1 != 0) goto block_7F4;
+    }
+    D_801891B8[*(u16 *)arg0](arg0);
+    func_80147078(arg0, 0);
+    func_80159B70(arg0);
+    return;
+block_7F4:
+    if (func_80148800(arg0) & 0x80) {
+    block_808:
+        func_80154A74(arg0, 0x11);
+        func_8015DAC4(arg0);
+        return;
+    }
+    if ((func_80148800(arg0) & 0x10) && func_8014BEF8(arg0) != 0) {
+        func_80154A74(arg0, 0x11);
+        func_8015DE24(arg0);
+        return;
+    }
+    if ((func_80148800(arg0) & 0x20) && p[0x49] == 0xA) {
+        if (func_80165624(arg0) != 0) {
+            func_8015DA5C(arg0);
+            func_8015F948(arg0);
+            return;
+        }
+        func_80154A74(arg0, 0x11);
+        func_800CAF14(arg0);
+        return;
+    }
+    if (func_801488A8(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {
+        func_80154150(arg0, 0x1B);
+        func_80146DB8(arg0, &D_8018917C);
+    } else {
+        func_80154150(arg0, 0x1A);
+        func_80146DB8(arg0, &D_8018918C);
+    }
+    func_80147A84(arg0);
+    func_801473EC(arg0);
+    s1 = *(s32 *)((char *)arg0 + 0x178);
+    *(s16 *)(s1 + 6) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));
+    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));
+    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));
+    func_80149374(arg0, (void *)(s1 + 4));
+    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;
+    if (func_8014D738(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80147078(arg0, 9);
+        func_8015C714(arg0);
+        return;
+    }
+    if (func_80161208(arg0) != 0) return;
+    func_801483E8(arg0);
+}
diff --git a/.run/giants/wave2_func_8015EA3C.c b/.run/giants/wave2_func_8015EA3C.c
new file mode 100644
index 000000000..55f1456c0
--- /dev/null
+++ b/.run/giants/wave2_func_8015EA3C.c
@@ -0,0 +1,109 @@
+#include "common.h"
+
+extern s32 func_801487F4(void);
+extern void func_80147078(void *a0, s16 a1);
+extern void func_80159B70(void *a0);
+extern s32 func_80149D10(void *a0);
+extern void func_80175150(void *a0);
+extern void func_8016EE40(s32 a0, s32 a1);
+extern s32 func_80149744(void *a0);
+extern void func_80149788(void *a0);
+extern s32 func_80161B84(void *a0);
+extern s32 func_8014A4B4(void *a0);
+extern void func_8014A4FC(void *a0);
+extern s32 func_80149AA8(void *a0);
+extern void func_80149AD4(void *a0);
+extern s32 func_80149B54(void *a0);
+extern void func_80149BAC(void *a0);
+extern s32 func_800CF8B4(void);
+extern s32 func_801491C4(void *a0);
+extern s32 func_80148E54(void *a0);
+extern void func_8001382C(s32 a0, void *a1, void *a2);
+extern void func_80146DB8(void *a0, void *a1);
+extern void func_80147A84(void *a0);
+extern void func_801473EC(void *a0);
+extern void func_80154150(void *a0, s32 a1);
+extern s32 func_8014D738(void *a0);
+extern void func_8015C714(void *a0);
+extern s32 func_80161208(void *a0);
+extern void func_801483E8(void *a0);
+
+extern void (*D_801891B8[])(void *);
+extern u16 D_801152A0;
+
+void func_8015EA3C(void *arg0) {
+    s32 invec[4];
+    s32 outbuf[4];
+    s32 temp;
+    s32 r;
+
+    if (!(func_801487F4() & 8)) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80147078(arg0, 0);
+        func_80159B70(arg0);
+        return;
+    }
+    r = func_80149D10(arg0);
+    if (r == 1) goto Lcase1;
+    if (r < 2) goto Ldefault;
+    if (r == 2) goto Lcase2;
+    goto Ldefault;
+Lcase1:
+    D_801891B8[*(u16 *)arg0](arg0);
+    func_80175150(arg0);
+    return;
+Lcase2:
+    func_8016EE40(*(s32 *)((u8 *)arg0 + 0x21C), 0x01000000);
+    return;
+Ldefault:
+    if (func_80149744(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80149788(arg0);
+        return;
+    }
+    if (func_80161B84(arg0) != 0) {
+        return;
+    }
+    if (func_8014A4B4(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_8014A4FC(arg0);
+        return;
+    }
+    if (func_80149AA8(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80149AD4(arg0);
+        return;
+    }
+    if (func_80149B54(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80149BAC(arg0);
+        return;
+    }
+    if (func_800CF8B4() != 0) {
+        *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x12) =
+            (D_801152A0 + func_801491C4(arg0)) & 0xFFF;
+    }
+    temp = func_80148E54(arg0);
+    if ((s16)temp >= 0) {
+        s32 d = temp - *(u16 *)(*(s32 *)((u8 *)arg0 + 0x20) + 0x12);
+        invec[0] = 0;
+        invec[1] = 0;
+        invec[2] = 0xFFFC0000;
+        func_8001382C((s16)d, invec, outbuf);
+        func_80146DB8(arg0, outbuf);
+        func_80147A84(arg0);
+        func_801473EC(arg0);
+        func_80154150(arg0, 0x1E);
+    } else {
+        func_80154150(arg0, 0x1D);
+    }
+    if (func_8014D738(arg0) != 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        func_80147078(arg0, 9);
+        func_8015C714(arg0);
+        return;
+    }
+    if (func_80161208(arg0) == 0) {
+        func_801483E8(arg0);
+    }
+}
diff --git a/.run/giants/wave2_func_8015F448.c b/.run/giants/wave2_func_8015F448.c
new file mode 100644
index 000000000..38e50016b
--- /dev/null
+++ b/.run/giants/wave2_func_8015F448.c
@@ -0,0 +1,108 @@
+#include "common.h"
+
+extern void (*D_801891B8[])(void *);
+extern s32 D_80062BD0;
+extern s32 D_801894C4;
+extern s32 D_801894D4;
+extern s32 D_801894E4;
+
+extern s32 func_80149884(void);
+extern s32 func_801496D4(s32 a0);
+extern void func_80149724(s32 a0);
+extern void func_801477E8(s32 a0, s32 a1);
+extern s32 func_80148800(s32 a0);
+extern s32 func_80148980(s32 a0);
+extern s32 func_8014F1F4(s32 a0);
+extern s32 func_8014FCFC(s32 a0);
+extern void func_80146A6C(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
+extern void func_80147A84(s32 a0);
+extern void func_801473EC(s32 a0);
+extern void func_80146DB8(s32 a0, s32 *a1);
+extern void func_80146E90(s32 a0, s32 a1);
+extern void func_8014ED28(s32 a0);
+extern void func_8014FA04(s32 a0);
+extern void func_801725B8(s32 a0);
+extern void func_80147324(s32 a0);
+extern void func_80019064(s32 *a0);
+extern void func_801484B0(void *a0, void *a1);
+extern void func_80148534(void *a0, void *a1);
+
+void func_8015F448(s32 arg0) {
+    s32 sp20[2];
+    s32 sp28[2];
+
+    if (((*(u32 *)(arg0 + 0x44) & 0x100) && (func_80149884() != 0)) ||
+        (func_801496D4(arg0) != 0)) {
+        D_801891B8[*(u16 *)arg0]((void *)arg0);
+        *(u8 *)(arg0 + 0x1BE) = 0xA;
+        func_80149724(arg0);
+        func_801477E8(arg0, 0);
+        return;
+    }
+
+    if (*(u8 *)(arg0 + 0x245) == 0) {
+        if (*(u8 *)(arg0 + 0x244) == 0) {
+            if (func_80148800(arg0) & 0x10) {
+                *(u8 *)(arg0 + 0x244) = 1;
+                *(u8 *)(arg0 + 0x245) = 1;
+            }
+        } else if (func_80148800(arg0) & 0x80) {
+            *(u8 *)(arg0 + 0x244) = 0;
+            *(u8 *)(arg0 + 0x245) = 1;
+        }
+    }
+
+    if (*(u16 *)(arg0 + 0xB8) & 0x3000) {
+        if (*(u16 *)(arg0 + 0xB8) & 0x2000) {
+            func_801484B0(sp20, sp28);
+            func_80147324(0x56D);
+        } else {
+            func_80148534(sp20, sp28);
+            func_80147324(0x56E);
+        }
+        func_80019064(&D_80062BD0);
+        func_80146A6C(0x25, arg0, *(s16 *)(arg0 + 6),
+                      (s16)(*(u16 *)(arg0 + 0xA) - 0x14),
+                      *(s16 *)(arg0 + 0xE), 0, 0);
+        func_80146A6C(0x25, arg0, *(s16 *)(arg0 + 6),
+                      (s16)(*(u16 *)(arg0 + 0xA) - 0x14),
+                      *(s16 *)(arg0 + 0xE), 1, 0);
+    }
+
+    if (*(u16 *)(arg0 + 0xB8) & 0x8000) {
+        if (*(u8 *)(arg0 + 0x245) != 0) {
+            *(u8 *)(arg0 + 0x245) = 0;
+            *(u16 *)(arg0 + 0xB8) = *(u16 *)(arg0 + 0xBA);
+            if (func_80148980(arg0) != 0) {
+                func_80146DB8(arg0, &D_801894C4);
+            } else {
+                func_80146DB8(arg0, &D_801894D4);
+            }
+        }
+    } else {
+        *(u16 *)(arg0 + 0x246) = *(u16 *)(arg0 + 6);
+        *(u16 *)(arg0 + 0x248) = *(u16 *)(arg0 + 0xA);
+        *(u16 *)(arg0 + 0x24A) = *(u16 *)(arg0 + 0xE);
+        func_80147A84(arg0);
+        func_801473EC(arg0);
+        if (func_8014F1F4(arg0) != 0) {
+            *(u16 *)(arg0 + 6) = *(u16 *)(arg0 + 0x246);
+            *(u16 *)(arg0 + 0xA) = *(u16 *)(arg0 + 0x248);
+            *(u16 *)(arg0 + 0xE) = *(u16 *)(arg0 + 0x24A);
+        }
+    }
+
+    if (func_8014FCFC(arg0) == 0) {
+        D_801891B8[*(u16 *)arg0]((void *)arg0);
+        *(u8 *)(arg0 + 0x1BE) = 0xA;
+        func_80149724(arg0);
+        func_801477E8(arg0, 0xFFE80000);
+        func_80146DB8(arg0, &D_801894E4);
+        func_80146E90(arg0, 0x10);
+        return;
+    }
+
+    func_8014ED28(arg0);
+    func_8014FA04(arg0);
+    func_801725B8(arg0);
+}
diff --git a/.run/giants/wave2_func_8016CBC0.c b/.run/giants/wave2_func_8016CBC0.c
new file mode 100644
index 000000000..977a590cf
--- /dev/null
+++ b/.run/giants/wave2_func_8016CBC0.c
@@ -0,0 +1,177 @@
+#include "common.h"
+
+typedef struct
+{
+  u16 h[6];
+} Rec_8016CBC0;
+typedef struct 
+{
+  u8 f0;
+  u8 f1;
+  u8 f2;
+  u8 f3;
+  Rec_8016CBC0 ent[16];
+} Blk_8016CBC0;
+typedef struct 
+{
+  s16 x;
+  s16 y;
+  s16 z;
+  s16 pad;
+} SVEC_8016CBC0;
+typedef struct 
+{
+  u8 r;
+  u8 g;
+  u8 b;
+  u8 pad;
+} CLR_8016CBC0;
+typedef struct 
+{
+  SVEC_8016CBC0 v[4];
+  CLR_8016CBC0 col[4];
+  s32 tag;
+} Poly_8016CBC0;
+typedef struct 
+{
+  s32 w[8];
+} Mtx8_8016CBC0;
+extern s32 func_80017758(void *a0, void *a1);
+extern Mtx8_8016CBC0 D_800AE620;
+extern Blk_8016CBC0 D_801D9CA0[];
+short func_8016CBC0(void)
+{
+  Poly_8016CBC0 p0;
+  Poly_8016CBC0 p1;
+  Mtx8_8016CBC0 mtx;
+  Blk_8016CBC0 *blk;
+  Rec_8016CBC0 *sub;
+  Rec_8016CBC0 *pv;
+  unsigned int uVar9;
+  unsigned int w9;
+  unsigned int uc;
+  unsigned int a2;
+  int col;
+  int iVar3;
+  int w3;
+  unsigned int w3b;
+  short count;
+  short i;
+register unsigned int zr __asm__("$0");
+  mtx = D_800AE620;
+  count = 0;
+  p1.tag = 0x50000000;
+  p0.tag = 0x50000000;
+  p1.col[3].b = 0;
+  p1.col[3].g = 0;
+  p1.col[3].r = 0;
+  p1.col[1].b = 0;
+  p1.col[1].g = 0;
+  p1.col[1].r = 0;
+  p0.col[2].b = 0;
+  p0.col[2].g = 0;
+  p0.col[2].r = 0;
+  p0.col[0].b = 0;
+  p0.col[0].g = 0;
+  p0.col[0].r = 0;
+  for (i = 0; i < 8; i++)
+  {
+    blk = &D_801D9CA0[i];
+    if (blk->f0 != 0)
+    {
+      sub = blk->ent;
+      uVar9 = blk->f1;
+      iVar3 = blk->f2;
+      col = blk->f3;
+      count = count + 1;
+      w3 = iVar3 - 1;
+      iVar3 = w3 + zr;
+      if (w3 != (-1))
+      {
+        do
+        {
+          pv = &sub[(short) uVar9];
+          {
+            unsigned int a = pv->h[0];
+            unsigned int b;
+            p0.v[0].x = a;
+            b = pv->h[3];
+            p1.v[1].x = b;
+            p0.v[1].x = (p1.v[0].x = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+          }
+          {
+            unsigned int a = pv->h[1];
+            unsigned int b;
+            p0.v[0].y = a;
+            b = pv->h[4];
+            uc = ((unsigned) (col & 0xFF)) >> 3;
+            p1.v[1].y = b;
+            p0.v[1].y = (p1.v[0].y = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+            w9 = uVar9 - 1;
+            uVar9 = w9 + zr;
+          }
+          {
+            unsigned int a = pv->h[2];
+            unsigned int b;
+            p0.v[0].z = a;
+            b = pv->h[5];
+            p1.col[0].g = col;
+            p0.col[1].g = col;
+            p1.col[0].b = uc;
+            p0.col[1].b = uc;
+            p1.col[0].r = uc;
+            p0.col[1].r = uc;
+            p1.v[1].z = b;
+            p0.v[1].z = (p1.v[0].z = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+          }
+          if (((int) (w9 << 16)) < 0)
+          {
+            uVar9 = 0xF;
+          }
+          pv = &sub[(short) uVar9];
+          col = col - 0xF;
+          a2 = (unsigned) (col & 0xFF);
+          a2 = a2 >> 3;
+          {
+            unsigned int a = pv->h[0];
+            unsigned int b;
+            p0.v[2].x = a;
+            b = pv->h[3];
+            p1.v[3].x = b;
+            p0.v[3].x = (p1.v[2].x = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+          }
+          {
+            unsigned int a = pv->h[1];
+            unsigned int b;
+            p0.v[2].y = a;
+            b = pv->h[4];
+            p1.v[3].y = b;
+            p0.v[3].y = (p1.v[2].y = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+          }
+          {
+            unsigned int a = pv->h[2];
+            unsigned int b;
+            p0.v[2].z = a;
+            b = pv->h[5];
+            p1.col[2].g = col;
+            p0.col[3].g = col;
+            p1.col[2].b = a2;
+            p0.col[3].b = a2;
+            p1.col[2].r = a2;
+            p0.col[3].r = a2;
+            p1.v[3].z = b;
+            p0.v[3].z = (p1.v[2].z = ((unsigned) (((s16) a) + ((s16) b))) >> 1);
+          }
+          func_80017758(&p0, &mtx);
+          func_80017758(&p1, &mtx);
+          uc = iVar3 - 1;
+          w3b = uc;
+          iVar3 = w3b + zr;
+        }
+        while (((short) w3b) != (-1));
+      }
+    }
+  }
+
+  return count;
+}
diff --git a/docs/family-hseq.md b/docs/family-hseq.md
index dcb7328b9..6fb96f6db 100644
--- a/docs/family-hseq.md
+++ b/docs/family-hseq.md
@@ -2,11 +2,11 @@
 
 > Generated by `tools/family_hseq.py` from the 134 overlay sigs + per-overlay src stubs. Ranked by TEMPLATABLE byte-weight (PURE+IMM members × nins × 4). The byte-gate is the arbiter.
 
-**Fleet (overlays):** 86.9% fn / 73.4% instr / 56.9% distinct-code matched. Unmatched: 46,028 instances / 3,479,432 ins (27,022 distinct classes).
+**Fleet (overlays):** 87.0% fn / 73.7% instr / 57.5% distinct-code matched. Unmatched: 45,883 instances / 3,443,679 ins (26,884 distinct classes).
 
-**Tail cross-check (Phase-25 close):** 31,371 tail fns / 1,529,064 ins → 596 h_seq families ≥2, **178 substantial (nins≥80) / 1,042,083 ins**.
+**Tail cross-check (Phase-25 close):** 30,955 tail fns / 1,496,040 ins → 595 h_seq families ≥2, **177 substantial (nins≥80) / 1,009,152 ins**.
 
-**Full frontier (all unmatched by h_seq):** 2763 target families (≥2 members or a matched sibling) + 3787 singletons (Step-D residue). Substantial: **591 families / 2,143,449 templatable ins**, 64 with a matched sibling (zero-crack). Substantial member classes: 13,661 PURE · 40 IMM · 6 STRUCT-excluded.
+**Full frontier (all unmatched by h_seq):** 2762 target families (≥2 members or a matched sibling) + 3787 singletons (Step-D residue). Substantial: **590 families / 2,107,696 templatable ins**, 71 with a matched sibling (zero-crack). Substantial member classes: 13,516 PURE · 40 IMM · 6 STRUCT-excluded.
 
 
 ## Top substantial families (by templatable byte-weight)
@@ -18,48 +18,48 @@
 | 3 | 329 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | Y | 0x8013c414 matched-ov077 | 45,073 |
 | 4 | 304 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8014d820 draft-ov077 | 41,952 |
 | 5 | 289 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135eb0 draft-ov077 | 39,882 |
-| 6 | 279 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x801670e4 draft-ov077 | 38,502 |
+| 6 | 279 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x801670e4 matched-ov077 | 38,223 |
 | 7 | 272 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8013b83c draft-ov077 | 37,536 |
 | 8 | 271 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8015b950 draft-ov077 | 37,398 |
 | 9 | 260 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80140958 draft-ov077 | 35,880 |
-| 10 | 249 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8013cb84 matched-ov077 | 34,113 |
-| 11 | 240 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8013d53c draft-ov077 | 33,120 |
-| 12 | 231 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80175da8 draft-ov077 | 31,878 |
-| 13 | 226 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8012956c draft-ov077 | 31,188 |
-| 14 | 222 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8015c32c draft-ov077 | 30,636 |
-| 15 | 209 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016cbc0 draft-ov077 | 28,842 |
-| 16 | 204 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8015ea3c draft-ov077 | 28,152 |
-| 17 | 201 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8015d738 draft-ov077 | 27,738 |
-| 18 | 198 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8013bd74 draft-ov077 | 27,324 |
-| 19 | 198 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x801412a8 draft-ov077 | 27,324 |
-| 20 | 188 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8015f448 draft-ov077 | 25,944 |
-| 21 | 188 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80175ab8 draft-ov077 | 25,944 |
-| 22 | 93 | 276 (276/0/0) | 2/138 | cross-address | PURE | 0 | · | 0x8014ffdc draft-ov077 | 25,668 |
-| 23 | 183 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8014032c draft-ov077 | 25,254 |
-| 24 | 181 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135a4c draft-ov077 | 24,978 |
-| 25 | 174 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8017ae2c draft-ov077 | 24,012 |
-| 26 | 173 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80154c24 draft-ov077 | 23,874 |
-| 27 | 165 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80178004 draft-ov077 | 22,770 |
-| 28 | 162 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80169bbc draft-ov077 | 22,356 |
-| 29 | 161 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80160534 draft-ov077 | 22,218 |
-| 30 | 161 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8016dc20 matched-ov077 | 22,057 |
-| 31 | 158 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801299c8 draft-ov077 | 21,804 |
-| 32 | 154 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8013c0f8 draft-ov077 | 21,252 |
-| 33 | 154 | 136 (136/0/0) | 1/136 | per-location | PURE | 2 | · | 0x80144090 matched-ov077 | 20,944 |
-| 34 | 155 | 133 (133/0/0) | 1/133 | per-location | PURE | 5 | · | 0x801365b8 matched-ov077 | 20,615 |
-| 35 | 148 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016d1d8 draft-ov077 | 20,424 |
-| 36 | 147 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80177b5c draft-ov077 | 20,286 |
-| 37 | 141 | 136 (136/0/0) | 1/136 | per-location | PURE | 2 | · | 0x8013d9b0 matched-ov077 | 19,176 |
-| 38 | 137 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x80133ab0 matched-ov077 | 18,769 |
-| 39 | 136 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135260 draft-ov077 | 18,768 |
-| 40 | 131 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801555f4 draft-ov077 | 18,078 |
-| 41 | 125 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8012aaac draft-ov077 | 17,250 |
-| 42 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80140608 draft-ov077 | 16,974 |
-| 43 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016c998 draft-ov077 | 16,974 |
-| 44 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80174cb0 draft-ov077 | 16,974 |
-| 45 | 122 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801588cc draft-ov077 | 16,836 |
-| 46 | 3338 | 5 (5/0/0) | 3/5 | cross-address | PURE | 0 | · | 0x8017d960 modal | 16,690 |
-| 47 | 114 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8015d1b8 draft-ov077 | 15,732 |
-| 48 | 113 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135888 draft-ov077 | 15,594 |
-| 49 | 112 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016b234 draft-ov077 | 15,456 |
-| 50 | 111 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80179b74 draft-ov077 | 15,318 |
+| 10 | 240 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8013d53c matched-ov077 | 32,880 |
+| 11 | 231 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80175da8 draft-ov077 | 31,878 |
+| 12 | 226 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8012956c matched-ov077 | 30,962 |
+| 13 | 222 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8015c32c draft-ov077 | 30,636 |
+| 14 | 209 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8016cbc0 matched-ov077 | 28,633 |
+| 15 | 204 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8015ea3c matched-ov077 | 27,948 |
+| 16 | 201 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8015d738 matched-ov077 | 27,537 |
+| 17 | 198 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8013bd74 draft-ov077 | 27,324 |
+| 18 | 198 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x801412a8 draft-ov077 | 27,324 |
+| 19 | 188 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80175ab8 draft-ov077 | 25,944 |
+| 20 | 188 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8015f448 matched-ov077 | 25,756 |
+| 21 | 93 | 275 (275/0/0) | 2/138 | cross-address | PURE | 1 | · | 0x8014ffdc matched-ov077 | 25,575 |
+| 22 | 183 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8014032c draft-ov077 | 25,254 |
+| 23 | 181 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135a4c draft-ov077 | 24,978 |
+| 24 | 174 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8017ae2c draft-ov077 | 24,012 |
+| 25 | 173 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80154c24 draft-ov077 | 23,874 |
+| 26 | 165 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80178004 draft-ov077 | 22,770 |
+| 27 | 162 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80169bbc draft-ov077 | 22,356 |
+| 28 | 161 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80160534 draft-ov077 | 22,218 |
+| 29 | 161 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x8016dc20 matched-ov077 | 22,057 |
+| 30 | 158 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801299c8 draft-ov077 | 21,804 |
+| 31 | 154 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8013c0f8 draft-ov077 | 21,252 |
+| 32 | 154 | 136 (136/0/0) | 1/136 | per-location | PURE | 2 | · | 0x80144090 matched-ov077 | 20,944 |
+| 33 | 155 | 133 (133/0/0) | 1/133 | per-location | PURE | 5 | · | 0x801365b8 matched-ov077 | 20,615 |
+| 34 | 148 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016d1d8 draft-ov077 | 20,424 |
+| 35 | 147 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80177b5c draft-ov077 | 20,286 |
+| 36 | 141 | 136 (136/0/0) | 1/136 | per-location | PURE | 2 | · | 0x8013d9b0 matched-ov077 | 19,176 |
+| 37 | 137 | 137 (137/0/0) | 1/137 | per-location | PURE | 1 | · | 0x80133ab0 matched-ov077 | 18,769 |
+| 38 | 136 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135260 draft-ov077 | 18,768 |
+| 39 | 131 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801555f4 draft-ov077 | 18,078 |
+| 40 | 125 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x8012aaac draft-ov077 | 17,250 |
+| 41 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80140608 draft-ov077 | 16,974 |
+| 42 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016c998 draft-ov077 | 16,974 |
+| 43 | 123 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x80174cb0 draft-ov077 | 16,974 |
+| 44 | 122 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x801588cc draft-ov077 | 16,836 |
+| 45 | 3338 | 5 (5/0/0) | 3/5 | cross-address | PURE | 0 | · | 0x8017d960 modal | 16,690 |
+| 46 | 114 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8015d1b8 draft-ov077 | 15,732 |
+| 47 | 113 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80135888 draft-ov077 | 15,594 |
+| 48 | 112 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x8016b234 draft-ov077 | 15,456 |
+| 49 | 111 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | Y | 0x80179b74 draft-ov077 | 15,318 |
+| 50 | 110 | 138 (138/0/0) | 1/138 | per-location | PURE | 0 | · | 0x801330e0 draft-ov077 | 15,180 |
diff --git a/docs/progress.fleet.md b/docs/progress.fleet.md
index f3f4f2708..730fdf89c 100644
--- a/docs/progress.fleet.md
+++ b/docs/progress.fleet.md
@@ -4,156 +4,156 @@
 # cross-binary collapsible-byte leverage: docs/duplicates.cross.md.
 
 # THREE progress metrics (all matter — see the labels):
-FLEET fn-count byte-ident: 306776 / 353722 = 86.73%   (REAL+LINKED+empties; FUNCTION-count, ×134-inflated — one crack counts per overlay)
-FLEET instr-weighted     : 9634605 / 13081451 = 73.7%   (shipped .text across resident+138 overlays; the decomp.dev-DISPLAY number)
-FLEET distinct-code(uniq): 3206708 / 5574674 = 57.5%   (60553/87459 unique fns; the DISTINCT-RE number)
+FLEET fn-count byte-ident: 307463 / 353722 = 86.92%   (REAL+LINKED+empties; FUNCTION-count, ×134-inflated — one crack counts per overlay)
+FLEET instr-weighted     : 9760499 / 13081451 = 74.6%   (shipped .text across resident+138 overlays; the decomp.dev-DISPLAY number)
+FLEET distinct-code(uniq): 3313721 / 5574674 = 59.4%   (61074/87459 unique fns; the DISTINCT-RE number)
 MAIN game-code weighted  :     436 / 60201 = 0.7%   (Phase-27 T10; SEPARATE — LINKED-excluding Ghidra sig dated 2026-06-14, PROVISIONAL until a fresh/complete main sig; NOT folded into the fleet number)
 
-FLEET REAL substantive   : 304921   (of which dedup-shared 234161 via 1846 groups / 234205 instances)
+FLEET REAL substantive   : 305608   (of which dedup-shared 234161 via 1846 groups / 234205 instances)
 FLEET LINKED PsyQ objs   :    959
 FLEET NON_MATCHING       :      7   (0 in any default build — G4)
-FLEET INCLUDE_ASM stubs  :  46939
+FLEET INCLUDE_ASM stubs  :  46252
 FLEET matchable          : 353722
 
 | binary | REAL | shared | LINKED | byte-ident | matchable | byte-ident % |
 |---|---:|---:|---:|---:|---:|---:|
 | main | 54 | 2 | 959 | 1055 | 2096 | 50.3% |
 | resident | 129 | 0 | 0 | 131 | 145 | 90.3% |
-| ov_SC01_000 | 2183 | 1704 | 0 | 2183 | 2403 | 90.8% |
-| ov_SC01_001 | 2188 | 1704 | 0 | 2190 | 2466 | 88.8% |
-| ov_SC01_004 | 2181 | 1695 | 0 | 2182 | 2414 | 90.4% |
-| ov_SC01_005 | 2210 | 1717 | 0 | 2210 | 2503 | 88.3% |
-| ov_SC01_006 | 2210 | 1717 | 0 | 2210 | 2503 | 88.3% |
-| ov_SC01_008 | 2181 | 1695 | 0 | 2183 | 2426 | 90.0% |
-| ov_SC01_009 | 2206 | 1696 | 0 | 2207 | 2507 | 88.0% |
-| ov_SC01_074 | 2184 | 1696 | 0 | 2186 | 2425 | 90.1% |
-| ov_SC01_077 | 2375 | 1664 | 0 | 2377 | 2585 | 92.0% |
-| ov_SC01_080 | 2222 | 1699 | 0 | 2222 | 2512 | 88.5% |
-| ov_SC01_084 | 2230 | 1699 | 0 | 2235 | 2579 | 86.7% |
-| ov_SC02_000 | 2281 | 1734 | 0 | 2281 | 2683 | 85.0% |
-| ov_SC02_003 | 2281 | 1734 | 0 | 2281 | 2683 | 85.0% |
-| ov_SC02_004 | 2189 | 1699 | 0 | 2189 | 2401 | 91.2% |
-| ov_SC02_005 | 2296 | 1695 | 0 | 2306 | 2927 | 78.8% |
-| ov_SC02_011 | 2305 | 1702 | 0 | 2316 | 2893 | 80.1% |
-| ov_SC02_015 | 2190 | 1701 | 0 | 2190 | 2414 | 90.7% |
-| ov_SC02_016 | 2220 | 1701 | 0 | 2223 | 2545 | 87.3% |
-| ov_SC02_017 | 2266 | 1701 | 0 | 2274 | 2732 | 83.2% |
-| ov_SC02_021 | 2196 | 1701 | 0 | 2196 | 2437 | 90.1% |
-| ov_SC02_026 | 2211 | 1699 | 0 | 2217 | 2572 | 86.2% |
-| ov_SC02_027 | 2234 | 1699 | 0 | 2243 | 2692 | 83.3% |
-| ov_SC02_028 | 2235 | 1699 | 0 | 2245 | 2701 | 83.1% |
-| ov_SC02_031 | 2221 | 1700 | 0 | 2226 | 2562 | 86.9% |
-| ov_SC02_035 | 2197 | 1699 | 0 | 2200 | 2520 | 87.3% |
-| ov_SC02_039 | 2182 | 1699 | 0 | 2182 | 2416 | 90.3% |
-| ov_SC02_041 | 2217 | 1699 | 0 | 2220 | 2561 | 86.7% |
-| ov_SC03_001 | 2316 | 1700 | 0 | 2333 | 2869 | 81.3% |
-| ov_SC03_002 | 2243 | 1704 | 0 | 2258 | 2631 | 85.8% |
-| ov_SC03_003 | 2192 | 1699 | 0 | 2193 | 2423 | 90.5% |
-| ov_SC03_006 | 2255 | 1705 | 0 | 2264 | 2767 | 81.8% |
-| ov_SC03_007 | 2236 | 1699 | 0 | 2240 | 2623 | 85.4% |
-| ov_SC03_010 | 2198 | 1699 | 0 | 2198 | 2470 | 89.0% |
-| ov_SC03_011 | 2206 | 1699 | 0 | 2212 | 2527 | 87.5% |
-| ov_SC03_012 | 2184 | 1699 | 0 | 2185 | 2406 | 90.8% |
-| ov_SC03_013 | 2203 | 1699 | 0 | 2203 | 2492 | 88.4% |
-| ov_SC03_014 | 2261 | 1724 | 0 | 2261 | 2685 | 84.2% |
-| ov_SC03_015 | 2262 | 1724 | 0 | 2262 | 2685 | 84.2% |
-| ov_SC03_023 | 2190 | 1699 | 0 | 2191 | 2435 | 90.0% |
-| ov_SC03_024 | 2248 | 1704 | 0 | 2255 | 2641 | 85.4% |
-| ov_SC03_028 | 2230 | 1699 | 0 | 2234 | 2664 | 83.9% |
-| ov_SC03_029 | 2232 | 1701 | 0 | 2242 | 2644 | 84.8% |
-| ov_SC03_030 | 2204 | 1704 | 0 | 2206 | 2495 | 88.4% |
-| ov_SC03_031 | 2202 | 1699 | 0 | 2205 | 2514 | 87.7% |
-| ov_SC03_089 | 2216 | 1699 | 0 | 2223 | 2581 | 86.1% |
-| ov_SC03_090 | 2218 | 1699 | 0 | 2226 | 2625 | 84.8% |
-| ov_SC03_091 | 2221 | 1699 | 0 | 2229 | 2640 | 84.4% |
-| ov_SC03_092 | 2232 | 1699 | 0 | 2244 | 2587 | 86.7% |
-| ov_SC03_093 | 2208 | 1699 | 0 | 2212 | 2563 | 86.3% |
-| ov_SC03_094 | 2203 | 1699 | 0 | 2209 | 2577 | 85.7% |
-| ov_SC03_095 | 2193 | 1699 | 0 | 2196 | 2474 | 88.8% |
-| ov_SC03_096 | 2193 | 1699 | 0 | 2196 | 2465 | 89.1% |
-| ov_SC03_097 | 2222 | 1699 | 0 | 2229 | 2603 | 85.6% |
-| ov_SC03_098 | 2201 | 1699 | 0 | 2204 | 2541 | 86.7% |
-| ov_SC03_099 | 2194 | 1699 | 0 | 2197 | 2504 | 87.7% |
-| ov_SC03_100 | 2204 | 1699 | 0 | 2208 | 2539 | 87.0% |
-| ov_SC03_101 | 2204 | 1699 | 0 | 2208 | 2528 | 87.3% |
-| ov_SC03_102 | 2196 | 1699 | 0 | 2199 | 2492 | 88.2% |
-| ov_SC03_103 | 2199 | 1701 | 0 | 2202 | 2510 | 87.7% |
-| ov_SC03_104 | 2224 | 1699 | 0 | 2231 | 2616 | 85.3% |
-| ov_SC03_105 | 2217 | 1699 | 0 | 2224 | 2597 | 85.6% |
-| ov_SC03_108 | 2186 | 1699 | 0 | 2186 | 2443 | 89.5% |
-| ov_SC03_109 | 2187 | 1699 | 0 | 2189 | 2424 | 90.3% |
-| ov_SC03_110 | 2192 | 1699 | 0 | 2192 | 2468 | 88.8% |
-| ov_SC03_111 | 2204 | 1699 | 0 | 2207 | 2510 | 87.9% |
-| ov_SC03_112 | 2197 | 1701 | 0 | 2199 | 2526 | 87.1% |
-| ov_SC03_113 | 2190 | 1701 | 0 | 2193 | 2468 | 88.9% |
-| ov_SC03_114 | 2180 | 1699 | 0 | 2182 | 2415 | 90.4% |
-| ov_SC03_115 | 2197 | 1699 | 0 | 2199 | 2472 | 89.0% |
-| ov_SC03_116 | 2187 | 1699 | 0 | 2190 | 2438 | 89.8% |
-| ov_SC03_117 | 2215 | 1699 | 0 | 2221 | 2557 | 86.9% |
-| ov_SC03_118 | 2262 | 1723 | 0 | 2263 | 2685 | 84.3% |
-| ov_SC03_119 | 2260 | 1723 | 0 | 2261 | 2685 | 84.2% |
-| ov_SC03_121 | 2194 | 1699 | 0 | 2197 | 2459 | 89.3% |
-| ov_SC03_124 | 2273 | 1695 | 0 | 2293 | 2741 | 83.7% |
-| ov_SC03_125 | 2230 | 1699 | 0 | 2242 | 2588 | 86.6% |
-| ov_SC03_126 | 2193 | 1701 | 0 | 2193 | 2423 | 90.5% |
-| ov_SC04_000 | 2209 | 1703 | 0 | 2218 | 2546 | 87.1% |
-| ov_SC04_002 | 2225 | 1699 | 0 | 2229 | 2636 | 84.6% |
-| ov_SC04_003 | 2203 | 1699 | 0 | 2207 | 2502 | 88.2% |
-| ov_SC04_004 | 2212 | 1699 | 0 | 2214 | 2558 | 86.6% |
-| ov_SC04_005 | 2220 | 1699 | 0 | 2226 | 2612 | 85.2% |
-| ov_SC04_006 | 2193 | 1699 | 0 | 2195 | 2454 | 89.4% |
-| ov_SC04_007 | 2213 | 1699 | 0 | 2217 | 2569 | 86.3% |
-| ov_SC04_008 | 2183 | 1699 | 0 | 2183 | 2415 | 90.4% |
-| ov_SC04_009 | 2199 | 1699 | 0 | 2202 | 2441 | 90.2% |
-| ov_SC04_010 | 2190 | 1699 | 0 | 2191 | 2419 | 90.6% |
-| ov_SC04_011 | 2246 | 1699 | 0 | 2252 | 2803 | 80.3% |
-| ov_SC04_012 | 2186 | 1699 | 0 | 2187 | 2420 | 90.4% |
-| ov_SC04_015 | 2249 | 1700 | 0 | 2260 | 2611 | 86.6% |
-| ov_SC04_016 | 2189 | 1699 | 0 | 2191 | 2440 | 89.8% |
-| ov_SC04_018 | 2300 | 1734 | 0 | 2300 | 2857 | 80.5% |
-| ov_SC04_019 | 2305 | 1734 | 0 | 2305 | 2857 | 80.7% |
-| ov_SC04_020 | 2217 | 1699 | 0 | 2229 | 2567 | 86.8% |
-| ov_SC04_021 | 2194 | 1701 | 0 | 2194 | 2423 | 90.5% |
-| ov_SC05_000 | 2190 | 1703 | 0 | 2193 | 2422 | 90.5% |
-| ov_SC05_001 | 2213 | 1699 | 0 | 2218 | 2574 | 86.2% |
-| ov_SC05_002 | 2195 | 1699 | 0 | 2198 | 2442 | 90.0% |
-| ov_SC05_003 | 2192 | 1699 | 0 | 2193 | 2481 | 88.4% |
-| ov_SC05_004 | 2187 | 1699 | 0 | 2189 | 2464 | 88.8% |
-| ov_SC05_005 | 2194 | 1699 | 0 | 2195 | 2491 | 88.1% |
-| ov_SC05_006 | 2186 | 1699 | 0 | 2186 | 2430 | 90.0% |
-| ov_SC05_007 | 2196 | 1699 | 0 | 2201 | 2482 | 88.7% |
-| ov_SC05_008 | 2213 | 1699 | 0 | 2215 | 2543 | 87.1% |
-| ov_SC05_009 | 2191 | 1699 | 0 | 2195 | 2438 | 90.0% |
-| ov_SC05_010 | 2217 | 1699 | 0 | 2221 | 2588 | 85.8% |
-| ov_SC05_011 | 2189 | 1699 | 0 | 2190 | 2409 | 90.9% |
-| ov_SC05_017 | 2296 | 1696 | 0 | 2307 | 2842 | 81.2% |
-| ov_SC05_018 | 2243 | 1699 | 0 | 2256 | 2673 | 84.4% |
-| ov_SC05_019 | 2194 | 1701 | 0 | 2194 | 2423 | 90.5% |
-| ov_SC06_000 | 2254 | 1708 | 0 | 2257 | 2691 | 83.9% |
-| ov_SC06_006 | 2209 | 1699 | 0 | 2210 | 2511 | 88.0% |
-| ov_SC06_008 | 2219 | 1701 | 0 | 2225 | 2542 | 87.5% |
-| ov_SC06_010 | 2203 | 1699 | 0 | 2208 | 2517 | 87.7% |
-| ov_SC06_011 | 2197 | 1699 | 0 | 2201 | 2468 | 89.2% |
-| ov_SC06_013 | 2191 | 1699 | 0 | 2192 | 2425 | 90.4% |
-| ov_SC06_014 | 2197 | 1699 | 0 | 2199 | 2453 | 89.6% |
-| ov_SC06_015 | 2194 | 1699 | 0 | 2194 | 2421 | 90.6% |
-| ov_SC06_016 | 2211 | 1699 | 0 | 2213 | 2549 | 86.8% |
-| ov_SC06_018 | 2208 | 1702 | 0 | 2215 | 2665 | 83.1% |
-| ov_SC06_020 | 2201 | 1701 | 0 | 2202 | 2518 | 87.5% |
-| ov_SC06_022 | 2215 | 1699 | 0 | 2223 | 2642 | 84.1% |
-| ov_SC06_024 | 2220 | 1699 | 0 | 2226 | 2667 | 83.5% |
-| ov_SC06_025 | 2212 | 1699 | 0 | 2217 | 2572 | 86.2% |
-| ov_SC06_027 | 2180 | 1699 | 0 | 2181 | 2408 | 90.6% |
-| ov_SC06_029 | 2238 | 1699 | 0 | 2250 | 2662 | 84.5% |
-| ov_SC06_030 | 2193 | 1699 | 0 | 2193 | 2456 | 89.3% |
-| ov_SC06_032 | 2205 | 1700 | 0 | 2212 | 2658 | 83.2% |
-| ov_SC06_033 | 2208 | 1700 | 0 | 2215 | 2631 | 84.2% |
-| ov_SC07_000 | 2207 | 1703 | 0 | 2209 | 2521 | 87.6% |
-| ov_SC07_001 | 2193 | 1699 | 0 | 2195 | 2454 | 89.4% |
-| ov_SC07_002 | 2220 | 1699 | 0 | 2224 | 2579 | 86.2% |
-| ov_SC07_006 | 1966 | 1547 | 0 | 2046 | 2456 | 83.3% |
-| ov_SC07_007 | 1982 | 1548 | 0 | 2066 | 2614 | 79.0% |
-| ov_SC07_008 | 2177 | 1699 | 0 | 2177 | 2386 | 91.2% |
-| ov_SC07_009 | 2187 | 1699 | 0 | 2189 | 2430 | 90.1% |
-| ov_SC07_010 | 1995 | 1548 | 0 | 2078 | 2526 | 82.3% |
-| ov_SC07_011 | 1982 | 1547 | 0 | 2062 | 2450 | 84.2% |
+| ov_SC01_000 | 2188 | 1704 | 0 | 2188 | 2403 | 91.1% |
+| ov_SC01_001 | 2193 | 1704 | 0 | 2195 | 2466 | 89.0% |
+| ov_SC01_004 | 2186 | 1695 | 0 | 2187 | 2414 | 90.6% |
+| ov_SC01_005 | 2215 | 1717 | 0 | 2215 | 2503 | 88.5% |
+| ov_SC01_006 | 2215 | 1717 | 0 | 2215 | 2503 | 88.5% |
+| ov_SC01_008 | 2186 | 1695 | 0 | 2188 | 2426 | 90.2% |
+| ov_SC01_009 | 2211 | 1696 | 0 | 2212 | 2507 | 88.2% |
+| ov_SC01_074 | 2189 | 1696 | 0 | 2191 | 2425 | 90.4% |
+| ov_SC01_077 | 2384 | 1664 | 0 | 2386 | 2585 | 92.3% |
+| ov_SC01_080 | 2227 | 1699 | 0 | 2227 | 2512 | 88.7% |
+| ov_SC01_084 | 2235 | 1699 | 0 | 2240 | 2579 | 86.9% |
+| ov_SC02_000 | 2286 | 1734 | 0 | 2286 | 2683 | 85.2% |
+| ov_SC02_003 | 2286 | 1734 | 0 | 2286 | 2683 | 85.2% |
+| ov_SC02_004 | 2194 | 1699 | 0 | 2194 | 2401 | 91.4% |
+| ov_SC02_005 | 2301 | 1695 | 0 | 2311 | 2927 | 79.0% |
+| ov_SC02_011 | 2310 | 1702 | 0 | 2321 | 2893 | 80.2% |
+| ov_SC02_015 | 2195 | 1701 | 0 | 2195 | 2414 | 90.9% |
+| ov_SC02_016 | 2225 | 1701 | 0 | 2228 | 2545 | 87.5% |
+| ov_SC02_017 | 2271 | 1701 | 0 | 2279 | 2732 | 83.4% |
+| ov_SC02_021 | 2201 | 1701 | 0 | 2201 | 2437 | 90.3% |
+| ov_SC02_026 | 2216 | 1699 | 0 | 2222 | 2572 | 86.4% |
+| ov_SC02_027 | 2239 | 1699 | 0 | 2248 | 2692 | 83.5% |
+| ov_SC02_028 | 2240 | 1699 | 0 | 2250 | 2701 | 83.3% |
+| ov_SC02_031 | 2226 | 1700 | 0 | 2231 | 2562 | 87.1% |
+| ov_SC02_035 | 2202 | 1699 | 0 | 2205 | 2520 | 87.5% |
+| ov_SC02_039 | 2187 | 1699 | 0 | 2187 | 2416 | 90.5% |
+| ov_SC02_041 | 2222 | 1699 | 0 | 2225 | 2561 | 86.9% |
+| ov_SC03_001 | 2321 | 1700 | 0 | 2338 | 2869 | 81.5% |
+| ov_SC03_002 | 2248 | 1704 | 0 | 2263 | 2631 | 86.0% |
+| ov_SC03_003 | 2197 | 1699 | 0 | 2198 | 2423 | 90.7% |
+| ov_SC03_006 | 2260 | 1705 | 0 | 2269 | 2767 | 82.0% |
+| ov_SC03_007 | 2241 | 1699 | 0 | 2245 | 2623 | 85.6% |
+| ov_SC03_010 | 2203 | 1699 | 0 | 2203 | 2470 | 89.2% |
+| ov_SC03_011 | 2211 | 1699 | 0 | 2217 | 2527 | 87.7% |
+| ov_SC03_012 | 2189 | 1699 | 0 | 2190 | 2406 | 91.0% |
+| ov_SC03_013 | 2208 | 1699 | 0 | 2208 | 2492 | 88.6% |
+| ov_SC03_014 | 2266 | 1724 | 0 | 2266 | 2685 | 84.4% |
+| ov_SC03_015 | 2267 | 1724 | 0 | 2267 | 2685 | 84.4% |
+| ov_SC03_023 | 2195 | 1699 | 0 | 2196 | 2435 | 90.2% |
+| ov_SC03_024 | 2253 | 1704 | 0 | 2260 | 2641 | 85.6% |
+| ov_SC03_028 | 2235 | 1699 | 0 | 2239 | 2664 | 84.0% |
+| ov_SC03_029 | 2237 | 1701 | 0 | 2247 | 2644 | 85.0% |
+| ov_SC03_030 | 2209 | 1704 | 0 | 2211 | 2495 | 88.6% |
+| ov_SC03_031 | 2207 | 1699 | 0 | 2210 | 2514 | 87.9% |
+| ov_SC03_089 | 2221 | 1699 | 0 | 2228 | 2581 | 86.3% |
+| ov_SC03_090 | 2223 | 1699 | 0 | 2231 | 2625 | 85.0% |
+| ov_SC03_091 | 2226 | 1699 | 0 | 2234 | 2640 | 84.6% |
+| ov_SC03_092 | 2237 | 1699 | 0 | 2249 | 2587 | 86.9% |
+| ov_SC03_093 | 2213 | 1699 | 0 | 2217 | 2563 | 86.5% |
+| ov_SC03_094 | 2208 | 1699 | 0 | 2214 | 2577 | 85.9% |
+| ov_SC03_095 | 2198 | 1699 | 0 | 2201 | 2474 | 89.0% |
+| ov_SC03_096 | 2198 | 1699 | 0 | 2201 | 2465 | 89.3% |
+| ov_SC03_097 | 2227 | 1699 | 0 | 2234 | 2603 | 85.8% |
+| ov_SC03_098 | 2206 | 1699 | 0 | 2209 | 2541 | 86.9% |
+| ov_SC03_099 | 2199 | 1699 | 0 | 2202 | 2504 | 87.9% |
+| ov_SC03_100 | 2209 | 1699 | 0 | 2213 | 2539 | 87.2% |
+| ov_SC03_101 | 2209 | 1699 | 0 | 2213 | 2528 | 87.5% |
+| ov_SC03_102 | 2201 | 1699 | 0 | 2204 | 2492 | 88.4% |
+| ov_SC03_103 | 2204 | 1701 | 0 | 2207 | 2510 | 87.9% |
+| ov_SC03_104 | 2229 | 1699 | 0 | 2236 | 2616 | 85.5% |
+| ov_SC03_105 | 2222 | 1699 | 0 | 2229 | 2597 | 85.8% |
+| ov_SC03_108 | 2191 | 1699 | 0 | 2191 | 2443 | 89.7% |
+| ov_SC03_109 | 2192 | 1699 | 0 | 2194 | 2424 | 90.5% |
+| ov_SC03_110 | 2197 | 1699 | 0 | 2197 | 2468 | 89.0% |
+| ov_SC03_111 | 2209 | 1699 | 0 | 2212 | 2510 | 88.1% |
+| ov_SC03_112 | 2202 | 1701 | 0 | 2204 | 2526 | 87.3% |
+| ov_SC03_113 | 2195 | 1701 | 0 | 2198 | 2468 | 89.1% |
+| ov_SC03_114 | 2185 | 1699 | 0 | 2187 | 2415 | 90.6% |
+| ov_SC03_115 | 2202 | 1699 | 0 | 2204 | 2472 | 89.2% |
+| ov_SC03_116 | 2192 | 1699 | 0 | 2195 | 2438 | 90.0% |
+| ov_SC03_117 | 2220 | 1699 | 0 | 2226 | 2557 | 87.1% |
+| ov_SC03_118 | 2267 | 1723 | 0 | 2268 | 2685 | 84.5% |
+| ov_SC03_119 | 2265 | 1723 | 0 | 2266 | 2685 | 84.4% |
+| ov_SC03_121 | 2199 | 1699 | 0 | 2202 | 2459 | 89.5% |
+| ov_SC03_124 | 2278 | 1695 | 0 | 2298 | 2741 | 83.8% |
+| ov_SC03_125 | 2235 | 1699 | 0 | 2247 | 2588 | 86.8% |
+| ov_SC03_126 | 2198 | 1701 | 0 | 2198 | 2423 | 90.7% |
+| ov_SC04_000 | 2214 | 1703 | 0 | 2223 | 2546 | 87.3% |
+| ov_SC04_002 | 2230 | 1699 | 0 | 2234 | 2636 | 84.7% |
+| ov_SC04_003 | 2208 | 1699 | 0 | 2212 | 2502 | 88.4% |
+| ov_SC04_004 | 2217 | 1699 | 0 | 2219 | 2558 | 86.7% |
+| ov_SC04_005 | 2225 | 1699 | 0 | 2231 | 2612 | 85.4% |
+| ov_SC04_006 | 2198 | 1699 | 0 | 2200 | 2454 | 89.6% |
+| ov_SC04_007 | 2218 | 1699 | 0 | 2222 | 2569 | 86.5% |
+| ov_SC04_008 | 2188 | 1699 | 0 | 2188 | 2415 | 90.6% |
+| ov_SC04_009 | 2204 | 1699 | 0 | 2207 | 2441 | 90.4% |
+| ov_SC04_010 | 2195 | 1699 | 0 | 2196 | 2419 | 90.8% |
+| ov_SC04_011 | 2251 | 1699 | 0 | 2257 | 2803 | 80.5% |
+| ov_SC04_012 | 2191 | 1699 | 0 | 2192 | 2420 | 90.6% |
+| ov_SC04_015 | 2254 | 1700 | 0 | 2265 | 2611 | 86.7% |
+| ov_SC04_016 | 2194 | 1699 | 0 | 2196 | 2440 | 90.0% |
+| ov_SC04_018 | 2305 | 1734 | 0 | 2305 | 2857 | 80.7% |
+| ov_SC04_019 | 2310 | 1734 | 0 | 2310 | 2857 | 80.9% |
+| ov_SC04_020 | 2222 | 1699 | 0 | 2234 | 2567 | 87.0% |
+| ov_SC04_021 | 2199 | 1701 | 0 | 2199 | 2423 | 90.8% |
+| ov_SC05_000 | 2195 | 1703 | 0 | 2198 | 2422 | 90.8% |
+| ov_SC05_001 | 2218 | 1699 | 0 | 2223 | 2574 | 86.4% |
+| ov_SC05_002 | 2200 | 1699 | 0 | 2203 | 2442 | 90.2% |
+| ov_SC05_003 | 2197 | 1699 | 0 | 2198 | 2481 | 88.6% |
+| ov_SC05_004 | 2192 | 1699 | 0 | 2194 | 2464 | 89.0% |
+| ov_SC05_005 | 2199 | 1699 | 0 | 2200 | 2491 | 88.3% |
+| ov_SC05_006 | 2191 | 1699 | 0 | 2191 | 2430 | 90.2% |
+| ov_SC05_007 | 2201 | 1699 | 0 | 2206 | 2482 | 88.9% |
+| ov_SC05_008 | 2218 | 1699 | 0 | 2220 | 2543 | 87.3% |
+| ov_SC05_009 | 2196 | 1699 | 0 | 2200 | 2438 | 90.2% |
+| ov_SC05_010 | 2222 | 1699 | 0 | 2226 | 2588 | 86.0% |
+| ov_SC05_011 | 2194 | 1699 | 0 | 2195 | 2409 | 91.1% |
+| ov_SC05_017 | 2301 | 1696 | 0 | 2312 | 2842 | 81.4% |
+| ov_SC05_018 | 2248 | 1699 | 0 | 2261 | 2673 | 84.6% |
+| ov_SC05_019 | 2199 | 1701 | 0 | 2199 | 2423 | 90.8% |
+| ov_SC06_000 | 2259 | 1708 | 0 | 2262 | 2691 | 84.1% |
+| ov_SC06_006 | 2214 | 1699 | 0 | 2215 | 2511 | 88.2% |
+| ov_SC06_008 | 2224 | 1701 | 0 | 2230 | 2542 | 87.7% |
+| ov_SC06_010 | 2208 | 1699 | 0 | 2213 | 2517 | 87.9% |
+| ov_SC06_011 | 2202 | 1699 | 0 | 2206 | 2468 | 89.4% |
+| ov_SC06_013 | 2196 | 1699 | 0 | 2197 | 2425 | 90.6% |
+| ov_SC06_014 | 2202 | 1699 | 0 | 2204 | 2453 | 89.8% |
+| ov_SC06_015 | 2199 | 1699 | 0 | 2199 | 2421 | 90.8% |
+| ov_SC06_016 | 2216 | 1699 | 0 | 2218 | 2549 | 87.0% |
+| ov_SC06_018 | 2213 | 1702 | 0 | 2220 | 2665 | 83.3% |
+| ov_SC06_020 | 2206 | 1701 | 0 | 2207 | 2518 | 87.6% |
+| ov_SC06_022 | 2220 | 1699 | 0 | 2228 | 2642 | 84.3% |
+| ov_SC06_024 | 2225 | 1699 | 0 | 2231 | 2667 | 83.7% |
+| ov_SC06_025 | 2217 | 1699 | 0 | 2222 | 2572 | 86.4% |
+| ov_SC06_027 | 2185 | 1699 | 0 | 2186 | 2408 | 90.8% |
+| ov_SC06_029 | 2243 | 1699 | 0 | 2255 | 2662 | 84.7% |
+| ov_SC06_030 | 2198 | 1699 | 0 | 2198 | 2456 | 89.5% |
+| ov_SC06_032 | 2210 | 1700 | 0 | 2217 | 2658 | 83.4% |
+| ov_SC06_033 | 2213 | 1700 | 0 | 2220 | 2631 | 84.4% |
+| ov_SC07_000 | 2212 | 1703 | 0 | 2214 | 2521 | 87.8% |
+| ov_SC07_001 | 2198 | 1699 | 0 | 2200 | 2454 | 89.6% |
+| ov_SC07_002 | 2225 | 1699 | 0 | 2229 | 2579 | 86.4% |
+| ov_SC07_006 | 1969 | 1547 | 0 | 2049 | 2456 | 83.4% |
+| ov_SC07_007 | 1985 | 1548 | 0 | 2069 | 2614 | 79.2% |
+| ov_SC07_008 | 2182 | 1699 | 0 | 2182 | 2386 | 91.5% |
+| ov_SC07_009 | 2192 | 1699 | 0 | 2194 | 2430 | 90.3% |
+| ov_SC07_010 | 1999 | 1548 | 0 | 2082 | 2526 | 82.4% |
+| ov_SC07_011 | 1985 | 1547 | 0 | 2065 | 2450 | 84.3% |
diff --git a/phase-ends/CURRENT_PHASE.md b/phase-ends/CURRENT_PHASE.md
index 45c215668..3d6b83109 100644
--- a/phase-ends/CURRENT_PHASE.md
+++ b/phase-ends/CURRENT_PHASE.md
@@ -374,3 +374,30 @@ conditional) · main-EXE/B9 + GLM/B6 + resident's 14 walls (P30) · behemoths B7
   `make sig-overlays` + `family_hseq.py` regen (→matched-ov077) → standard `family_sweep --hseq --only` (137/137).
   **BATCH R22: check-all 140/140 byte-identical; tools-health green; dedup 1846/0.** Fleet **73.4→73.7% instr ·
   56.9→57.5% distinct · 86.73% fn-count**. Commit `commit:0699`.
+
+- **✅ 2026-07-18 — CRACK-WAVE 2 + FABLE AGENTS + TYPE-LIFT RECOVERY (Ultracode→xHigh). Fleet 73.4→74.6% instr.**
+  **Two Opus crack-waves (15 fresh-core agents) + 3 Fable5 agents (gcc-2.7.2 source-readers) + a permuter track.**
+  Wave-1: `func_8013CB84` (249) MATCH → **banked ×138**. Wave-2 (8 non-jr cores 93-209 ins): **6 MATCH**
+  (8016cbc0/8015ea3c/8015d738/8015f448/8014ffdc[×276]/801412a8) + 2 near (80175ab8=58, 80178004=39).
+  **Fable5 (each read the compiler source): 3 MATCH** — `func_8013D53C` (240, the cse.c cross-statement
+  address-CSE wall: `*(S9*)(&D_801DA998+0x20)` never unifies with SYMBOL_REF while gas folds %hi/%lo(sym+k)
+  byte-identical — NEW family-portable idiom), `func_801670E4` (279, post-reload scheduler boost-kill re-ties),
+  `func_8012956C` (226, 4 stacked mechanisms incl. the reorg j-slot-steal barrier) — plus 2 near driven far
+  closer (8014D820 33→**11**, 80175DA8 30→**11**, permuter/Fable seeds preserved).
+  **BANKED: 8 exemplars ×1** (all but 801412a8) **+ ~815 members swept**: first sweep 538 (4 clean families:
+  8015ea3c 134 / 8015d738 134 / 8015f448 138 / 8014ffdc 135) + type-lift recovery (8012956c **137/137**,
+  801670e4 partial 4). **R22 clean-fleet 140/140 byte-identical; tools-health green; dedup 1846/0; 0 NON_MATCHING.**
+  Fleet **74.6% instr · 59.4% distinct-code · 86.92% fn-count** (crack-wave arc start 73.4/56.9/86.61;
+  **session-total 72.1→74.6 = +2.5pp instr**). Commits `commit:0699`..`commit:0708`.
+  **NEW LESSONS (R30):** (a) crack-wave sweep needs a **map-regen** step (freshly-cracked exemplar is draft-ov077
+  → family_sweep finds 0; bank ×1 → sig-overlays + family_hseq.py → matched-ov077 → standard sweep). (b) The
+  reconcile ladder (cast_call_sites→reconcile_tu→scope_data_externs) handles most, but recurring manual fixups:
+  **func_80161208/func_801670E4 all-decls-normalized-to-no-proto** (a reconcile re-adds a file-scope prototyped
+  decl that poisons every no-proto call), scalar-typedef strip, §17a-1 fn-ptr casts, local-typedef uniquify vs
+  same-file siblings. (c) **Type-lift recovers clean-TYPE families 137/137** (Blk16_956C/Ent_956C, SVec/Fr →
+  engine_types.h, byte-neutral) but NOT def-sig/per-sibling-decl-conflict families.
+  **CARRIED FOLLOW-UPS (all preserved, R20):** (1) 801670e4/8016cbc0 — type-lifted but the sweep hits a
+  per-sibling func_801670E4 decl-conflict (needs the func_80161208-style all-decls-normalize applied per sibling,
+  or a sweep enhancement). (2) 8013d53c family — void* def-sig caller-decl thread per sibling. (3) 801412a8 —
+  §29 narrow-u16-param def-side wall (caller decl int; matching adds masking). (4) permuter/Fable fuel: 8014d820
+  (11), 80175da8 (11), 80175ab8 (58), 80178004 (39). Drafts in .run/giants/{wave2_,fable_,*.close11}*.