=== lever-free bodies in ov_SC03_105 sharing a callee or global with func_801834A4 (30 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_8018423C (src/ov_SC03_105/ov_SC03_105_jr_80181C84.c:4327) shares 3: D_800B99DA D_8018E59C func_801850D8 ---
void func_8018423C(s32 arg0)
{
    Vec4s16_8018423C pos;
    Vec4s16_8018423C vec;
    Vec4s16_8018423C tmp;
    Vec4s16_8018423C out;
    s32 i;
    s32 j;
    s32 k;
    s32 step;
    s32 r;

    pos.f0 = *(u16 *)(arg0 + 6);
    pos.f1 = *(u16 *)(arg0 + 0xA);
    pos.f2 = *(u16 *)(arg0 + 0xE);
    vec.f2 = 0;
    vec.f0 = 0;

    j = 0;
    do {
        i = j + 1;
        vec.f1 = -(i << 7);
        func_8012F214(arg0, (s32)&vec, (s32)&vec);
        if (func_80135004(1, &pos, (s32)&vec) != 0) {
            if ((D_800B99DA & 7) == 0) {
                step = -0x40;
                out = vec;
                for (k = 0; k < 8; k++, step += 0x10) {
                    out.f0 = vec.f0 + step;
                    r = (s16)(rand() % 0x1000 + 0x2000);
                    func_801850D8(7, r, 0, 0, &out, 0, D_8018E59C[rand() & 1], 0);
                }
            }
            return;
        }
        pos = vec;
        j = i;
    } while (i < 3);
}

--- func_80182DCC (src/ov_SC03_105/ov_SC03_105_jr_80181C84.c:3502) shares 3: D_800B99DA D_8018E59C func_801850D8 ---
void func_80182DCC(void *arg0) {
    u16 sp20[3];
    u8 *p = D_800AF630;
    s32 i, j;
    u32 base;
    s32 range1;
    s32 range2;
    s32 range3;
    s32 off;
    s32 ret;
    s32 h;

    if (D_800B99DA % 7 == 0) {
        base = 0x1400;
        i = 0;
        range1 = 0xA00;
        sp20[0] = 0x30;
        sp20[1] = 0;
        sp20[2] = 0;
        for (; i < 7; i++) {
            ret = func_801850D8(1, base + rand() % range1, 0, 0, sp20, (s32)arg0,
                                *(s32 *)(((rand() & 1) << 2) + (s32)D_8018E59C), 0);
            if (ret != 0) {
                *(s32 *)(ret + 0x20) |= 0xA00000;
            }
            sp20[0] -= 0x10;
        }
    }
    if (*(u16 *)(p + 0xA3AA) % 9 == 0) {
        base = 0x2000;
        i = 0;
        range2 = 0x1000;
        sp20[1] = 8;
        sp20[2] = 0;
        for (; i < 5; i++) {
            sp20[0] = 8;
            h = sp20[1];
            h -= 0x20;
            h -= i * 4;
            sp20[1] = h;
            for (j = 0; j < 3; j++) {
                ret = func_801850D8(1, (s16)(base + rand() % range2 + i * 0x600), 0, 0, sp20,
                                    (s32)arg0, *(s32 *)(((rand() & 1) << 2) + (s32)D_8018E59C), 0);
                if (ret != 0) {
                    *(s32 *)(ret + 0x20) |= 0xA00000;
                }
                sp20[0] -= 8;
            }
        }
        sp20[1] = 0;
        i = 0;
        range3 = base >> 1;
        off = 0x800;
        for (; i < 2; i++) {
            sp20[0] = 8;
            sp20[1] += 0x14;
            for (j = 0; j < 3; j++) {
                ret = func_801850D8(1, (s16)(base + rand() % range3 - off), 0, 0, sp20,
                                    (s32)arg0, *(s32 *)(((rand() & 1) << 2) + (s32)D_8018E59C), 0);
                if (ret != 0) {
                    *(s32 *)(ret + 0x20) |= 0xA00000;
                }
                sp20[0] -= 8;
            }
            off += 0x800;
        }
    }
}

--- func_801824CC (src/ov_SC03_105/ov_SC03_105_jr_80181C84.c:3244) shares 3: D_800B99DA D_8018E59C func_801850D8 ---
void func_801824CC(a0, a1, a2, a3, mask)
    s32 a0;
    s16 a1;
    s16 a2;
    s16 a3;
    s32 mask;
{
    Stk stk;
    Vec3x16 vec;
    s32 base;
    s32 i;
    s32 r;
    u16 *p;

    stk = *(Stk *)D_801B822C;
    base = (func_8004787C((D_800B99DA << 6) & 0x7C0) << 4) >> 12;
    if (D_800B99DA % 6 == 0) {
        vec.f2 = 0;
        for (i = 0; i < 5; i++) {
            /* LOAD-BEARING: the explicit pointer temp. Writing the two loads as
             * `*(u16 *)&stk.b[i * 4]` / `[i * 4 + 2]` inline permutes $v0/$v1 on the
             * `sll`/`addiu $sp` pair that feeds the addu. */
            p = (u16 *)&stk.b[i * 4];
            vec.f0 = base + p[0];
            vec.f1 = p[1];
            r = func_801850D8(1, (s16)(a1 + rand() % ((a1 << 16) >> 17)), a2, a3, &vec, a0,
                              D_8018E59C[rand() & 1], 0);
            if (r != 0) {
                *(s32 *)(r + 0x20) |= mask;
            }
        }
    }
    if ((D_800B99DA & 3) == 0) {
        vec.f0 = base;
        vec.f1 = 0;
        vec.f2 = 0;
        r = func_801850D8(1, (s16)(a1 + rand() % ((a1 << 16) >> 17)), a2, a3, &vec, a0,
                          D_8018E59C[rand() & 1], -0x80000);
        if (r != 0) {
            *(s32 *)(r + 0x20) |= mask;
        }
    }
    if (D_800B99DA % 5 == 0) {
        vec.f1 = -4;
        vec.f2 = 0;
        for (i = 0; i < 2; i++) {
            /* LOAD-BEARING association: `(i << 5) + (base - 0x10)`, NOT
             * `base + (i << 5) - 0x10`. The latter makes `base + i*32` a giv of
             * benefit 4 (> 2*biv_count), so strength_reduce reduces it to an extra
             * induction pseudo — which also steals the last callee-saved register and
             * pushes `mask` out of $fp into memory. Splitting the invariant off leaves
             * a bare `i<<5` giv (benefit 2 - 2 = 0 => "not worth while"), and
             * `base - 0x10` stays unhoisted inside the loop. */
            vec.f0 = (i << 5) + (base - 0x10);
            r = func_801850D8(1, (s16)(a1 + rand() % ((a1 << 16) >> 17)), a2, a3, &vec, a0,
                              D_8018E59C[rand() & 1], -0x60000);
            if (r != 0) {
                *(s32 *)(r + 0x20) |= mask;
            }
        }
    }
    if (D_800B99DA % 6 == 0) {
        vec.f1 = -0x10;
        vec.f2 = 0;
        for (i = 0; i < 2; i++) {
            vec.f0 = (i << 6) + (base - 0x20);
            r = func_801850D8(1, (s16)(a1 + rand() % ((a1 << 16) >> 17)), a2, a3, &vec, a0,
                              D_8018E59C[rand() & 1], -0x60000);
            if (r != 0) {
                *(s32 *)(r + 0x20) |= mask;
            }
        }
    }
}

--- func_801831E0 (src/ov_SC03_105/ov_SC03_105_jr_80181C84.c:3599) shares 3: D_800B99DA D_8018E59C func_801850D8 ---
void func_801831E0(s32 arg0, s32 arg1) {

    extern u16 D_801BA6A0[];
    extern u16 D_801BA5E8;
    extern u16 D_801BA5EA;
    extern u16 D_801BA5EC;
    extern s32 D_8018E59C[];
    u16 *w;
    u16 *e;
    u16 *m;
    s32 ctr;
    s32 q;
    s32 ret;
    s32 t;

    w = D_801BA6A0;
    switch (arg1) {
    case 0:
        ctr = 0x17;
        do {
            w[0] = *(u16 *)(arg0 + 6);
            w[1] = *(u16 *)(arg0 + 0xA);
            w[2] = *(u16 *)(arg0 + 0xE);
            ctr--;
            w -= 4;
        } while (ctr >= 0);
        break;
    case 1:
    case 3:
        D_801BA5E8 = *(u16 *)(arg0 + 6);
        D_801BA5EA = *(u16 *)(arg0 + 0xA);
        D_801BA5EC = *(u16 *)(arg0 + 0xE);
        ctr = 0x17;
        do {
            m = w + 1;
            e = w + 2;
            *w = *(w - 4);
            *m = *(w - 3);
            *e = *(w - 2);
            if ((D_800B99DA & 7) == 0 && (ctr & 1) != 0) {
                q = rand() % 4096;
                if ((rand() & 1) == 0) {
                    t = -q;
                    q = t + 0x4000;
                } else {
                    q = q + 0x4000;
                }
                ret = func_801850D8(5, (s16)q, 0, 0, w, 0, *(s32 *)(((rand() & 1) << 2) + (s32)D_8018E59C), 0);
                if (ret != 0) {
                    *(s32 *)(ret + 0x54) = arg1 - 1;
                    *(s32 *)(ret + 0x50) = (s32)w;
                    *(s32 *)(ret + 0x20) |= 0x200000;
                }
            }
            ctr--;
            w -= 4;
        } while (ctr > 0);
        break;
    case 2:
        ctr = 0x17;
        do {
            if ((D_800B99DA & 7) == 0 && (ctr & 1) != 0) {
                q = rand() % 4096;
                if ((rand() & 1) == 0) {
                    t = -q;
                    q = t + 0x4000;
                } else {
                    q = q + 0x4000;
                }
                ret = func_801850D8(5, (s16)q, 0, 0, w, 0, D_8018E59C[rand() & 1], 0);
                if (ret != 0) {
                    *(s32 *)(ret + 0x50) = (s32)w;
                    *(s32 *)(ret + 0x54) = arg1;
                    *(s32 *)(ret + 0x20) |= 0x200000;
                }
            }
            ctr--;
            w -= 4;
        } while (ctr > 0);
        break;
    }
}

--- func_80150FD8 (src/shared/ov/func_80150FD8.h:5) shares 1: D_800B99DA ---
void func_80150FD8(s32 a0) {
    if (D_800B99DA & 7) {
        func_80146994(0x34, a0, 0, 0);
    }
}

--- func_80172414 (src/shared/ov/func_80172414.h:6) shares 1: D_800B99DA ---
void func_80172414(s32 a0) {
    if (*(u16 *)(a0 + 0xB8) & 0x2000) {
        func_80161C24(a0, *(u16 *)(a0 + 0x16E));
    }
    if (*(s32 *)(a0 + 0x2C) < (s32)0xFFF90000) {
        if ((D_800B99DA & 7) == 0) {
            func_8014C010(a0, 2);
        }
    }
}

