=== lever-free bodies in ov_SC03_110 sharing a callee or global with func_801800F0 (52 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_8012FB54 (src/shared/ov/func_8012FB54.h:7) shares 2: func_8002D4C8 func_80143B6C ---
void func_8012FB54(s32 a0) {
    s32 s0 = a0;
    s32 v1;
    s32 p;
    if ((*(s32 *)(s0 + 0xB4) & 0x10000) != 0) {
        *(s32 *)(s0 + 0x4) = *(s32 *)(s0 + 0x4) + *(s32 *)(s0 + 0x10);
        *(s32 *)(s0 + 0x8) = *(s32 *)(s0 + 0x8) + *(s32 *)(s0 + 0x14);
        *(s32 *)(s0 + 0xC) = *(s32 *)(s0 + 0xC) + *(s32 *)(s0 + 0x18);
        v1 = *(s32 *)(s0 + 0x1C) - 1;
        *(s32 *)(s0 + 0x1C) = v1;
        if (v1 == 0) {
            func_801319E0(s0);
        } else {
            p = func_80143B6C(s0, 1);
            if (p != 0) {
                *(s16 *)(p + 0xA) = *(u16 *)(p + 0xA) + *(u16 *)(s0 + 0xAC);
            }
            if (*(s32 *)(s0 + 0x1C) == 0x13) {
                func_8002D4C8(0x8F2, 0);
            }
        }
    }
    func_80131CA8(s0, 0x36);
}

--- func_801818A8 (src/ov_SC03_110/ov_SC03_110_jr_8017FBC8.c:3939) shares 2: func_8002D4C8 func_8012CBF4 ---
void func_801818A8(s32 a0) {

    extern u8 D_8019C7A0[];
    s32 sp10[2];
    s32 t;
    s32 u;

    switch (*(u16 *)(a0 + 0x34)) {
    case 0:
        if (((s32 (*)(s32))func_8012CBF4)(a0)) {
            *(s32 *)(a0 + 0x1C) = 0x1E;
            *(s16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0;
            *(s16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1;
        } else if (*(s16 *)(a0 + 0x100) < *(s16 *)(a0 + 0xA)) {
            *(s16 *)(a0 + 0xA) = *(s16 *)(a0 + 0x100);
            *(s32 *)(a0 + 0x1C) = 0x1E;
            *(s16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0;
            *(s16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1;
        }
        break;
    case 1:
        t = func_8012B8E4(a0, 6);
        *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) =
            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + t;
        if (func_8012BEE8(a0)) {
            if (rand() & 1) {
                *(s16 *)(a0 + 0x2) = 1;
            } else {
                *(s16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1;
                func_8012B200((void *)a0);
                *(s32 *)(a0 + 0x1C) = 0x20;
                func_8002D4C8(0x6FF, 0);
            }
        }
        break;
    case 2:
        func_80181BF0(sp10, a0, (s32)D_8019C7A0);
        u = sp10[0];
        *(s16 *)(*(s32 *)(a0 + 0x20) + 0x10) = u;
        *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) = u >> 16;
        func_8012B178(a0, *(s32 *)(a0 + 0xE4) + 0xFFF80000);
        func_8012CBF4(a0);
        if (func_80181BC4(a0) == 1) {
            *(s16 *)(a0 + 0x2) = 1;
        } else if (func_8012BEE8(a0)) {
            *(s16 *)(a0 + 0x2) = 1;
        }
        break;
    default:
        *(s16 *)(a0 + 0x2) = 1;
        break;
    }
}

--- func_8017FBC8 (src/ov_SC03_110/ov_SC03_110_jr_8017FBC8.c:2745) shares 2: func_8012CBF4 func_80143B6C ---
void func_8017FBC8(s32 param_1)
{
    extern void func_80180C40(void *a0);
    extern s32 func_8012CBF4(s32 a0);
    extern s32 func_8012CBA4(s32 a0);
    extern s32 func_8012CBCC(s32 a0);
    extern s32 func_8012D624(s32 a0, s32 a1, s32 a2);
    extern void func_8012B2CC(s32 a0);
    extern void func_8012B178(s32 a0, s32 a1);
    extern void func_8012B23C(s32 a0);
    extern s32 func_80143B6C(s32 a0, s32 a1);
    extern void func_80131E00(s32 a0, s32 a1);
    extern u16 D_80126B96;
    extern s16 D_80126B9A;

    s32 iVar1;
    s16 cond;

    if (*(s16 *)(param_1 + 0xa) >= 0x10) {
        func_80180C40((void *)param_1);
        return;
    }

    switch (*(u16 *)(param_1 + 0x34)) {
    case 0:
        iVar1 = func_8012CBF4(param_1);
        if ((iVar1 & 0xff) == 0x1a) {
            goto EXIT_808B4;
        }
        if ((iVar1 & 0x4000) != 0) {
            goto STATE4;
        }
        if (func_8012D624(param_1, 0x20, 5) == 1) {
            D_80126B96 = 0x11;
            D_80126B9A = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12);
            *(s32 *)(param_1 + 0x48) = 0x18000;
            *(u16 *)(param_1 + 0x34) += 1;
            *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) =
                *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + 0x800;
            func_8012B2CC(param_1);
            func_8012B178(param_1, 0xFFF00000);
            goto TAIL;
        }
        if (*(s32 *)(param_1 + 0x14) < 0) {
            /* the barrier keeps [0xa] live across the [0xfe] load so local-alloc
             * hands it $v0 (see the header note); without it the two lh regs swap. */
            s32 ta = *(s16 *)(param_1 + 0xa);
            cond = ta < *(s16 *)(param_1 + 0xfe);
        } else {
            cond = *(s16 *)(param_1 + 0xa) > *(s16 *)(param_1 + 0xfe);
        }
        if (cond) {
            *(s32 *)(param_1 + 0x48) = 0x18000;
            *(u16 *)(param_1 + 0x34) += 1;
        }
        *(s32 *)(param_1 + 0x1c) += 1;
        goto TAIL;

    case 1:
        iVar1 = func_8012CBF4(param_1);
        if ((iVar1 & 0xff) == 0x1a) {
            goto EXIT_808B4;
        }
        if ((iVar1 & 0x2000) != 0) {
            *(u16 *)(param_1 + 0x34) += 1;
            *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0;
            *(s32 *)(param_1 + 0x1c) = 0;
            goto TAIL;
        }
        if ((iVar1 & 0x4000) == 0) {
            goto L_B88;
        }
        goto STATE4;

    case 2:
        *(s32 *)(param_1 + 0x10) = *(s32 *)(param_1 + 0x10) * 15 / 16;
        *(s32 *)(param_1 + 0x18) = *(s32 *)(param_1 + 0x18) * 15 / 16;
        iVar1 = func_8012CBA4(param_1);
        if ((iVar1 & 0xff) == 0x1a) {
            goto EXIT_808B4;
        }
        if ((iVar1 & 0x6000) == 0) {
            *(s32 *)(param_1 + 0x1c) = 0;
            *(u16 *)(param_1 + 0x34) += 1;
            goto TAIL;
        }
        if (*(s32 *)(param_1 + 0x1c) % 3 == 0) {
            func_80143B6C(param_1, 1);
        }
        *(s32 *)(param_1 + 0x1c) += 1;
        if (*(s32 *)(param_1 + 0x1c) < 0x10) {
            goto TAIL;
        }
        goto SET_HIT;

    case 3:
        iVar1 = func_8012CBCC(param_1);
        if ((iVar1 & 0xff) == 0x1a) {
            goto EXIT_808B4;
        }
        if ((iVar1 & 0x4000) == 0) {
            goto L_AF8;
        }
    STATE4:
        func_8012B23C(param_1);
        *(u16 *)(param_1 + 0x34) = 4;
        *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0;
        goto TAIL;
    L_AF8:
        if ((iVar1 & 0x2000) == 0) {
            goto L_B88;
        }
        *(s16 *)(param_1 + 2) = 1;
        func_80143B6C(param_1, 1);
        goto TAIL;

    case 4:
        if (*(s32 *)(param_1 + 0x1c) % 3 == 0) {
            func_80143B6C(param_1, 1);
        }
        iVar1 = func_8012CBA4(param_1);
        if ((iVar1 & 0xff) != 0x1a) {
            goto L_B78;
        }
    EXIT_808B4:
        func_80180C40((void *)param_1);
        return;
    L_B78:
        if ((iVar1 & 0x2000) == 0) {
            goto L_B88;
        }
    SET_HIT:
        *(s16 *)(param_1 + 2) = 1;
        goto TAIL;
    L_B88:
        *(s32 *)(param_1 + 0x1c) += 1;
        if (*(s32 *)(param_1 + 0x1c) >= 0x3c) {
            func_80131E00(param_1, 0xd);
        }
    }
TAIL:
    if (0x100000 < *(s32 *)(param_1 + 0x14)) {
        *(s32 *)(param_1 + 0x14) = 0x100000;
    }
}

--- func_80131340 (src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c:1432) shares 2: func_8012CBF4 func_80143B6C ---
void func_80131340(s32 a0)
{
    /* 8-byte, align-2 vector: align < 4 is what makes the assignments unaligned
     * (lwl/lwr + swl/swr) block moves. Block-scope so the body stays self-contained
     * for the dedup_propagate lift (§28-#1) and cannot collide with the TU's `M8`. */
    struct V8 {
        u16 vx, vy, vz, pad;
    };
    extern struct V8 D_80182224;
    /* BLOCK-scope, mirroring the already-matched func_801312D0's decl at TU L1619: the
     * later DEFINE_func_80131AC8() (TU L1964, AFTER this slot) redeclares func_80131CF4
     * with the stale 1-arg engine_core canonical. A file-scope `extern int
     * func_80131CF4(int,int);` here is a HARD `conflicting types` against it (cc1 rc=33,
     * measured); block-scope goes out of scope before that macro and compiles clean. */
    extern int func_80131CF4(int, int);

    struct V8 sp10;
    struct V8 sp18;
    struct V8 sp20;
    struct V8 sp28;
    s32 temp;
    s32 var_a1;

    if (*(s16 *)(a0 + 0xA) >= 0x10) {
        func_801319E0(a0);
        return;
    }

    temp = func_80131CF4(*(s32 *)(a0 + 0xBC), 0x2E);
    if (temp != 0) {
        sp10.vz = 0;
        sp10.vx = 0;
        sp10.vy = temp;
    } else {
        sp10 = D_80182224;
    }

    if (*(s32 *)(a0 + 0x10) != 0 || *(s32 *)(a0 + 0x18) != 0) {
        var_a1 = func_80131CF4(*(s32 *)(a0 + 0xBC), 0x19);
        if (var_a1 == 0) {
            var_a1 = 0x50;
        }
        func_8012DBD0(a0, var_a1,
                      *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800, 0x1D);
    }

    switch (*(u8 *)(a0 + 0xC2)) {
    case 0:
    case 1:
        if (*(s32 *)(a0 + 0xC4) & 4) {
            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) -= 0x100;
        }
        *(s32 *)(a0 + 0x1C) += 1;
        if (*(s32 *)(a0 + 0x1C) >= 0x3D) {
            func_80131E00(a0, 0xD);
            return;
        }
        if (*(u8 *)(a0 + 0xC2) == 0) {
            *(u8 *)(a0 + 0xC2) = 1;
            sp18.vx = *(u16 *)(a0 + 0x3A);
            sp18.vy = *(u16 *)(a0 + 0x3E);
            sp18.vz = *(u16 *)(a0 + 0x42);
            sp20 = sp18;
            sp20.vx += sp10.vx;
            sp20.vy += sp10.vy;
            sp20.vz += sp10.vz;
            sp28 = sp20; /* load-bearing dead aggregate copy — gcc-2.7.2 has no aggregate DSE */
            func_8012CEB0((s32)&sp18, (s32)&sp20, 1);
            sp20.vx -= sp10.vx;
            sp20.vy -= sp10.vy;
            sp20.vz -= sp10.vz;
            *(u16 *)(a0 + 0x3A) = sp20.vx;
            *(u16 *)(a0 + 0x3E) = sp20.vy;
            *(u16 *)(a0 + 0x42) = sp20.vz;
            *(u16 *)(a0 + 0x6) = sp20.vx;
            *(u16 *)(a0 + 0xA) = sp20.vy;
            *(u16 *)(a0 + 0xE) = sp20.vz;
        }
        D_801A0DD0 = ((s32 (*)(s32, s32))func_8012CC64)(a0, (s32)&sp10);
        if (D_801A0DD0 & 0x8000) {
            *(s32 *)(a0 + 0x18) = 0;
            *(s32 *)(a0 + 0x10) = 0;
        }
        if (D_801A0DD0 & 0x4000) {
            func_8012B23C(a0);
            *(u8 *)(a0 + 0xC2) = 4;
        } else if (D_801A0DD0 & 0x2000) {
            if (func_80131D68(a0, D_801A0DD0) == 1) {
                return;
            }
            *(u8 *)(a0 + 0xC2) = 2;
            func_80143B6C(a0, 1);
            *(s32 *)(a0 + 0x14) = 0xFFF30000;
            *(s32 *)(a0 + 0x1C) = 0;
        } else if (D_801A0DD0 & 0x8000) {
            *(u8 *)(a0 + 0xC2) = 2;
            *(s32 *)(a0 + 0x1C) = 0;
            *(s32 *)(a0 + 0x18) = 0;
            *(s32 *)(a0 + 0x10) = 0;
        }
        break;

    case 2:
        if (*(s32 *)(a0 + 0xC4) & 4) {
            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) -= 0x100;
        }
        *(s32 *)(a0 + 0x1C) += 1;
        if (*(s32 *)(a0 + 0x1C) >= 0x3D) {
            func_80131E00(a0, 0xD);
            return;
        }
        D_801A0DD4 = *(s32 *)(a0 + 0x14);
        D_801A0DD0 = ((s32 (*)(s32, s32))func_8012CC64)(a0, (s32)&sp10);
        if (D_801A0DD0 & 0x8000) {
            *(s32 *)(a0 + 0x18) = 0;
            *(s32 *)(a0 + 0x10) = 0;
        }
        if (D_801A0DD0 & 0x4000) {
            func_8012B23C(a0);
            *(u8 *)(a0 + 0xC2) = 4;
        } else if (D_801A0DD0 & 0x2000) {
            if (func_80131D68(a0, D_801A0DD0) == 1) {
                return;
            }
            func_80143B6C(a0, 1);
            /* MUST precede the 0x1C/0xC2 stores — see the header note on the /3 block. */
            *(s32 *)(a0 + 0x14) = (-D_801A0DD4) / 3;
            *(s32 *)(a0 + 0x1C) = 0;
            *(u8 *)(a0 + 0xC2) = 3;
            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0;
        } else if (D_801A0DD0 & 0x8000) {
            *(u8 *)(a0 + 0xC2) = 3;
            *(s32 *)(a0 + 0x1C) = 0;
            *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0;
            *(s32 *)(a0 + 0x18) = 0;
            *(s32 *)(a0 + 0x10) = 0;
        }
        break;

    case 3:
        *(s32 *)(a0 + 0x10) = *(s32 *)(a0 + 0x10) * 15 / 16;
        *(s32 *)(a0 + 0x18) = *(s32 *)(a0 + 0x18) * 15 / 16;
        if (*(u8 *)(a0 + 0xC3) & 1) {
            D_801A0DD0 = ((s32 (*)(s32))func_8012CBA4)(a0);
            if (D_801A0DD0 & 0x8000) {
                *(s32 *)(a0 + 0x18) = 0;
                *(s32 *)(a0 + 0x10) = 0;
            }
            if (func_80131D68(a0, D_801A0DD0) == 1) {
                return;
            }
            if (!(D_801A0DD0 & 0x6000)) {
                func_80131E00(a0, 0xD);
                return;
            }
        } else {
            D_801A0DD0 = ((s32 (*)(s32))func_8012CBF4)(a0);
            if (D_801A0DD0 & 0x8000) {
                *(s32 *)(a0 + 0x18) = 0;
                *(s32 *)(a0 + 0x10) = 0;
            }
            if (D_801A0DD0 & 0x4000) {
                func_8012B23C(a0);
                *(u8 *)(a0 + 0xC2) = 4;
                break;
            } else if (D_801A0DD0 & 0x2000) {
                if (func_80131D68(a0, D_801A0DD0) == 1) {
                    return;
                }
                *(u8 *)(a0 + 0xC3) |= 1;
            } else if (D_801A0DD0 & 0x8000) {
                *(s32 *)(a0 + 0x18) = 0;
                *(s32 *)(a0 + 0x10) = 0;
            }
        }
        if ((*(s32 *)(a0 + 0x1C) & 3) == 3) {
            func_80143B6C(a0, 1);
        }
        *(s32 *)(a0 + 0x1C) += 1;
        if (*(s32 *)(a0 + 0x1C) < 0x11) {
            break;
        }
        if (!(D_801A0DD0 & 0x6000)) {
            func_80131E00(a0, 0xD);
            return;
        }
        /* polarity MUST match case 4's — see the cross-jump note in the header. */
        if (*(s16 *)(a0 + 0x76) <= 0) {
            func_80131E00(a0, 6);
        } else {
            func_80131C78(a0);
        }
        break;

    case 4:
        D_801A0DD0 = ((s32 (*)(s32))func_8012CBA4)(a0);
        if (D_801A0DD0 & 0x8000) {
            *(s32 *)(a0 + 0x18) = 0;
            *(s32 *)(a0 + 0x10) = 0;
        }
        if (D_801A0DD0 & 0x2000) {
            if (func_80131D68(a0, D_801A0DD0) == 1) {
                return;
            }
            if (*(s16 *)(a0 + 0x76) <= 0) {
                func_80131E00(a0, 6);
            } else {
                func_80131C78(a0);
            }
        } else {
            if ((*(s32 *)(a0 + 0x1C) & 3) == 3) {
                func_80143B6C(a0, 1);
            }
            *(s32 *)(a0 + 0x1C) += 1;
            if (*(s32 *)(a0 + 0x1C) >= 0x3D) {
                func_80131E00(a0, 0xD);
                return;
            }
        }
        break;
    }

    func_80131CA8(a0, 0x2F);
}

--- func_80141C0C (src/ov_SC03_110/ov_SC03_110_jr_80140608.c:1508) shares 1: func_8002D4C8 ---
void func_80141C0C(s32 param_1)
{
    func_8002D4C8(*(u16 *)(&D_801830C0 + (((param_1 << 16) >> 15) + (u32)D_80115110) * 2), 0);
}

--- func_80145BF8 (src/shared/ov/func_80145BF8.h:7) shares 1: func_8002D4C8 ---
void func_80145BF8(void) {
    func_8002D4C8(0x21, func_80028FBC() & 0xFFFF);
    func_8002D4C8(0x22, func_80029000() & 0xFFFF);
    func_8002D4C8(func_80028D9C() == 0 ? 0xC : 0xB, 0);
}

