=== lever-free bodies in ov_SC04_011 sharing a callee or global with func_8013CF68 (5 found; top 6 by shared symbols) — read them for the SHAPE ===
--- func_8013D178 (src/ov_SC04_011/ov_SC04_011_jr_8013C98C.c:1138) shares 9: D_801F1558 D_801F1559 D_801F155A D_801F155B D_801F155C D_801F155D D_801F155E D_801F155F D_801F1560 ---
void func_8013D178(void) {

    extern u8 D_801F1558, D_801F1559, D_801F155A, D_801F155B, D_801F155C, D_801F155D, D_801F155E, D_801F155F, D_801F1560;
    extern u8 D_801F15F8, D_801F15F9, D_801F15FA, D_801F15FB, D_801F15FC, D_801F15FD, D_801F15FE, D_801F15FF, D_801F1600;

    {
        u8 *p = &D_801F1558;
        u8 v = *p, t = D_801F15F8;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F1559;
        u8 v = *p, t = D_801F15F9;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155A;
        u8 v = *p, t = D_801F15FA;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155B;
        u8 v = *p, t = D_801F15FB;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155C;
        u8 v = *p, t = D_801F15FC;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155D;
        u8 v = *p, t = D_801F15FD;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155E;
        u8 v = *p, t = D_801F15FE;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F155F;
        u8 v = *p, t = D_801F15FF;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
    {
        u8 *p = &D_801F1560;
        u8 v = *p, t = D_801F1600;
        if (v != t) { if (v < t) *p = v + 8; else *p = v - 8; }
    }
}

--- func_80144B9C (src/shared/ov/func_80144B9C.h:159) shares 6: D_800A5E8C D_800A5E90 D_800A5E94 D_800A5E95 D_800A5E96 func_80028620 ---
void func_80144B9C(void) {
    P10 *p10 = (P10 *)D_80126B58;
    P14 *p14 = (P14 *)D_80078E78;
    register u8 *p = D_800AF630;
    P18 *p18 = (P18 *)D_800AE6A8;
    P1C *p1C = (P1C *)D_80126948;
    HDR *hdr;
    ENT *ent;
    s32 tbl;
    s16 i;
    void (*calltmp)(void);
    s32 flag;

    func_80019018();
    func_80018E78();
    if (p18->f8 == 0) {
        hdr = (HDR *)func_801457A4(*(s16 *)(p + 0xA3D8));
        p18->f16 = 0;
        flag = 1;
        D_8011DB14 = p14->f3A;
        D_8011DB1C = p14->f3E;
        D_80128150 = 100;
        func_8002AB64();
    } else {
        hdr = (HDR *)func_801457A4(*(s16 *)(p + 0xA3D8));
        flag = 0;
    }
    p18->f1C = hdr->fC8;
    tbl = hdr->fC8;
    if (p18->f16 == 0xFF) {
        ent = &D_80078E50;
    } else {
        ent = (ENT *)*(s32 *)(p18->f16 * 4 + tbl);
    }
    p18->fC = ent->f8;
    p18->f14 = 0;
    p10->f4D = 0;
    if (ent->fC != (s32)D_8010F5C8) {
        p10->f198 = ent->fC;
    }
    if (*(s16 *)(p + 0xA3DA) == 0x1000 && *(s16 *)(p + 0xA3DC) == 0x1000) {
        p10->f6 = p10->f88 = p10->f90 = p18->f20;
        p10->fA = p10->f8A = p10->f92 = p18->f22;
        p10->fE = p10->f8C = p10->f94 = p18->f24;
        p10->f20->f12 = p18->f26;
        p18->f18 = 0;
    } else {
        p10->f6 = p10->f88 = p10->f90 = ent->f10;
        p10->fA = p10->f8A = p10->f92 = ent->f12;
        p10->fE = p10->f8C = p10->f94 = ent->f14;
        p10->f20->f12 = ent->f16;
    }
    p10->f154 = p10->f15C = p10->f6;
    p10->f156 = p10->f15E = p10->fA;
    p10->f158 = p10->f160 = p10->fE;
    func_80015978((void *)((s32)p10 + 4), D_80126DB0);
    D_80126DB6 = p10->f20->f12;
    if (*(s16 *)(p + 0xA3DA) == 0x1000 &&
        (*(s16 *)(p + 0xA3DC) == 0x1000 || *(s16 *)(p + 0xA3DC) == 0x2000) && flag == 0) {
        ent->f18();
        func_8012A1BC();
    } else {
        if (*(s16 *)(p + 0xA3DA) == 0x1000 && *(s16 *)(p + 0xA3DC) == 0x3000) {
            p1C->fA0 = ent->f3;
        } else {
            p1C->fA0 = 0;
        }
        ent->f18();
    }
    if (*(s16 *)(p + 0xA3D8) == 0x3069) {
        p1C->fA0 = ent->f3;
    }
    D_801151D4 = (s32)p1C;
    func_8002850C(hdr->f0, hdr->f2, hdr->f4);
    D_800A5E88 = hdr->f6;
    D_800A5E8C = hdr->f8;
    D_800A5E90 = hdr->fA;
    D_800A5E94 = hdr->fC;
    D_800A5E95 = hdr->fD;
    D_800A5E96 = hdr->fE;
    func_80028620(0, &D_800A5E88);
    D_800A5E98 = hdr->f10;
    D_800A5E9C = hdr->f12;
    D_800A5EA0 = hdr->f14;
    D_800A5EA4 = hdr->f16;
    D_800A5EA5 = hdr->f17;
    D_800A5EA6 = hdr->f18;
    func_80028620(1, &D_800A5E98);
    D_800A5EA8 = hdr->f1A;
    D_800A5EAC = hdr->f1C;
    D_800A5EB0 = hdr->f1E;
    D_800A5EB4 = hdr->f20;
    D_800A5EB5 = hdr->f21;
    D_800A5EB6 = hdr->f22;
    func_80028620(2, &D_800A5EA8);
    func_80129398();
    D_800B9AAC = hdr->f24;
    D_800B9B00 = hdr->f26;
    D_800B9AC4 = hdr->f28;
    D_800B9B18 = hdr->f2C;
    D_800B9AC8 = hdr->f30;
    D_800B9B1C = hdr->f34;
    D_800B9AB2 = hdr->f38;
    D_800B9B06 = hdr->f3A;
    D_800B9AB6 = hdr->f3C;
    D_800B9B0A = hdr->f3E;
    D_800B9ABC = hdr->f40[0];
    D_800B9ABD = hdr->f40[1];
    D_800B9ABE = hdr->f40[2];
    D_800B9B10 = hdr->f40[3];
    D_800B9B11 = hdr->f40[4];
    D_800B9B12 = hdr->f40[5];
    D_800B9ABF = hdr->f40[6];
    D_800B9AC0 = hdr->f40[7];
    D_800B9AC1 = hdr->f40[8];
    D_800B9B13 = hdr->f40[9];
    D_800B9B14 = hdr->f40[10];
    D_800B9B15 = hdr->f40[11];
    func_8012944C();
    p10->fB0 = hdr->f4C;
    p10->fCC = hdr->f50;
    p10->f1E8 = hdr->f54;
    p10->f1F0 = hdr->f58;
    D_80126728 = hdr->f5C;
    D_8011DB08 = hdr->f60;
    D_80126AEC = hdr->f64;
    p10->f19C = (s32)hdr + 0x68;
    func_801336E8(hdr->f88, hdr->f8C, hdr->f90);
    func_8013B83C(hdr->f94, hdr->f98, hdr->f9C);
    func_8013B568(hdr->fA8);
    func_800D02C0(hdr->fD4);
    func_80011E84(hdr->fD8);
    for (i = 0; i < 8; i++) {
        D_801151F0[i] = *(u8 *)((s32)hdr + i + 0xAC);
    }
    D_801274C8 = hdr->fB4;
    D_801274CC = hdr->fB8;
    D_801274D0 = hdr->fBC;
    D_801274D4 = hdr->fC0;
    D_801270B8 = hdr->fC4;
    D_80127520 = hdr->fC4;
    D_801151D8 = 0;
    D_8011DB28 = 0;
    calltmp = ent->f20;
    calltmp();
    func_8013D3D4(hdr->fA0, hdr->fA4);
    func_8002D4C8(0x1E, 0);
    if (p18->f8 == 0) {
        D_80078E50 = *ent;
    }
    p18->f4 = (s32)&D_80078E50;
    p18->f8 = p18->f8 & 0x7F000000;
    if (func_800CF854() != 0) {
        func_8001C14C();
        func_8012A110();
    }
}

--- func_801716AC (src/shared/ov/func_801716AC.h:7) shares 3: D_800A5E94 D_800A5E95 D_800A5E96 ---
s32 func_801716AC(s32 a0, void * a1, s32 * a2)
{
    s32 d;
    s32 p;
    a0 = a0 * 0x10;
    p = a0 + (s32)a1;
    d = (s16)func_80012FC8(*(u8 *)(p + 0xC), (&D_800A5E94)[a0], 10, 1);
    *a2 += d;
    *(char *)(p + 0xC) = *(u8 *)(p + 0xC) + d;
    d = (s16)func_80012FC8(*(u8 *)(p + 0xD), (&D_800A5E95)[a0], 10, 1);
    *a2 += d;
    *(char *)(p + 0xD) = *(u8 *)(p + 0xD) + d;
    d = (s16)func_80012FC8(*(u8 *)(p + 0xE), (&D_800A5E96)[a0], 10, 1);
    *a2 += d;
    *(char *)(p + 0xE) = *(u8 *)(p + 0xE) + d;
}

--- func_801596F0 (src/ov_SC04_011/ov_SC04_011_jr_801588CC.c:1391) shares 1: func_80028620 ---
s32 func_801596F0(s32 param_1) {
    u8 *base = &(*(u8 *)&D_800AF630);
    s32 v;
    u32 *p;
    u32 *q;

    v = *(s32 *)(param_1 + 0x28) - 1;
    *(s32 *)(param_1 + 0x28) = v;
    if (v == -1) {
        func_80174B6C();
        (*(s16 *)&D_800B9AAC) = 0x7fff;
        D_800B9B00 = 0x7fff;


        for (p = (u32 *)(base + 0x65A8); p < (u32 *)(base + 0x9DA8); p += 0xe) {
            p[1] |= 0x80000000;
        }

        if ((u32 *)(base + 0x2A8) < (u32 *)(base + 0x65A8)) {
            u32 orc = 0x80000000;
            u32 *ab = D_800AFAE8;
            q = (u32 *)(base + 0x2AC);
            do {
                if (q < ab + 1 || q >= ab + 0x22) {
                    *q |= orc;
                }
                q += 0x21;
            } while (q < (u32 *)(base + 0x65AC));
        }

        (*(s16 *)&D_801270C0) = 3;
        ((void (*)(s32))func_80129248)(0);
        func_8013C938();
        func_8013CB20();
        func_8013C98C();
        func_8002850C(0x800, 0x800, 0x800);
        func_80028620(0, &(*(u8 *)&D_80192838));
        func_80028620(1, &(*(u8 *)&D_80192838) + 0x10);
        func_80028620(2, &(*(u8 *)&D_80192838) + 0x20);
        *(s32 *)(param_1 + 0x28) = 0xff;
        *(u8 *)(param_1 + 0x15) = *(u8 *)(param_1 + 0x15) + 1;
    }
    return 0;
}

--- func_8013D53C (src/ov_SC04_011/ov_SC04_011_jr_8013C98C.c:1311) shares 1: D_801F1558 ---
void func_8013D53C(void *arg0v) {

    extern Rec9 D_80190D5C[];
    extern Rec12 D_80190D94[];
    extern u8 D_80078EAF;
    extern u8 D_801F15F8;
    extern s32 D_801EDAD4;
    Cmd_8013D53C *arg0 = arg0v;

    extern u8 D_80190D98[];
    extern u8 D_80190D9C[];
    extern unsigned char D_801F1558;
    extern s16 *D_801EDABC;
    extern s32 D_801EDAEC;
    extern s32 D_801EDAF0;
    extern s32 D_801EDAF4;
    s32 s0v;
    s32 t9v;
    s32 t8v;
    u8 b0, b1, b2;
    u8 pad[8];   /* dead BLKmode local: frame 0x10 -> 0x18, zero code */

    if (!(D_801EDAE0 & 1)) {
        D_801EDAC8 = 1;
    } else {
        D_801EDAC8 = D_80078EAF;
    }

    b0 = ((u8 *)D_80190D94)[D_801EDAC8 * 12];
    D_801F163A = b0;
    D_801F16AE = b0;
    b1 = D_80190D98[D_801EDAC8 * 12];
    D_801F1562 = b1;
    D_801F161C = b1;
    b2 = D_80190D9C[D_801EDAC8 * 12];
    D_801F1540 = b2;
    D_801F1561 = b2;

    (*(S9 *)&D_801F1558) = ((S9 *)D_80190D5C)[D_801EDAC8];
    (*(S9 *)&D_801F15F8) = *(S9 *)(&D_801F1540 + 0x18);  /* same addr as (*(S9 *)&D_801F1558); distinct sym defeats cse, keeps %hi/%lo */

    D_801F1620 = 1;
    D_801EDADC = -1;
    D_801EDAD8 = 0;
    D_801EDAD4 = -1;
    D_801EDAC0 = 0;
    D_801EDACC = 0;
    D_801EDAD0 = 0;

    if ((D_801EDAE0 & 2) && (D_801EDAC8 == 4)) {
        s0v = (*(s32 * *)&D_801EDAB0)[18];
        t9v = (*(s32 * *)&D_801EDAB0)[19];
        t8v = (*(s32 * *)&D_801EDAB0)[20];
    } else {
        s32 *p = (s32 *)(D_801EDAC8 * 12 + (s32) (*(s32 * *)&D_801EDAB0));  /* block-local: local-alloc ties sum into mul chain */
        s0v = p[0];
        t9v = p[1];
        t8v = p[2];
    }

    (*(Cmd_8013D53C * *)&D_801EDABC) = arg0;
    if (arg0 != 0) {
        if (D_801EDAE8 != 0) {
            s32 *p = (s32 *)(D_801EDAC8 * 12 + (s32) (*(s32 * *)&D_801EDAB8));
            D_801EDAEC = p[0];
            D_801EDAF0 = p[1];
            D_801EDAF4 = p[2];
        } else {
            while ((arg0->cmd & 0xFFFF) != 0xFF) {
                if ((arg0->cmd & 0xFFFF) == 9) {
                    s32 n;
                    s32 i;
                    u16 *src;
                    u16 *dst;
                    n = arg0->w * arg0->h;
                    i = 0;
                    src = arg0->data;
                    dst = src + n;
                    if (n > 0) {
                        do {
                            u16 px;
                            s32 r, g, b, out;
                            px = *src;
                            r = ((px & 0x1F) * s0v) / 2560;
                            g = (((px & 0x3E0) * t9v) / 2560) & 0x3E0;
                            b = (((px & 0x7C00) * t8v) / 2560) & 0x7C00;
                            out = r | g | b | (px & 0x8000);
                            if (out == 0 && px != 0) {
                                out = 0x8000;
                            }
                            *dst = out;
                            dst++;
                            do { i++; } while (0);
                            src++;
                        } while (i < n);
                    }
                }
                arg0++;
            }
        }
    }
}

