=== lever-free bodies in ov_SC04_011 sharing a callee or global with func_80176734 (90 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_80175DA8 (src/ov_SC04_011/ov_SC04_011_jr_801734BC.c:2867) shares 8: D_800B9A13 D_800D43D4 D_800D4414 D_800D45D4 D_80193B48 D_80193BDC D_80193BF4 func_800183E0 ---
void func_80175DA8(param_1)
    u16 param_1;
{

    extern u8  D_8011F7F0;
    extern u8  D_800B9A13;
    extern S_AF634 D_800AF634[];
    extern S_AF634 D_800AF638[];
    extern u16 D_80193AEC[];
    extern u16 D_80193B3C[];
    extern u16 D_80193B48;
    extern u8  D_80193BC8[];
    extern u8  D_80193BDC[];
    extern s32 D_80193BF4[];
    extern u8  D_800D43D4;
    extern u8  D_800D4414;
    extern u8  D_800D45D4;

    u8 *base = &D_8011F7F0;
    u8 *s = base - 0x48;
    u16 *src = D_80193AEC;
    Sp_80175DA8 *p;
    s16 i;
    s32 arg;
    s32 t;
    s32 fl;
    u16 v;

    p = (Sp_80175DA8 *)(D_800AF638[(s16)param_1].g0 + D_800AF634[(s16)param_1].g0 * 4);
    *(Sp_80175DA8 **)(s + (s16)param_1 * 4 + 0x28) = p;
    i = 0;
    do {
        p->tag = ((u32)(p - 1) & 0xFFFFFF) | 0x4000000;
        p->code = *(u32 *)src;
        src += 2;
        if (i < 2) {
            p->x = *src++ + *(u16 *)(s + 0xC);
            p->y = *src++ + *(u16 *)(s + 0xE);
        } else if (i == 2) {
            p->x = *src++ + *(u16 *)(s + 0x10);
            p->y = *src++ + *(u16 *)(s + 0x12);
        } else {
            p->x = *src++ + *(u16 *)(s + 0x14);
            p->y = *src++ + *(u16 *)(s + 0x16);
        }
        p->uv = *(u32 *)src;
        src += 2;
        p->wh = *(u32 *)src;
        src += 2;
        p++;
        i++;
    } while (i < 5);

    *(u8 *)(s + 7) = D_800B9A13;
    p = (Sp_80175DA8 *)func_8017742C((u32 *)p,
                                     (s16)(*(u16 *)(s + 0x10) - 0x98),
                                     (s16)(*(u16 *)(s + 0x12) + 9));
    func_8005A600((s32)p, 0, 0, 0x16, 0);
    p->tag = ((u32)(p - 1) & 0xFFFFFF) | 0x2000000;
    *(Sp_80175DA8 **)(s + (s16)param_1 * 4 + 0x30) = p;
    p++;
    {
        s32 acc = D_800AF634[(s16)param_1].g0;
        D_800AF634[(s16)param_1].g0 =
            acc + (((s32)p - *(s32 *)(s + (s16)param_1 * 4 + 0x28)) >> 2);
    }

    p = *(Sp_80175DA8 **)(s + (s16)param_1 * 4 + 0x28);
    if (base[0x48] != 0) {
        *((u8 *)p + 0xD) = 0;
    } else {
        *((u8 *)p + 0xD) = 0xA0;
    }

    {
        u8 *q1 = *(u8 **)(s + (s16)param_1 * 4 + 0x28);
        *(u16 *)(q1 + 0x22) = 0x6CD6;
        if (base[0x48] & 0x80) {
            *(u16 *)(q1 + 0x20) = D_80193B48;
            arg = (s32)&D_800D45D4;
        } else {
            u16 *tt = D_80193B3C;
            s32 k = base[0x48];
            if (k != 0) {
                k--;
                tt += k;
            }
            *(u16 *)(q1 + 0x20) = *tt;
            arg = D_80193BF4[base[0x48]];
        }
    }
    func_800183E0(arg);

    {
        u8 *q2 = *(u8 **)(s + (s16)param_1 * 4 + 0x28);
        t = (s32)(*(u16 *)(base + 0x2E) << 16);
        if (t != 0) {
            q2[0x49] = D_80193BDC[t >> 20];
        } else {
            q2[0x49] = 0xA0;
        }
    }

    {
        u8 *q3 = *(u8 **)(s + (s16)param_1 * 4 + 0x28);
        v = *(u16 *)(base + 0x40);
        if (v < 100) {
            q3[0x5D] = D_80193BC8[v / 5];
        } else {
            q3[0x5D] = 0;
        }
    }

    do { fl = *(s16 *)(base + 0x1E) & 0x8000; } while (0);
    /* §5a zero-byte sched fence: without it sched1 hoists the `la D_800D43D4`
       into the lh's load-delay slot, dropping the target's nop (-1 ins). */
    arg = (s32)&D_800D43D4;
    if (fl != 0) {
        arg = (s32)&D_800D4414;
    }
    func_800183E0(arg);
}

--- func_801754A8 (src/ov_SC04_011/ov_SC04_011_jr_801734BC.c:2695) shares 2: D_800B9A13 D_8011F7A8 ---
void func_801754A8(void) {

    extern u8 D_8011F7A8;
    extern unsigned char D_800B9A13;
    extern s32 D_80126B9C;
    extern DispatchFn D_80193C18[];
    u8 *p = &D_8011F7A8;
    s32 r = func_80029504();
    s32 flag = 0;

    if (((D_800B9A13 == 0) && ((D_80126B9C & 0x80) == 0)) ||
        (0x4AF < (u32)(r - 10))) {
        flag = 1;
    }
    p[9] = flag;
    D_80193C18[p[0]]((void *)p);
}

--- func_80175308 (src/shared/ov/func_80175308.h:17) shares 2: D_80078E78 D_8011F7A8 ---
void func_80175308(void) {
    u8 *p = (u8 *)&D_8011F7A8;
    p[0] = 1;
    D_8011F7A9 = 2;
    D_8011F7AE = 0x37;
    D_8011F7B8 = -0x37;
    (*(s16 *)&D_8011F7B4) = -0x37;
    D_8011F7BE = 0x37;
    D_8011F7BA = 0x37;
    (*(s16 *)&D_8011F7B6) = 0x37;
    D_8011F7BC = 0x37;
    *(Blk152 *)(p + 0x48) = (*(Blk152 *)D_80078E78);
    func_80016714(p + 0xE0, 0x98);
    {
        s16 *q = &D_800B9A02;
        func_801757A0(*q);
        func_800596F4(0);
        func_801757A0((s16)(*(u16 *)q ^ 1));
    }
}

--- func_8016EE94 (src/shared/ov/func_8016EE94.h:27) shares 2: D_80126B58 D_80126D20 ---
void func_8016EE94(s32 a0, s32 a1)
{
    a0 = a0 | 0x4000000;
    D_80126D50 = a0 | a1;
    D_80126D54 = 0;
    D_80126D6C = 0;
    D_80126D6D = 0;
    D_80126D6E = 0;
    D_80126D5C = 0;
    D_80126D60 = 0;
    D_80126D64 = 0;
    D_80126D66 = 0;
    D_80126D68 = 0;
    D_80126D6A = 0;
    D_80126D1A = 0;
    D_80127058 = 0;
    D_8012705C = 0;
    D_80127060 = 0;
    D_80127064 = 0;
    D_80127068 = 0;
    D_8012706C = 0;
    D_80127070 = 0;
    D_80127074 = 0;
    func_801726D0(&D_80126B58);
    D_800B9A17 = 0;
    D_80126D20 = 0;
}

--- func_80144B9C (src/shared/ov/func_80144B9C.h:159) shares 2: D_80078E78 D_80126B58 ---
void func_80144B9C(void) {
    P10 *p10 = (P10 *)D_80126B58;
    P14 *p14 = (P14 *)D_80078E78;
    register u8 *p = D_800AF630;
    P18 *p18 = (P18 *)D_800AE6A8;
    P1C *p1C = (P1C *)D_80126948;
    HDR *hdr;
    ENT *ent;
    s32 tbl;
    s16 i;
    void (*calltmp)(void);
    s32 flag;

    func_80019018();
    func_80018E78();
    if (p18->f8 == 0) {
        hdr = (HDR *)func_801457A4(*(s16 *)(p + 0xA3D8));
        p18->f16 = 0;
        flag = 1;
        D_8011DB14 = p14->f3A;
        D_8011DB1C = p14->f3E;
        D_80128150 = 100;
        func_8002AB64();
    } else {
        hdr = (HDR *)func_801457A4(*(s16 *)(p + 0xA3D8));
        flag = 0;
    }
    p18->f1C = hdr->fC8;
    tbl = hdr->fC8;
    if (p18->f16 == 0xFF) {
        ent = &D_80078E50;
    } else {
        ent = (ENT *)*(s32 *)(p18->f16 * 4 + tbl);
    }
    p18->fC = ent->f8;
    p18->f14 = 0;
    p10->f4D = 0;
    if (ent->fC != (s32)D_8010F5C8) {
        p10->f198 = ent->fC;
    }
    if (*(s16 *)(p + 0xA3DA) == 0x1000 && *(s16 *)(p + 0xA3DC) == 0x1000) {
        p10->f6 = p10->f88 = p10->f90 = p18->f20;
        p10->fA = p10->f8A = p10->f92 = p18->f22;
        p10->fE = p10->f8C = p10->f94 = p18->f24;
        p10->f20->f12 = p18->f26;
        p18->f18 = 0;
    } else {
        p10->f6 = p10->f88 = p10->f90 = ent->f10;
        p10->fA = p10->f8A = p10->f92 = ent->f12;
        p10->fE = p10->f8C = p10->f94 = ent->f14;
        p10->f20->f12 = ent->f16;
    }
    p10->f154 = p10->f15C = p10->f6;
    p10->f156 = p10->f15E = p10->fA;
    p10->f158 = p10->f160 = p10->fE;
    func_80015978((void *)((s32)p10 + 4), D_80126DB0);
    D_80126DB6 = p10->f20->f12;
    if (*(s16 *)(p + 0xA3DA) == 0x1000 &&
        (*(s16 *)(p + 0xA3DC) == 0x1000 || *(s16 *)(p + 0xA3DC) == 0x2000) && flag == 0) {
        ent->f18();
        func_8012A1BC();
    } else {
        if (*(s16 *)(p + 0xA3DA) == 0x1000 && *(s16 *)(p + 0xA3DC) == 0x3000) {
            p1C->fA0 = ent->f3;
        } else {
            p1C->fA0 = 0;
        }
        ent->f18();
    }
    if (*(s16 *)(p + 0xA3D8) == 0x3069) {
        p1C->fA0 = ent->f3;
    }
    D_801151D4 = (s32)p1C;
    func_8002850C(hdr->f0, hdr->f2, hdr->f4);
    D_800A5E88 = hdr->f6;
    D_800A5E8C = hdr->f8;
    D_800A5E90 = hdr->fA;
    D_800A5E94 = hdr->fC;
    D_800A5E95 = hdr->fD;
    D_800A5E96 = hdr->fE;
    func_80028620(0, &D_800A5E88);
    D_800A5E98 = hdr->f10;
    D_800A5E9C = hdr->f12;
    D_800A5EA0 = hdr->f14;
    D_800A5EA4 = hdr->f16;
    D_800A5EA5 = hdr->f17;
    D_800A5EA6 = hdr->f18;
    func_80028620(1, &D_800A5E98);
    D_800A5EA8 = hdr->f1A;
    D_800A5EAC = hdr->f1C;
    D_800A5EB0 = hdr->f1E;
    D_800A5EB4 = hdr->f20;
    D_800A5EB5 = hdr->f21;
    D_800A5EB6 = hdr->f22;
    func_80028620(2, &D_800A5EA8);
    func_80129398();
    D_800B9AAC = hdr->f24;
    D_800B9B00 = hdr->f26;
    D_800B9AC4 = hdr->f28;
    D_800B9B18 = hdr->f2C;
    D_800B9AC8 = hdr->f30;
    D_800B9B1C = hdr->f34;
    D_800B9AB2 = hdr->f38;
    D_800B9B06 = hdr->f3A;
    D_800B9AB6 = hdr->f3C;
    D_800B9B0A = hdr->f3E;
    D_800B9ABC = hdr->f40[0];
    D_800B9ABD = hdr->f40[1];
    D_800B9ABE = hdr->f40[2];
    D_800B9B10 = hdr->f40[3];
    D_800B9B11 = hdr->f40[4];
    D_800B9B12 = hdr->f40[5];
    D_800B9ABF = hdr->f40[6];
    D_800B9AC0 = hdr->f40[7];
    D_800B9AC1 = hdr->f40[8];
    D_800B9B13 = hdr->f40[9];
    D_800B9B14 = hdr->f40[10];
    D_800B9B15 = hdr->f40[11];
    func_8012944C();
    p10->fB0 = hdr->f4C;
    p10->fCC = hdr->f50;
    p10->f1E8 = hdr->f54;
    p10->f1F0 = hdr->f58;
    D_80126728 = hdr->f5C;
    D_8011DB08 = hdr->f60;
    D_80126AEC = hdr->f64;
    p10->f19C = (s32)hdr + 0x68;
    func_801336E8(hdr->f88, hdr->f8C, hdr->f90);
    func_8013B83C(hdr->f94, hdr->f98, hdr->f9C);
    func_8013B568(hdr->fA8);
    func_800D02C0(hdr->fD4);
    func_80011E84(hdr->fD8);
    for (i = 0; i < 8; i++) {
        D_801151F0[i] = *(u8 *)((s32)hdr + i + 0xAC);
    }
    D_801274C8 = hdr->fB4;
    D_801274CC = hdr->fB8;
    D_801274D0 = hdr->fBC;
    D_801274D4 = hdr->fC0;
    D_801270B8 = hdr->fC4;
    D_80127520 = hdr->fC4;
    D_801151D8 = 0;
    D_8011DB28 = 0;
    calltmp = ent->f20;
    calltmp();
    func_8013D3D4(hdr->fA0, hdr->fA4);
    func_8002D4C8(0x1E, 0);
    if (p18->f8 == 0) {
        D_80078E50 = *ent;
    }
    p18->f4 = (s32)&D_80078E50;
    p18->f8 = p18->f8 & 0x7F000000;
    if (func_800CF854() != 0) {
        func_8001C14C();
        func_8012A110();
    }
}

--- func_80176218 (src/ov_SC04_011/ov_SC04_011_jr_801734BC.c:3085) shares 2: D_80078E78 D_8011F7A8 ---
void func_80176218(s32 param_1)
{
    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every
       LATER function in this TU, which blocks a byte-true decl of a different type.
       Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */
    extern u8 D_80078E78[];

    extern u16 D_8011F82A;
    extern u16 D_8011F82C;
    extern u16 D_8011F8C4;
    extern u8  D_8011F7A8;   /* st base  ($s3) */
    extern u8  D_80193BC8[];
    extern u8 *D_80193B4C[];
    s32 st   = (s32)&D_8011F7A8;   /* $s3 */
    s32 cach = st + 0x48;          /* $s1 */
    s32 flag = st + 0xE0;          /* $s2 */
    s32 cur  = (s32)&(*(u8 *)D_80078E78);   /* $s5 */
    u8 buf[24];
    s32 ne;
    s32 t;
    u16 sA;

    /* ---- block 1: raw-global pair 0x3A/0x3C ---- */
    sA = D_80078EB2;
    t = (sA != D_8011F82A);
    if (D_8011F82C == (*(u16 *)&D_80078EB4)) {
        ne = t;
        if (ne == 0 && D_8011F8C4 == 0) goto L340;
    } else {
        s32 d = (s16)(D_8011F82C - (*(u16 *)&D_80078EB4));
        u16 nv;
        if (d < 0) {
            if (d < -10) nv = D_8011F82C + 2;
            else         nv = D_8011F82C + 1;
        } else {
            if (d > 10)  nv = D_8011F82C - 2;
            else         nv = D_8011F82C - 1;
        }
        D_8011F82C = nv;
        *(u16 *)(flag + 0x3C) = 1;
        *(u16 *)(cach + 0x3A) = *(u16 *)(cur + 0x3A);
        goto L328;
    }
    if (ne) {
        *(u16 *)(st + 0x82)  = sA;
        *(u16 *)(st + 0x11C) = 1;
    } else {
        *(u16 *)(st + 0x11C) = 0;
    }
L328:
    func_80176FF4(*(s32 *)(((param_1 << 16) >> 14) + st + 0x18));
L340:

    /* ---- block 2: pair 0x3E/0x40 ---- */
    sA = *(u16 *)(cur + 0x3E);
    t = (sA != *(u16 *)(cach + 0x3E));
    if (*(u16 *)(cach + 0x40) == *(u16 *)(cur + 0x40)) {
        ne = t;
        if (ne == 0 && *(u16 *)(flag + 0x40) == 0) goto L444;
    } else {
        s32 d = (s16)(*(u16 *)(cach + 0x40) - *(u16 *)(cur + 0x40));
        u16 nc;
        if (d < 0) {
            if (d < -10) nc = *(u16 *)(cach + 0x40) + 2;
            else         nc = *(u16 *)(cach + 0x40) + 1;
        } else {
            if (d > 10)  nc = *(u16 *)(cach + 0x40) - 2;
            else         nc = *(u16 *)(cach + 0x40) - 1;
        }
        *(u16 *)(cach + 0x40) = nc;
        *(u16 *)(flag + 0x40) = 1;
        *(u16 *)(cach + 0x3E) = *(u16 *)(cur + 0x3E);
        goto L3E8;
    }
    if (ne) {
        *(u16 *)(cach + 0x3E) = sA;
        *(u16 *)(flag + 0x40) = 1;
    } else {
        *(u16 *)(flag + 0x40) = 0;
    }
L3E8:
    {
        s32 s0b = ((param_1 << 16) >> 14) + st;
        u16 cc;
        s32 pp;
        func_80177340(*(s32 *)(s0b + 0x18) + 0x104);
        cc = *(u16 *)(cach + 0x40);
        pp = *(s32 *)(s0b + 0x28);
        if (cc < 100)
            *(u8 *)(pp + 0x5D) = D_80193BC8[cc / 5];
        else
            *(u8 *)(pp + 0x5D) = 0;
    }
L444:

    /* ---- block 3: field 0x14 (s32) ---- */
    if (*(s32 *)(cach + 0x14) == *(s32 *)(cur + 0x14)) {
        if (*(s32 *)(flag + 0x14) == 0) goto L4D0;
        *(s32 *)(flag + 0x14) = 0;
        goto L4A8;
    } else {
        s32 d = *(s32 *)(cur + 0x14) - *(s32 *)(cach + 0x14);
        s32 nd;
        if (d > 0) {
            if (d < 10) nd = *(s32 *)(cach + 0x14) + 1;
            else        nd = *(s32 *)(cach + 0x14) + 10;
        } else {
            if (d < -9) nd = *(s32 *)(cach + 0x14) - 10;
            else        nd = *(s32 *)(cach + 0x14) - 1;
        }
        *(s32 *)(cach + 0x14) = nd;
        *(s32 *)(flag + 0x14) = 1;
    }
L4A8:
    {
        u32 r = func_801783D0(*(s32 *)(cach + 0x14), 0);
        func_80177F84(*(s32 *)(((param_1 << 16) >> 14) + st + 0x18) + 0x208, r);
    }
L4D0:

    /* ---- block 4: field 0x34 (u16) + 0x42 (u8) ---- */
    if (*(u16 *)(cur + 0x34) != *(u16 *)(cach + 0x34)) {
        *(u16 *)(cach + 0x34) = *(u16 *)(cur + 0x34);
        *(u16 *)(flag + 0x34) = 1;
        *(u8 *)(cach + 0x42) = *(u8 *)(cur + 0x42);
    } else {
        if (*(u16 *)(flag + 0x34) == 0) goto L558;
        *(u16 *)(flag + 0x34) = 0;
    }
    {
        u16 e = 999;
        s16 r;
        if (*(u16 *)(cach + 0x34) < 1000) e = *(u16 *)(cach + 0x34);
        r = (s16)func_801783D0((s16)e, 4);
        func_80177DA8(*(s32 *)(((param_1 << 16) >> 14) + st + 0x18) + 0x294,
                      (s32)r, *(u8 *)(cach + 0x42));
    }
L558:

    /* ---- block 5: field 0x1A (s16) ---- */
    if (*(s16 *)(cach + 0x1A) != *(s16 *)(cur + 0x1A)) {
        *(s16 *)(cach + 0x1A) = *(s16 *)(cur + 0x1A);
        *(s16 *)(flag + 0x1A) = 1;
    } else {
        if (*(s16 *)(flag + 0x1A) == 0) goto L63C;
        *(s16 *)(flag + 0x1A) = 0;
    }
    {
        u16 f = *(u16 *)(cach + 0x1A);
        s32 e = *(s32 *)(((param_1 << 16) >> 14) + st + 0x18);
        s32 i6, i4, sum;
        /* L1: the store is written into BOTH arms so cross_jump merges the tail (see header). */
        if (f & 1) *(s16 *)(e + 0x32A) = 0x200;
        else       *(s16 *)(e + 0x32A) = *(u16 *)(st + 0x16) + 0x65;
        {
            s32 t = (((s16)f / 15) & 3) * 15;
            i6 = func_801783D0(((s16)f / 15) * 0x10000 >> 0x12, 8);
            i4 = func_801783D0((t * 0x10000) >> 16, 0);
        }
        /* L2: copy temp defeats expand_binop's commutative swap; cse folds it back (see header). */
        sum = i4;
        i4 = i6 + sum;
        ((void (*)(s32, s32))func_80177AD4)(*(s32 *)(((param_1 << 16) >> 14) + st + 0x18) + 800,
                      i4 * 0x10000 >> 0x10);
    }
L63C:

    /* ---- block 6: field 0x4A (u8) ---- */
    if (*(u8 *)(cur + 0x4A) != *(u8 *)(cach + 0x4A)) {
        *(u8 *)(cach + 0x4A) = *(u8 *)(cur + 0x4A) & 0x7F;
        *(u8 *)(flag + 0x4A) = 1;
    } else {
        if (*(u8 *)(flag + 0x4A) == 0) return;
        *(u8 *)(flag + 0x4A) = 0;
    }
    {
        s32 s0b = ((param_1 << 16) >> 14) + st;
        u8 *arg = D_80193B4C[*(u8 *)(cach + 0x4A)];
        u32 *p = (u32 *)(*(s32 *)(s0b + 0x18) + 900);
        func_80024054(arg, buf);
        p = ((u32 * (*)(u32 *, u8 *, s32, s32))func_80178298)(p, buf,
                          (s16)(*(u16 *)(st + 0x14) + 0x39),
                          (s16)(*(u16 *)(st + 0x16) + 0x5B));
        func_8005A600((s32)p, 0, 0, 0x15, 0);
        *p = ((u32)((u8 *)p - 0x14) & 0xffffff) | 0x2000000;
        *(u32 **)(s0b + 0x20) = p;
    }
}

