=== lever-free bodies in ov_SC04_011 sharing a callee or global with func_80133CD4 (36 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_80136334 (src/ov_SC04_011/ov_SC04_011_jr_80135D20.c:921) shares 7: D_801152A8 D_801152AA D_801152AC D_801909BC D_801909C0 D_801909C4 D_801909C8 ---
s32 func_80136334(void *arg0, s32 arg1, s32 arg2) {
    extern u8 D_801152A8[];
    extern s16 D_801152AA;
    extern s16 D_801152AC[];
    extern s16 D_80126722;
    extern s16 D_80126724;
    u16 a1v;
    s16 a2v;
    s32 n;
    s16 *b4;
    s32 d;
    s32 dx;
    s32 denom;
    s32 result;
    s32 frame_pad[2];
    (void)&frame_pad;
    a1v = arg1;
    a2v = arg2;

    if (!(a1v & 1)) {
        dx = a2v - (*(s16 **)&D_801909BC)[2];
        d = dx;
        denom = -(*(s16 **)&D_801909C8)[2];
    } else {
        denom = (*(s16 **)&D_801909C8)[2];
        d = (*(s16 **)&D_801909BC)[2] - a2v;
        dx = -d;
    }
    n = -d;
    {
        s16 *b8 = *(s16 **)&D_801909C8;
        u16 *ac = *(u16 **)&D_801909BC;
        b4 = D_801909C4;
        b4[0] = ac[0] + n * b8[0] / denom;
        b4[1] = ac[1] + n * b8[1] / denom;
        b4[2] = ac[2] + dx;
    }

    if (b4[0] < M2C_FIELD(arg0, s16 *, 4)) return 0;
    if (M2C_FIELD(arg0, s16 *, 6) < b4[0]) return 0;
    if (b4[1] < M2C_FIELD(arg0, s16 *, 8)) return 0;
    if (M2C_FIELD(arg0, s16 *, 0xA) < b4[1]) return 0;
    if (a1v & 0x8000) {
        u16 *b0 = *(u16 **)&D_801909C0;
        b4[0] = b0[0];
        b4[1] = b0[1];
    }
    D_801152AA = 0;
    (*(s16 *)D_801152A8) = 0;
    if (a1v & 1) {
        D_801909C4[2] = a2v + 2;
        D_801152AC[0] = 0xFFF;
    } else {
        D_801152AC[0] = -0xFFF;
        D_801909C4[2] = a2v - 2;
    }
    (*(s16 *)D_80126720) = (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1;
    D_80126722 = (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1;
    result = 1;
    D_80126724 = (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1;
    return result;
}

--- func_801365B8 (src/ov_SC04_011/ov_SC04_011_jr_80135D20.c:1000) shares 7: D_801152A8 D_801152AA D_801152AC D_801909BC D_801909C0 D_801909C4 D_801909C8 ---
s32 func_801365B8(void *arg0, s32 arg1, s32 arg2) {
    extern u8 D_801152A8[];
    extern s16 D_801152AA;
    extern s16 D_801152AC;
    extern s16 D_80126722;
    extern s16 D_80126724;
    u16 *ac;
    s16 *b8;
    s16 *b4;
    s16 temp_v0;
    s16 temp_v1;
    s32 var_a3;
    s32 temp_a1;
    s32 var_a1;
    s32 var_v0;
    s32 var_v1;
    u16 a1c;
    u16 a2c;

    a1c = arg1;
    a2c = arg2 + 0;
    if (!(arg1 & 1)) {
        var_v1 = (s16) arg2 - (*(s16 **)&D_801909BC)[0];
        var_a1 = var_v1;
        var_a3 = -(*(s16 **)&D_801909C8)[0];
    } else {
        var_a3 = (*(s16 **)&D_801909C8)[0];
        var_v1 = (*(s16 **)&D_801909BC)[0] - (s16) arg2;
        var_a1 = -var_v1;
    }
    ac = *(u16 **)&D_801909BC;
    b4 = D_801909C4;
    b8 = *(s16 **)&D_801909C8;
    b4[0] = ac[0] + var_a1;
    temp_a1 = -var_v1;
    b4[1] = ac[1] + (temp_a1 * b8[1]) / var_a3;
    temp_v0 = ac[2] + (temp_a1 * b8[2]) / var_a3;
    b4[2] = temp_v0;
    var_v0 = 0;
    if (temp_v0 < M2C_FIELD(arg0, s16 *, 0xC)) {
        return var_v0;
    }
    if (M2C_FIELD(arg0, s16 *, 0xE) < temp_v0) {
        return var_v0;
    }
    temp_v1 = b4[1];
    if (temp_v1 < M2C_FIELD(arg0, s16 *, 8)) {
        return var_v0;
    }
    if (M2C_FIELD(arg0, s16 *, 0xA) < temp_v1) {
        return var_v0;
    }
    if (a1c & 0x8000) {
        b4[1] = (s16) (*(u16 **)&D_801909C0)[1];
        b4[2] = (s16) (*(u16 **)&D_801909C0)[2];
    }
    D_801152AC = 0;
    D_801152AA = 0;
    if ((a1c & 1) != 0) {
        *(s16 *)D_801152A8 = 0xFFF;
        M2C_FIELD(D_801909C4, s16 *, 0) = a2c + 2;
    } else {
        *(s16 *)D_801152A8 = -0xFFF;
        M2C_FIELD(D_801909C4, s16 *, 0) = a2c - 2;
    }
    *(s16 *)D_80126720 = (s16) ((s32) (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1);
    D_80126722 = (s16) ((s32) (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1);
    D_80126724 = (s16) ((s32) (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1);
    return (1);
}

--- func_80135EB0 (src/ov_SC04_011/ov_SC04_011_jr_80135D20.c:767) shares 7: D_801152A8 D_801152AA D_801152AC D_801909BC D_801909C0 D_801909C4 D_801909C8 ---
s32 func_80135EB0(void *arg0, s32 arg1) {
    extern u8 D_801152A8[];
    extern s16 D_801152AA[];
    extern s16 D_801152AC[];
    extern s16 D_80126722[];
    extern s16 D_80126724[];
    s32 t1;
    s32 t2;
    s32 t3;
    s32 m1;
    s32 m2;
    s32 t4;
    s32 t5;
    s32 t6;
    s32 n1;
    s32 n2;
    s32 r;

    t1 = (*(s16 **)&D_801909BC)[0];
    if (t1 < M2C_FIELD(arg0, s16 *, 4)) {
        m1 = 1;
    } else {
        m1 = (M2C_FIELD(arg0, s16 *, 6) < t1) << 1;
    }
    t2 = (*(s16 **)&D_801909BC)[2];
    if (t2 < M2C_FIELD(arg0, s16 *, 0xC)) {
        m1 |= 4;
    } else if (M2C_FIELD(arg0, s16 *, 0xE) < t2) {
        m1 |= 8;
    }
    t3 = (*(s16 **)&D_801909BC)[1];
    /* The do-while(0) is NOT inert: flow.c counts every ref inside it at loop depth 2 (flow.c:2067), which
     * lifts m2 to 11 refs and ranks it above arg1 in global.c allocno_compare -> m2 $s2, arg1 $s3. */
    do {
        if (t3 < M2C_FIELD(arg0, s16 *, 8)) {
            m2 = 0x10;
        } else {
            m2 = -(M2C_FIELD(arg0, s16 *, 0xA) < t3);
            m2 &= 0x20;
        }
    } while (0);
    if ((m1 | m2) == 0) {
        u16 *ac;
        s16 *b4;
        s32 c0;
        s32 c1;
        s32 h0;
        s32 h1;

        ac = *(u16 **)&D_801909BC;
        b4 = D_801909C4;
        c0 = ac[0];
        b4[0] = c0;
        h0 = (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1;
        D_801152AA[0] = 0;
        ((SVECTOR *)D_80126720)->vx = h0;
        (*(s16 *)D_801152A8) = c0 - h0;
        c1 = ac[2];
        b4[2] = c1;
        h1 = (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1;
        D_80126724[0] = h1;
        D_801152AC[0] = c1 - h1;
        b4[1] = ac[1];
        D_80126722[0] = (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1;
        VectorNormalSS(D_801152A8, D_801152A8);
        D_801150D8 |= 1;
        return 1;
    }

    t4 = (*(s16 **)&D_801909C0)[0];
    if (t4 < M2C_FIELD(arg0, s16 *, 4)) {
        n1 = 1;
    } else {
        n1 = (M2C_FIELD(arg0, s16 *, 6) < t4) << 1;
    }
    t5 = (*(s16 **)&D_801909C0)[2];
    if (t5 < M2C_FIELD(arg0, s16 *, 0xC)) {
        n1 |= 4;
    } else if (M2C_FIELD(arg0, s16 *, 0xE) < t5) {
        n1 |= 8;
    }
    t6 = (*(s16 **)&D_801909C0)[1];
    if (t6 < M2C_FIELD(arg0, s16 *, 8)) {
        n2 = 0x10;
    } else {
        n2 = (M2C_FIELD(arg0, s16 *, 0xA) < t6) << 5;
    }
    if (((m1 | m2) & (n1 | n2)) != 0) {
        goto ret0;
    }
    {
        u16 *b0 = *(u16 **)&D_801909C0;
        u16 *ac = *(u16 **)&D_801909BC;
        s16 *b8 = *(s16 **)&D_801909C8;

        b8[0] = b0[0] - ac[0];
        b8[1] = b0[1] - ac[1];
        b8[2] = b0[2] - ac[2];
    }

    switch (m1) {
    case 4:
        r = func_80136334(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 0xC));
        goto test;
    case 1:
        if (func_801365B8(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 4)) != 0) goto ret1;
        break;
    case 2:
        if (func_801365B8(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 6)) != 0) goto ret1;
        break;
    case 5:
        if (func_80136334(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 0xC)) != 0) goto ret1;
        if (func_801365B8(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 4)) != 0) goto ret1;
        break;
    case 6:
        if (func_80136334(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 0xC)) != 0) goto ret1;
        if (func_801365B8(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 6)) != 0) goto ret1;
        break;
    case 9:
        if (func_801365B8(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 4)) != 0) goto ret1;
        /* fallthrough */
    case 8:
        r = func_80136334(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 0xE));
    test:
        if (r != 0) goto ret1;
        break;
    ret0:
        return 0;
    case 10:
        if (func_801365B8(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 6)) != 0) goto ret1;
        if (func_80136334(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 0xE)) != 0) goto ret1;
        break;
    case 0:
        break;
    default:
        goto ret1;
    }
    if (m2 == 0) {
        goto ret0;
    }
    if (m2 == 0x10) {
        if (((s32 (*)(void *, s32, s32))func_80136824)(arg0, (s16) arg1, M2C_FIELD(arg0, s16 *, 8)) == 0) {
            goto ret0;
        }
    } else {
        if (((s32 (*)(void *, s32, s32))func_80136824)(arg0, (s16) (arg1 | 1), M2C_FIELD(arg0, s16 *, 0xA)) == 0) {
            goto ret0;
        }
    }
ret1:
    return 1;
}

--- func_80134C20 (src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:2817) shares 6: D_801152A8 D_801909BC D_801909C0 D_801909C4 D_801909C8 D_801EDA40 ---
s32 func_80134C20(s32 arg0, s32 arg1, s32 arg2, s32 arg3) {
    extern s32 func_80134FB8(s32 a0, s32 a1, s32 a2);
    extern void * D_801909BC;
    extern void * D_801909C0;
    extern void * D_801909C4;
    extern void * D_801909C8;
    extern u16 D_801EDA40;

    s32 temp_a3;
    s32 temp_s1;
    s32 temp_v0;
    s32 temp_v0_2;
    s32 var_v0;
    u16 temp_a1;
    s32 temp_s4;
    u16 c = arg0;

    temp_s4 = arg2 + (M2C_FIELD(((void *)arg1), s16 *, 2) * 8);
    temp_s1 = *(s32 *)(arg3 + (M2C_FIELD(((void *)arg1), s16 *, 4) * 4));
    var_v0 = 0;
    if (func_80134FB8(temp_s4, (s32) D_801909C0, temp_s1) >= 0) {
        return var_v0;
    }
    temp_v0 = func_80134FB8(temp_s4, (s32) D_801909BC, temp_s1);
    if (temp_v0 < 0) {
        goto block_13;
    }
    temp_v0_2 = func_80134FB8(temp_s4, (s32) D_801909C8, 0);
    temp_a3 = -temp_v0;
    {
        u16 *pB4 = (u16 *)D_801909C4;
        u16 *pAC = (u16 *)D_801909BC;
        s16 *pB8 = (s16 *)D_801909C8;
        pB4[0] = pAC[0] + (temp_a3 * pB8[0]) / temp_v0_2;
        pB4[1] = pAC[1] + (temp_a3 * pB8[1]) / temp_v0_2;
        pB4[2] = pAC[2] + (temp_a3 * pB8[2]) / temp_v0_2;
        var_v0 = 0;
        if (func_80134FB8(arg2 + (M2C_FIELD(((void *)arg1), s16 *, 6) * 8), (s32) pB4, *(s32 *)(arg3 + (M2C_FIELD(((void *)arg1), s16 *, 8) * 4))) < -0x2F00) {
            return var_v0;
        }
    }
    var_v0 = 0;
    if (func_80134FB8(arg2 + (M2C_FIELD(((void *)arg1), s16 *, 0xA) * 8), (s32) D_801909C4, *(s32 *)(arg3 + (M2C_FIELD(((void *)arg1), s16 *, 0xC) * 4))) < -0x2F00) {
        return var_v0;
    }
    var_v0 = 0;
    if (func_80134FB8(arg2 + (M2C_FIELD(((void *)arg1), s16 *, 0xE) * 8), (s32) D_801909C4, *(s32 *)(arg3 + (M2C_FIELD(((void *)arg1), s16 *, 0x10) * 4))) < -0x2F00) {
        return var_v0;
    }
    if ((arg0 << 16) < 0) {
        var_v0 = 0;
        if (func_80134FB8(arg2 + (M2C_FIELD(((void *)arg1), s16 *, 0x12) * 8), (s32) D_801909C4, *(s32 *)(arg3 + (M2C_FIELD(((void *)arg1), s16 *, 0x14) * 4))) < -0x2F00) {
            return var_v0;
        }
    }
    if (c & 1) {
        if (!(M2C_FIELD(((void *)arg1), u16 *, 0) & 0x300)) {
            goto block_14;
        }
        return 0;
    }
    temp_a1 = M2C_FIELD(((void *)arg1), u16 *, 0);
    if (!(temp_a1 & 0x200)) {
        goto block_14;
    }
    D_801EDA40 = temp_a1;
block_13:
    return 0;
block_14:
    __builtin_memcpy(D_801152A8, (void *)temp_s4, 8);
    VectorNormalSS(D_801909C8, D_801909C8);
    {
        u16 *pB8 = (u16 *)D_801909C8;
        u16 *pB4b = (u16 *)D_801909C4;
        pB4b[0] = pB4b[0] - ((pB8[0] << 0x10) >> 0x1B);
        pB4b[1] = pB4b[1] - ((pB8[1] << 0x10) >> 0x1B);
        pB4b[2] = pB4b[2] - ((pB8[2] << 0x10) >> 0x1B);
    }
    return (1);
}

--- func_80135A4C (src/ov_SC04_011/ov_SC04_011_jr_80135A4C.c:624) shares 6: D_801152A8 D_801152B0 D_801909BC D_801909C0 D_801909C4 D_801EDA40 ---
s32 func_80135A4C(s32 a0, s32 a1, s32 *a2, s32 a3) {
    typedef struct { s8 c[8]; } Blk8;
    extern s16 func_80135480(void *param_1, s32 param_2, s16 *param_3, s16 *param_4);
    extern s32 func_80135EB0(void *arg0, s32 arg1_);
    extern s32 func_80136A94(s32 a0, s32 a1, s32 a2, s32 a3);
    extern s32 func_80133AB0(s16, s16, s16, s32);
    extern u8 D_801909BC;
    extern u8 D_801909C0;
    extern s16 *D_801909C4;
    extern s16 D_801EDA3C;
    extern u16 D_801EDA40;
    extern s32 D_801EDA44;
    extern s32 D_801EDA64;
    extern u8 D_801152A8[];
    extern u8 D_801152B0;

    s32 *p;
    s32 base;
    s32 flag;
    s32 acc;
    s16 i;
    s16 eq;
    s32 ret;
    s32 frame_pad[8];
    (void)&frame_pad;

    switch (((s32 (*)(void *, s32, s16 *, s16 *))func_80135480)((void *)a0, a1, (s16 *)a2, (s16 *)a3)) {
    case 0:
        return 0;
    case 1:
        base = a0 + 0x34;
        p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000);
        flag = 0;
        break;
    case 2:
        base = a0 + 0x34;
        p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000);
        flag = 1;
        break;
    case 3:
        base = a0 + 0x34;
        p = (s32 *)&D_801EDA64;
        flag = 0;
        break;
    case 4:
        base = (s32)&D_801EDA44;
        p = (s32 *)&D_801EDA64;
        flag = 1;
        break;
    }

    if (a1 < 0) {
        if (func_80135EB0(p, -0x8000) != 0) {
            goto docall;
        }
        for (p = (s32 *)*p; p != 0; p = (s32 *)*p) {
            if (func_80135EB0(p, -0x8000) != 0) {
docall:
                func_80136A94(flag, a0, a3, base);
                return 1;
            }
        }
    } else {
        acc = 0;
        i = 0;
        *(s16 *)((*(u8 **)&D_801909BC) + 6) = -0x7FFF;
        *(s16 *)((*(u8 **)&D_801909C0) + 6) = 0x7FFF;
        D_801EDA40 = 0;
        D_801EDA3C = 0;
        eq = ((V3 *)a2)->x == ((V3 *)a3)->x && ((V3 *)a2)->y == ((V3 *)a3)->y && ((V3 *)a2)->z == ((V3 *)a3)->z;

        while (1) {
            ret = func_80133AB0(0, (s16)(*(Box **)&D_801909BC)->f0, (s16)(*(Box **)&D_801909BC)->f4, (s32)p);
            if (ret == 0) break;
            acc |= ret;
            if (eq != 0) break;
            if (i++ >= 5) return 0;
        }

        if ((s16)acc != 0 || D_801EDA3C != 0) {
            if ((*(Box **)&D_801909BC)->f6 >= -0xBCB) {
                *(Blk8 *)D_801152A8 = *(Blk8 *)&D_801152B0;
            }
            (*(Box **)&D_801909C4)->f0 = (*(Box **)&D_801909C0)->f0;
            (*(Box **)&D_801909C4)->f2 = (*(Box **)&D_801909C0)->f2;
            (*(Box **)&D_801909C4)->f4 = (*(Box **)&D_801909C0)->f4;
            goto docall;
        }
    }
    return 0;
}

--- func_80135168 (src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:2973) shares 5: D_801909BC D_801909C0 D_801909C4 D_801909C8 D_801EDA40 ---
int func_80135168(u16 arg0, u16 *p1, u16 *p2)
{
    /* [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 §100); the whole-binary byte-gate is the arbiter. */
    extern u8 D_801909BC;
    extern u8 D_801909C0;
    extern u8 D_801909C8;
    s16 *pb0;
    s16 *pac;
    s16 *pb8;
    u16 *pb4;
    u16 ax, bx, ay, by, az, bz;
    int a1v, a2v, d94;

    pb0 = (*(s16 * *)&D_801909C0);

    ax = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;
    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;

    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;
    ((H16 *)&D_801EDA40)->h = 0;
    if (func_80134A74(arg0, a1v, a2v, d94)) {
        pb4 = (*(u16 * *)&D_801909C4);
        p2[0] = pb4[0];
        p2[1] = pb4[1];
        p2[2] = pb4[2];
        p2[3] = D_801EDA40;
        return 1;
    }
    return 0;
}

