=== lever-free bodies in ov_SC06_018 sharing a callee or global with func_8017F0F4 (23 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_8017FF34 (src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c:4803) shares 3: func_8012B1B4 func_8012CBCC func_8017EA54 ---
void func_8017FF34(s32 a0)
{

    extern s32 D_80126B60;
    s32 sp10[3];

    if (*(s32 *)(a0 + 8) >= D_80126B60 - 0x200000) {
        if (*(s32 *)(a0 + 0x48) >= 0) {
            *(s32 *)(a0 + 0x48) = -0x8000;
            *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1;
        }
    } else {
        if (D_80126B60 - 0x180000 >= *(s32 *)(a0 + 8)) {
            if (*(s32 *)(a0 + 0x48) <= 0) {
                *(s32 *)(a0 + 0x48) = 0x8000;
                *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1;
            }
        }
    }

    *(s32 *)(a0 + 0xDC) = *(s32 *)(a0 + 0xDC) >> 1;

    sp10[0] = 0;
    sp10[1] = 0;
    sp10[2] = *(s32 *)(a0 + 0xDC);
    ((void (*)(s32, s32))func_8012B1B4)(a0, (s32)sp10);
    func_8012CBCC(a0);
    func_8017EA54(a0, 0x51);

    *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 0x10);
    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) &= 0xFFF;

    *(u16 *)(a0 + 0x100) -= 1;
    if (*(s16 *)(a0 + 0x100) == 0) {
        *(s16 *)(a0 + 2) = 3;
        *(u16 *)(a0 + 0x100) = 5;
        *(s32 *)(a0 + 0x1C) = 0;
    }
}

--- func_8017AE2C (src/ov_SC06_018/ov_SC06_018_jr_8017AE2C.c:2630) shares 3: func_8012B608 func_8012B744 func_8012BE98 ---
void func_8017AE2C(s32 param_1) {
    s32 pv = param_1;
    s16 *g = &D_801D5AF8;

    switch (g[0]) {
    case 0:
    default:
        return;
    case 1:
        g[1] = (u16)g[1] - 1;
        if (g[1] <= 0) {
            *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) = (u16)g[2];
            goto reset_both;
        }
        {
            s32 r = func_8012B608(*(s16 *)(*(s32 *)(pv + 0x20) + 0x12), g[2], 6);
            *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) =
                *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) + r;
        }
        return;
    case 2:
        func_8012B178(pv, (s32)g[4] << 8);
        func_8012AD80(pv);
        *(u16 *)(pv + 0xA) -= 8;
        func_8012B030((u8 *)pv);
        break;
    case 3:
        if (g[1] != 0) {
            if (g[5] != 0) {
                void *p = (void *)(pv + 4);
                if ((s16)func_80012A60(*(s16 *)(*(s32 *)(pv + 0x20) + 0x12),
                                       (s16)func_8012B744(p, &g[6])) < 0x100) {
                    g[1] = 0;
                }
                *(s16 *)(*(s32 *)(pv + 0x20) + 0x12) =
                    func_8012B744(p, &D_801D5B04);
                func_8012B178(pv, 0xFFFA0000);
                func_8012AD80(pv);
                *(u16 *)(pv + 0xA) -= 8;
                func_8012B030((u8 *)pv);
                /* &D_801D5AF8+0xC == &D_801D5B04; distinct rtx defeats gcc's address-CSE
                   so BE98's arg rematerializes instead of sharing the store's reg (byte-gate). */
                if (func_8012BE98(pv, (u16 *)((s32)&D_801D5AF8 + 0xC)) < 0x101) {
                    D_801D5AF8 = 0;
                    D_801D5AFA = 0;
                }
            }
            {
                s32 t = func_8012B744((void *)(pv + 4), &g[6]);
                s32 r = func_8012B608(*(s16 *)(*(s32 *)(pv + 0x20) + 0x12), t, g[3]);
                *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) =
                    *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) + r;
            }
            g[1] = (u16)g[1] - 1;
            if (g[1] > 0) {
                return;
            }
            g[1] = 0;
            return;
        }
        *(s16 *)(*(s32 *)(pv + 0x20) + 0x12) =
            func_8012B744((void *)(pv + 4), &D_801D5B04);
        func_8012B178(pv, 0xFFFA0000);
        func_8012AD80(pv);
        *(u16 *)(pv + 0xA) -= 8;
        func_8012B030((u8 *)pv);
        /* see note above: distinct rtx for the same address defeats address-CSE. */
        if (func_8012BE98(pv, (u16 *)((s32)&D_801D5AF8 + 0xC)) < 0x101) {
            D_801D5AF8 = 0;
            D_801D5AFA = 0;
        }
        return;
    case 4:
        func_8012AD80(pv);
    }
    g[1] = (u16)g[1] - 1;
    if (g[1] > 0) {
        return;
    }
reset_both:
    g[0] = 0;
    g[1] = 0;
    return;
}

--- func_8018314C (src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c:6726) shares 2: func_8012B1B4 func_8012CBCC ---
void func_8018314C(s32 a0) {
    extern u8 D_801AD4D0[];
    extern u8 D_801B4C8C[];
    extern u8 D_801B4D7C[];
    extern u8 D_801B4E6C[];
    s32 pad[4];

    ((void (*)(s32, s32))func_8012B1B4)(a0, (s32)D_801AD4D0);
    func_8012CBCC(a0);
    func_801808A4(a0, 0x48);
    *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 0x10);
    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) &= 0xFFF;

    *(u16 *)(a0 + 0x100) -= 1;
    if (*(s16 *)(a0 + 0x100) == 0) {
        *(s16 *)(a0 + 2) = 6;
        *(u16 *)(a0 + 0x100) = 0x2D;
        *(s32 *)(a0 + 0x1C) = 0;
        *(s16 *)(a0 + 0x104) = 0;
        func_8012A828(a0, D_801B4C8C);

        if (*(s32 *)(a0 + 0xCC) != 0) {
            func_8012A828(*(s32 *)(a0 + 0xCC), D_801B4D7C);
        }
        if (*(s32 *)(a0 + 0xD0) != 0) {
            func_8012A828(*(s32 *)(a0 + 0xD0), D_801B4E6C);
        }
    }
}

--- func_80185DD8 (src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c:8665) shares 2: func_8012B608 func_8012BE54 ---
void func_80185DD8(s32 a0) {
    s32 r;
    s16 vecA[4];
    s16 vecB[4];
    s32 x;

    if ((*(u32 *)(a0 + 0xE0) & 0x40) == 0) {
        s32 ret = ((s32 (*)(s32))func_8012BE54)(a0);
        if (ret <= 0x63FFF) {
            if (func_8012BEE8(a0) != 0) {
                s32 t;
                s32 rr;

                t = func_8012B8A4((s16 *)a0);
                *(u32 *)(a0 + 0xE8) = (t + 0x800) & 0xFFF;
                rr = rand();
                *(s32 *)(a0 + 0x1C) = rr % 0x40 + 0x40;
            }
        }
    }

    r = func_8012B608((s32) * (s16 *)(*(s32 *)(a0 + 0x20) + 0x12), *(s32 *)(a0 + 0xE8), 8);
    *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + r;

    *(u32 *)(a0 + 0xE0) &= 0xFFFFFFBF;
    func_8012B178(a0, 0xFFF8D000);

    if (func_8018765C(a0) == 0) {
        func_801877E4(a0);
    }

    vecA[0] = *(s16 *)(a0 + 0x6);
    vecA[1] = *(s16 *)(a0 + 0xA);
    vecA[2] = *(s16 *)(a0 + 0xE);
    ((s32 (*)(void *, void *))func_8012EFB8)(vecA, vecB);

    x = vecB[0];
    if (x < 0) {
        x = -x;
    }
    /* |z| tested per sign inside the jump context: each arm of the ?: is its own compare-and-branch,
     * so the two `slti 201` tails are not one value-converged abs (the x test above is). */
    if (x >= 0x105 || (vecB[1] >= 0 ? vecB[1] >= 0xC9 : -vecB[1] >= 0xC9)) {
        func_8012C098((void *)a0);
    }
}

--- func_8018598C (src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c:8462) shares 2: func_8012B608 func_8012B744 ---
void func_8018598C(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 s32 *D_80126B78;
    u8  auStack_38[8];
    s16 sp20[3];
    u8  auStack_28[8];
    StructB58 *b58 = &(*(StructB58 *)&D_80126B58);   /* $s4 */
    short *psVar7 = (short *)(param_1 + 0xec);
    s32 sVar1;
    s32 r_b608;

    if (func_8012BEE8(param_1) != 0) {
        unsigned int *p28 = (unsigned int *)auStack_28; /* $s5 */
        s32 r0 = rand();
        s32 coord;
        s32 s2v;
        s32 r3;
        s32 tmp;

        coord = r0 % 0x400;
        sVar1 = *(s16 *)((*(s32 *)&(*(s32 *)&D_80126B78)) + 0x12);
        s2v   = sVar1 + 0x800;
        if ((rand() & 1) == 0) {
            coord = s2v - coord;
        } else {
            s32 c = coord;   /* fresh pseudo so gcc keeps s2v first in the addu (§10 A1) */
            coord = s2v + c;
        }

        func_8012B0B4(p28, coord, rand() % 0x200 + 0x200);

        tmp = *(s32 *)auStack_28;
        psVar7[0] = b58->f6 + tmp;
        psVar7[1] = b58->fa;
        psVar7[2] = b58->fe + (tmp >> 16);

        r3 = rand();
        *(s32 *)(param_1 + 0x1c) = 0x80;
        *(s16 *)(param_1 + 0x100) = r3 % 9 + 8;
    }

    if ((*(u32 *)(param_1 + 0xe0) & 0x40) == 0) {
        *(u32 *)(param_1 + 0xe8) = func_8012B744((void *)(param_1 + 4), psVar7);
    }

    r_b608 = func_8012B608((s32)*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12),
                           *(s32 *)(param_1 + 0xe8),
                           (s32)*(s16 *)(param_1 + 0x100));
    *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) =
        *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + r_b608;
    func_8012B178(param_1, 0xfffa0000);

    *(u32 *)(param_1 + 0xe0) &= 0xffffffbf;
    if (func_8018765C(param_1) == 0) {
        func_801877E4(param_1);
        sp20[1] = 0;
        sp20[0] = 0;
        sp20[2] = -0x100;
        ((void (*)(s32, s32, s32))func_8012F14C)(*(s32 *)(param_1 + 0x20) + 0x34,
                                                 (s32)sp20, (s32)psVar7);
    }

    if (((u32)D_800B99DA % 0x28 == 0) && ((*(u32 *)(param_1 + 0xe0) & 0x80) == 0)) {
        ((void (*)(s32, s32, s32, s32))func_80189380)(param_1, (s32)&D_801B5184, (s32)auStack_38, 0xb);
        ((void (*)(s32, s32, s32, s32, s32, s32))func_8018931C)(param_1, (s32)auStack_38, 0x282, 1, 0, 0);
        *(u32 *)(param_1 + 0xe0) |= 0x80;
    }

    if (func_80013478(param_1 + 4, (s32)psVar7) < 0x400) {
        *(s32 *)(param_1 + 0x1c) = 0;
    }
}

--- func_8012BE54 (src/shared/ov/func_8012BE54.h:7) shares 1: func_8012BE98 ---
void func_8012BE54(s32 a0) {
    u16 sp[3];
    sp[0] = D_80126B5E;
    sp[1] = D_80126B62;
    sp[2] = D_80126B66;
    func_8012BE98(a0, sp);
}

