=== lever-free bodies in ov_SC03_001 sharing a callee or global with func_80189030 (126 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_8018A3A8 (src/ov_SC03_001/ov_SC03_001_jr_8018A3A8.c:3169) shares 7: D_80115126 D_80115138 D_80115148 D_801EEB10 D_801EF274 D_801F1374 func_80029124 ---
void func_8018A3A8(void) {
    /* [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_801151C8[];
    extern s16 D_801EF1E8;
    extern u8 D_800B9A15;
    extern u16 D_80115112;
    extern s32 D_801EF1E0;
    extern s32 D_80115130;
    extern s32 D_801C17F0;
    extern s16 D_801EF270;
    extern s32 D_801EF1E4;
    extern u16 D_8011511A;
    s32 s0;
    s32 pad[2];
    (void)&pad;

    D_801151D0 = *(s32 *)&D_801151C8[(u16)D_800B9A02 * 4];

    if (D_80115126 == 4) {
        if (func_801399F0(D_801EF1E4) != 0) {
            if (D_80115148[0] == 0) {
                if (D_801EF1E0 == (s32)&D_801F4334) {
                    D_801EF1E8 = 0x60;
                    D_801EF1F0 = 0;
                    D_801EF1EC = 0;
                    D_801EF1E0 = 0;
                    if (resLoad_lastId == 0x16) {
                        D_801EF270 = 1;
                        ((s32 (*)(s32))func_8001AAA0)(0x35);
                    } else {
                        D_801EF270 = 0;
                    }
                    D_80115112 = 6;
                } else {
                    D_80115112 = D_80115112 - 1;
                }
            } else {
                D_801EF1E0 = 0;
                func_8017ADE8(0x12);
                func_8002D4C8(0x46F, 0);
                D_8011511A = 0;
                D_80115112 = D_80115112 - 1;
            }

            if (D_801EF1E0 != 0) {
                D_80115130 = D_801EF1E0;
                func_80139954();
                D_801EF1E4 = func_801376E8(D_801EF1E0, (s32)&D_801C17F0);
            }
        }
    } else if (D_80115126 == 5) {
        if (D_801EF1E0 != 0) {
            if ((D_801EF28C = func_801399F0(D_801EF1E4)) != 0) {
                D_801EF1E0 = 0;
            }
        } else if ((func_800149E0(0) & 0x50) != 0 || D_801EF28C > 0) {
            switch (D_801EF274) {
            case 0:
                D_801EF274 = -1;
                break;

            case 1:
                if (D_801EF28C < 0) {
                    D_801EF1E0 = (s32)&D_801F0D18;
                } else if (D_801EF28C == 1) {
                    u16 *p = &D_80115112;
                    D_801EEB10 = 1;
                    func_80139954();
                    D_800B9A15 = 0;
                    *p = *p + 1;
                } else {
                    D_801EF274 = -2;
                }
                break;

            case 2:
                D_801EF288 = 0;
                D_801EF278 = 0;
                /* fallthrough */
            case 5:
            case 6:
                D_801EF274 = ((u16)D_801EF274 + 1) | 0x100;
                break;

            case 3:
                if (D_801EF28C == 1) {
                    D_801EF274 = (u16)D_801EF274 + 1;
                    if (D_801EF288 == 0) {
                        if (func_8018C914(-0xA) != 0) {
                            func_8002D4C8(0x472, 0);
                            D_801EF274 = 0x10C;
                            break;
                        }
                        func_8002D4C8(0x5EE, 0);
                        D_801EF278 = 0;
                        D_801EF288 = 0;
                        D_801EF27C = rand() % 9 + 3;
                        func_80139A68(D_801EF27C, 0);
                    } else {
                        func_80139A68(D_801EF27C, 0);
                        D_801EF274 = 0x106;
                        break;
                    }
                }
                D_801EF274 = ((u16)D_801EF274 + 1) | 0x100;
                break;

            case 4:
            case 12:
            case 13:
                if (D_801EF278 != 0) {
                    func_8018C914(D_801EF278);
                    func_8002D4C8(0x5EE, 0);
                }
                D_801EF274 = -1;
                break;

            case 7:
                D_801EF284 = (u16)D_801EF28C - 1;
                D_801EF280 = rand() % 13 + 1;
                func_80139A68(D_801EF280, 0);
                D_801EF274 = ((u16)D_801EF274 + 1) | 0x100;
                break;

            case 8:
            case 9:
                if (D_801EF27C == D_801EF280) {
                    D_801EF280 = rand() % 13 + 1;
                    func_80139A68(D_801EF280, 0);
                    D_801EF274 = 0x109;
                    break;
                }
                if (D_801EF284 == 0 ? D_801EF27C < D_801EF280 : D_801EF280 < D_801EF27C) {
                    if (D_801EF278 == 0) {
                        D_801EF278 = 0xA;
                    }
                    D_801EF278 = (u16)D_801EF278 * 2;
                    func_80139A68(D_801EF278, 0);
                    func_8002D4C8(0x5EE, 0);
                    if (D_801EF278 >= 0x2800) {
                        func_80029124(0x11A, 1);
                        D_801EF274 = 0x10D;
                        *(s32 *)(D_801EF258 + 4) = (s32)&D_801F1374;
                    } else {
                        s32 r;
                        D_801EF288 = (u16)D_801EF288 + 1;
                        s0 = D_801C1884[D_801EF288];
                        r = rand() % (9 - s0 * 2);
                        s0 = s0 + 3;
                        D_801EF27C = r + s0;
                        func_80139A68(D_801EF278, 0);
                        D_801EF274 = 0x10A;
                    }
                } else {
                    D_801EF278 = 0;
                    D_801EF288 = 0;
                    D_801EF274 = 0x10B;
                    func_8002D4C8(0xC62, 0);
                }
                break;

            case 10:
            case 11:
                D_801EF274 = 0x103;
                break;
            }

            if (D_801EF274 < 0) {
                func_8017ADE8(0xA);
                if (D_801EF274 == -1) {
                    func_8002D4C8(0x46F, 0);
                }
                {
                    u16 *p = &D_80115112;
                    D_801EF274 = 0;
                    *p = *p - 1;
                }
            }
            if (D_801EF274 >= 0x100) {
                s32 t = D_801EF274 & 0xFF;
                D_801EF274 = t;
                D_801EF1E0 = D_801C184C[t];
            }

            if (D_801EF1E0 != 0) {
                D_80115130 = D_801EF1E0;
                func_80139954();
                D_801EF1E4 = func_801376E8(D_801EF1E0, (s32)&D_801C17F0);
            }
        }
    } else {
        if (D_801EF1E0 != 0) {
            if (func_801399F0(D_801EF1E4) != 0) {
                D_801EF1E0 = 0;
            }
        } else if ((func_800149E0(0) & 0x50) != 0) {
            u16 idx = D_8011511A;
            if (D_80115138[idx] == 8) {
                func_8018C000(0xF, func_8014168C((s16)idx));
            }
            if (D_801EEB10 != 0) {
                func_80139954();
                D_800B9A15 = 0;
                func_8002D4C8(0x474, 0);
                D_80115112 = D_80115112 + 1;
            } else {
                func_8002D4C8(0x46F, 0);
                D_80115112 = D_80115112 - 1;
            }
        }
    }

    func_8018B238();
    func_80137B80();
}

--- func_8018B8DC (src/ov_SC03_001/ov_SC03_001_jr_8018B8DC.c:3224) shares 5: D_80115126 D_80115148 D_801EB58C D_801EF254 func_800291B4 ---
s32 func_8018B8DC(s32 param_1, s32 param_2) {
    extern void *func_8018C89C(s32 a0);
    extern u8 D_801117EC[];
    extern u8 * D_801EF1D4;
    extern u8 * D_801EF1DC;
    extern u8 D_801EF298[];
    extern u8 D_8018E5C0[];
    extern void * D_8018E680[];
    extern void * D_801EB58C[];
    extern void * D_801C17B4[];
    extern void * D_801C17D0[];
    extern s32 * D_801EF254[];
    extern s16 D_8010EDEE;
    extern u8 D_8010EDF2;
    extern s16 D_800A6586[];
    extern u8 D_801F0700[];
    extern u8 D_801F0B80[];
    extern u8 D_801F44B4[];
    extern u8 D_801F44E0[];
    extern u8 D_801F44F8[];
    extern u8 D_801F4524[];

    /* [T51] scoped in: these must not constrain the rest of the TU (cookbook §103). */

    void *result;

    result = D_801117EC;
    switch ((short)param_1) {
    case 10:
        if (D_80115126 != 5) {
            result = D_8018E680[D_801EF1D4[(short)param_2]];
        } else {
            result = D_801C17B4[(short)param_2];
        }
        break;

    case 7: {
        s32 t = func_800291B4(D_8018E5C0[(short)param_2]) & 0xFF;
        if (t != 0) {
            s32 idx = t * 0xC;
            if (*(s16 *)((u8 *)&D_8010EDEE + idx) != 0 &&
                D_80115126 == *((u8 *)&D_8010EDF2 + idx)) {
                result = func_8018C89C(((short)param_2 & 3) + 6);
                func_80139A68(*(s16 *)((u8 *)&D_8010EDEE + idx), 0);
            } else {
                result = func_8018C89C(5);
            }
        }
        break;
    }

    case 8:
        if (D_80115148[0] != 0) {
            s32 t = func_800291B4(D_8018E5C0[(short)param_2]) & 0xFF;
            if (t != 0) {
                s32 idx = t * 0xC;
                if (*(s16 *)((u8 *)&D_8010EDEE + idx) != 0 &&
                    D_80115126 == *((u8 *)&D_8010EDF2 + idx)) {
                    result = func_8018C89C(((short)param_2 & 3) + 6);
                    func_80139A68(*(s16 *)((u8 *)&D_8010EDEE + idx), 0);
                } else {
                    result = func_8018C89C(5);
                }
            }
        } else {
            s32 t = func_800291B4(D_8018E5C0[(short)param_2]) & 0xFF;
            if (t != 0) {
                result = D_8018E680[t];
            }
        }
        break;

    case 13: {
        s32 e = D_801EF1DC[(short)param_2];
        if ((func_800291B4(e + 0x62) & 0x80) != 0) {
            result = D_801EB58C[e];
        }
        break;
    }

    case 14: {
        u8 v = D_801EF298[(short)param_2];
        if (v != 0xFF) {
            s32 code;
            v = v + 1;
            code = v + 0x62;
            if ((func_800291B4(code) & 0xF0) == 0xC0) {
                result = func_8018C89C(((short)param_2 & 1) | 6);
                func_80139A68((s16)(D_800A6586[v] * 9 / 10), 0);
            } else if ((func_800291B4(code) & 0xF0) == 0xE0) {
                result = D_801F0700;
            }
        }
        break;
    }

    case 11:
        if (D_80115126 == 4) {
            if (D_80115148[0] == 0) {
                result = D_801F44B4;
                if (D_801EF254[(short)param_2] == 0) {
                    result = D_801C17D0[(short)param_2];
                }
            } else {
                s32 *p = D_801EF254[(short)param_2];
                if (p != 0) {
                    result = D_801F4524;
                    if (p[1] != 0) {
                        result = D_801F44F8;
                    }
                } else {
                    result = D_801F44E0;
                }
            }
        } else {
            if (D_801EF254[(short)param_2] != 0) {
                result = D_801F0B80;
            }
        }
        break;

    default:
        result = func_8018C89C(0);
        break;
    }
    return (s32)result;
}

--- func_8013E83C (src/ov_SC03_001/ov_SC03_001_jr_8013C98C.c:1839) shares 4: D_80115118 D_80115158 D_8011515A func_80029178 ---
void func_8013E83C() {
    extern void func_80141C0C(int);
    extern unsigned short D_80115118;
    extern unsigned short D_80115128;
    extern unsigned short D_8011512E;
    extern unsigned int D_80115130;
    extern unsigned short D_80115158;
    extern unsigned short D_8011515A;
    extern unsigned short D_8011515C;
    extern unsigned short D_8011515E;
    extern unsigned short D_80115162;
    extern unsigned short D_80115166;
    extern void * D_801ED488;
    extern void * D_801ED48C;
    extern unsigned char D_8018E524;
    extern unsigned char D_8018E53C;
    extern unsigned char D_8018E5B0;
    extern unsigned char D_8018E5B8;


    D_80115118 = 0;
    D_80115130 = 0;
    if (D_8011511A >= 4) {
        D_8011511A = D_8011511A - 3;
    }
    D_80115158 = 0x106;

    if ((((int(*)(int))func_80029178)(0x1c) & 0xFF) == 0) {
        D_801ED488 = &D_8018E524;
        D_801ED48C = &D_8018E5B0;
    } else {
        D_801ED488 = &D_8018E53C;
        D_801ED48C = &D_8018E5B8;
    }

    D_8011515A = 0x104;
    D_8011515C = 0x104;
    D_8011515E = 0x129;
    D_80115162 = 0x103;
    D_80115166 = 0x105;
    D_80115128 = 0;
    D_8011512E = 0;

    if (D_80115110 == 3) {
        ((void(*)(int, int))func_8002D4C8)(0x46e, 0);
    } else {
        func_80141C0C(0);
    }
}

--- func_801418F8 (src/ov_SC03_001/ov_SC03_001_jr_80140608.c:1386) shares 4: D_80115118 D_80115158 D_8011515A func_80029178 ---
void func_801418F8(void)
{

    extern s16 D_8011512E;
    extern u8 D_80115158[];
    extern s16 D_8011515A;
    extern u8 D_8011515C;
    extern s16 D_8011515E;
    extern s16 D_80115162;
    extern s16 D_80115166;
    extern u8  D_8018E524;
    extern u8  D_8018E53C;
    extern u8  D_8018E5B0;
    extern u8  D_8018E5B8;
    extern void *D_801ED488;
    extern void *D_801ED48C;
    u16 t;

    func_800D24A0(1);
    D_8011511A = 2;
    t = D_8011511A;
    (*(s16 *)&D_80115118) = 0;
    D_80115130 = 0;
    if (t >= 4) {
        D_8011511A = t - 3;
    }
    (*(s16 *)D_80115158) = 0x106;
    if ((func_80029178(0x1C) & 0xFF) == 0) {
        D_801ED488 = &D_8018E524;
        D_801ED48C = &D_8018E5B0;
    } else {
        D_801ED488 = &D_8018E53C;
        D_801ED48C = &D_8018E5B8;
    }
    D_8011515A = 0x104;
    (*(s16 *)&D_8011515C) = 0x104;
    D_8011515E = 0x129;
    D_80115162 = 0x103;
    D_80115166 = 0x105;
    D_80115128 = 0;
    D_8011512E = 0;
    if (D_80115110 == 3) {
        func_8002D4C8(0x46E, 0);
    } else {
        func_80141C0C(0);
    }
    D_80115128 = 1;
    D_8018E884 = 0xE;
    D_8018E886 = 3;
    D_80115112 = D_80115112 + 1;
}

--- func_8018B644 (src/ov_SC03_001/ov_SC03_001_jr_8018A3A8.c:3994) shares 4: D_80115140 D_80115158 D_801EF290 func_800291B4 ---
s32 func_8018B644(void *arg0, s32 arg1, s32 arg2, s32 arg3, s32 *arg4) {

    extern s32 func_800291B4(s32 arg);

    extern u8  D_80115140[];
    extern u8  D_80115158[];
    extern u8  D_80115159[];
    extern u8  D_8018E5C0[];
    extern u8  D_801EF290[];
    extern u8  D_801EF298[];
    extern s32 D_8010EDE8[];
    extern s32 D_8010F468[];
    extern s32 D_801C12E8;

    s32 ret;
    s32 n;
    u16 mode;

    *arg4 = 0x808080;
    n = D_80115159[(s16)arg2 * 2];
    n = n * D_80115158[(s16)arg2 * 2];
    ret = 0;
    mode = arg1 + 0;

    switch ((s16)arg1) {                                  /* jtbl_801E597C */
    case 10:
    case 11:
    case 13: {
        s32 j = arg3 + D_80115140[(s16)arg2];
        if ((s16)arg3 < 6 && (s16)j < (s16)n) {
            ret = ((s32 *)arg0)[(s16)j];
        }
        break;
    }

    case 12: {
        s32 j = arg3 + D_80115140[(s16)arg2];
        if ((s16)arg3 < 6 && (s16)j < (s16)n) {
            ret = ((s32 *)arg0)[D_801EF290[(s16)j]];
        }
        break;
    }

    case 7:
    case 8: {
        s16 v1 = (s16)arg3;
        if (v1 < 0xC) {
            s32 t = func_800291B4(D_8018E5C0[v1]) & 0xFF;
            if (t == 0) {
                return 1;
            }
            ret = D_8010EDE8[t * 3];
        }
        break;
    }

    case 14: {
        s32 j = arg3 + D_80115140[(s16)arg2];
        if ((s16)arg3 < 6 && (s16)j < (s16)n) {
            s32 k = D_801EF298[(s16)j];
            s32 c = k + 0x63;
            if (k < 0 || (func_800291B4(c) & 0x40) == 0) {
                ret = D_801C12E8;
            } else {
                s32 e = k + 1;
                ret = D_8010F468[e * 2];
                n = func_800291B4(c);
                if (n & 0x20) {
                    *arg4 = 0x804040;
                }
            }
        }
        break;
    }

    default: {
        s32 v1 = (s16)arg3;
        s32 ok = ((s16)mode == 5) ? (v1 < 4) : (v1 < 3);
        if (ok) {
            ret = ((s32 *)arg0)[(s16)arg3];
        }
        break;
    }
    }

    return ret;
}

--- func_8013E6AC (src/ov_SC03_001/ov_SC03_001_jr_8013C98C.c:1798) shares 3: D_80115140 D_80115148 func_80029504 ---
void func_8013E6AC(void) {
    short i;

    func_8013E83C();
    D_8011511A = 0;
    D_80115124 = D_80078EC0;
    for (i = 0; i < 8; i++) {
        *(s16 *)((char *)&D_80115148 + (i << 1)) = 0;
        D_80115140[i] = 0;
    }
    if (!((u32)func_80029504() < 5 || currentLocationId == 0x302A || currentLocationId == 0x3073)) {
        s32 *ep;
        s32 *fp;
        fp = (s32 *)&D_80115110;
        ep = (s32 *)&D_8018E8AC;
        for (i = 0; i < 5; i++) {
            s32 *fa;
            s32 v;
            fa = (s32 *)(i * 4 + (s32)fp);
            v = ep[i] * 3 >> 2;
            fa[0x16] = v;
            *(s32 *)((char *)&D_80115188 + (i << 2)) = v;
        }
        D_8018E884 = 2;
        D_8018E886 = 1;
        { u16 *q = &D_80115112; *q += 1; }
    } else {
        func_8013E83C();
        D_8011511A = 7;
        D_8018E886 = 0;
        D_8018E884 = 0;
        D_80115112 = 6;
    }
}

