oot/src/code/z_player_lib.c

#include <ultra64.h>
#include <global.h>

typedef struct {
    u8 unk_0;
    u16 unk_2;
} Struct_8008F2F8;

// TODO decompile data

extern SkeletonHeader* D_80125B70[];

extern s16 D_80125B78[];

extern u8 D_80125C44[];

extern Struct_8008F2F8 D_80125C88[];

extern u8 D_80125C98[];

extern UNK_TYPE D_80125F18[];

extern UNK_TYPE D_80125F20[];

extern UNK_TYPE D_80125F28[];

extern UNK_TYPE D_80125F30[];

extern UNK_TYPE D_80125F38[];

extern UNK_PTR D_80125F40[];

extern u8 D_8012607C[];

extern f32 D_801260D0;

extern Vec3f D_801260A4;
extern Vec3f D_801260B0;
extern Vec3f D_801260BC;
extern Vec3f D_801260C8;

extern Vec3f D_80126080;
extern Vec3f D_8012608C;
extern Vec3f D_80126098;

// TODO decompile bss

extern u8 D_80160008[]; // TODO check type

// Segment Addresses

extern LinkAnimetionEntry D_04003238;
extern UNK_TYPE D_0602A738;
extern UNK_TYPE D_0602CB48;

void func_8008E750(GlobalContext* globalCtx, Player* player) {
    s32 currentBoots;
    s16* temp_var;

    REG(27) = 0x7D0;
    REG(48) = 0x172;

    currentBoots = player->currentBoots;
    if (currentBoots == 0) {
        if (LINK_IS_CHILD) {
            currentBoots = 5;
        }
    } else if (currentBoots == 1) {
        if ((s32)(player->stateFlags1 * 0x10) < 0) {
            currentBoots = 4;
        }
        REG(27) = 0x1F4;
        REG(48) = 0x64;
    }

    temp_var = (s16*)&D_80125B78 + (currentBoots * 0x11);
    REG(19) = temp_var[0];
    REG(30) = temp_var[1];
    REG(32) = temp_var[2];
    REG(34) = temp_var[3];
    REG(35) = temp_var[4];
    REG(36) = temp_var[5];
    REG(37) = temp_var[6];
    REG(38) = temp_var[7];
    REG(43) = temp_var[8];
    REG(45) = temp_var[9];
    REG(68) = temp_var[10];
    REG(69) = temp_var[11];
    IREG(66) = temp_var[12];
    IREG(67) = temp_var[13];
    IREG(68) = temp_var[14];
    IREG(69) = temp_var[15];
    MREG(95) = temp_var[16];
    if (globalCtx->roomCtx.curRoom.unk_03 == 2) {
        REG(45) = 0x1F4;
    }
}

s32 func_8008E8DC(GlobalContext* globalCtx, Player* player) {
    return (player->stateFlags1 & 0x20000080 || player->action || globalCtx->sceneLoadFlag == 0x14 ||
            player->stateFlags1 & 1 || player->unk_692 & 0x80 ||
            (gSaveContext.unk_13F0 && func_8008F0D8(player, player->unk_154) >= 0));
}

s32 func_8008E988(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    return func_8008E8DC(globalCtx, player) || player->unk_6AD == 4;
}

s32 func_8008E9C4(Player* player) {
    return player->stateFlags1 & 0x10;
}

s32 func_8008E9D0(Player* player) {
    return LINK_IS_CHILD && player->currentShield == 2;
}

s32 func_8008E9F8(Player* player, s32 arg1) {
    s32 temp_v1 = D_80125C44[arg1];

    if (temp_v1 == 2 && func_8008E9D0(player) != 0) {
        return 1;
    } else {
        return temp_v1;
    }
}

#ifdef NON_MATCHING
// Regalloc only
void func_8008EA40(Player* player) {
    s8 temp;

    if ((s32)(player->stateFlags1 << 9) < 0) {
        temp = player->unk_154;
        if ((temp < 0) || (player->heldItemActionParam == temp)) {
            if (func_8008F1A0(player) == 0 && func_8008E9D0(player) == 0) {
                player->unk_15D = 0xA;
                player->unk_160 = gSaveContext.linkAge + D_80125F40[10];
                if (player->unk_15E == 0x12) {
                    player->unk_15E = 0x10;
                } else if (player->unk_15E == 0x13) {
                    player->unk_15E = 0x11;
                }
                player->unk_168 = gSaveContext.linkAge + D_80125F40[player->unk_15E];
                player->unk_15B = 2;
                player->unk_154 = -1;
            }
        }
    }
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008EA40.s")
#endif

#ifdef NON_MATCHING
// Regalloc, gSaveContext and D_80125F40 hi/lo pairs swapped
void func_8008EB2C(Player* player, s32 arg1) {
    player->unk_15C = D_80125C98[(arg1 * 5) + 1];
    player->unk_15D = D_80125C98[(arg1 * 5) + 2];
    player->unk_15E = D_80125C98[(arg1 * 5) + 3];
    player->unk_164 = gSaveContext.linkAge + D_80125F40[D_80125C98[(arg1 * 5) + 1]];
    player->unk_160 = gSaveContext.linkAge + D_80125F40[D_80125C98[(arg1 * 5) + 2]];
    player->unk_168 = gSaveContext.linkAge + D_80125F40[D_80125C98[(arg1 * 5) + 3]];
    player->unk_16C = gSaveContext.linkAge + D_80125F40[D_80125C98[(arg1 * 5) + 4]];
    func_8008EA40(player);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008EB2C.s")
#endif

void func_8008EC04(Player* player, s32 arg1) {
    player->unk_158 = arg1;
    if (arg1 == 1) {
        player->unk_15B = 0;
    } else {
        player->unk_15B = D_80125C98[arg1 * 5];
    }
    if (player->unk_15B < 3 && player->currentShield == 0) {
        player->unk_15B = 0;
    }
    func_8008EB2C(player, arg1);
}

void func_8008EC70(Player* player) {
    player->unk_154 = player->heldItemActionParam;
    func_8008EC04(player, func_8008E9F8(player, player->heldItemActionParam));
    player->unk_6AD = 0;
}

#ifdef NON_MATCHING
// Regalloc, ITEM_NONE immediate not reused
void func_8008ECAC(GlobalContext* globalCtx, Player* player) {
    s32 phi_v0;

    if (player->action != 0x56) {
        player->currentShield = ((gSaveContext.equips.equipment & gEquipMasks[1]) >> gEquipShifts[1]);
        player->currentTunic = (((gSaveContext.equips.equipment & gEquipMasks[2]) >> gEquipShifts[2]) - 1);
        player->currentBoots = (((gSaveContext.equips.equipment & gEquipMasks[3]) >> gEquipShifts[3]) - 1);
        if (gSaveContext.buttonStatus[EQUIP_SWORD] == ITEM_NONE) {
            player->currentSword = ITEM_NONE;
        } else {
            if (gSaveContext.equips.buttonItems[EQUIP_SWORD] == ITEM_SWORD_KNIFE) {
                phi_v0 = ITEM_SWORD_BGS;
            } else {
                phi_v0 = gSaveContext.equips.buttonItems[EQUIP_SWORD];
            }
            player->currentSword = phi_v0;
        }
        func_8008EC04(player, func_8008E9F8(player, player->heldItemActionParam));
        func_8008E750(globalCtx, player);
    }
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008ECAC.s")
#endif

void func_8008ED9C(GlobalContext* globalCtx, Player* player, s32 item, s32 arg2) {
    Inventory_UpdateBottleItem(globalCtx, item, player->heldItemCButtonIdx);
    if (item != ITEM_BOTTLE) {
        player->unk_152 = item;
        player->heldItemActionParam = arg2;
    }
    player->unk_154 = arg2;
}

void func_8008EDF0(Player* player) {
    player->unk_664 = NULL;
    player->stateFlags2 &= ~0x2000;
}

void func_8008EE08(Player* player) {
    if ((player->actor.bgCheckFlags & 1) || (player->stateFlags1 & 0x8A00000) ||
        ((player->stateFlags1 & 0xC0000) == 0 && (player->actor.posRot.pos.y - player->actor.unk_80) < 100.0f)) {
        player->stateFlags1 &= 0xBFF07FFF;
    } else if ((player->stateFlags1 & 0x2C0000) == 0) {
        player->stateFlags1 |= 0x80000;
    }
    func_8008EDF0(player);
}

#ifdef NON_MATCHING
// v1 instead of v0
void func_8008EEAC(GlobalContext* globalCtx, UNK_PTR arg1) {
    Player* player;

    player = PLAYER;
    func_8008EE08(player);
    player->unk_664 = arg1;
    player->unk_684 = arg1;
    player->stateFlags1 |= 0x10000;
    func_8005AA90(Gameplay_GetCamera(globalCtx, 0), 8, arg1);
    func_8005A444(Gameplay_GetCamera(globalCtx, 0), 2);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008EEAC.s")
#endif

s32 func_8008EF40(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    return player->stateFlags1 & 0x800000;
}

s32 func_8008EF44(GlobalContext* globalCtx, s32 arg1) {
    globalCtx->unk_11E5C = (arg1 + 1);
    return 1;
}

s32 func_8008EF5C(GlobalContext* globalCtx, Vec3f* pos, f32 radius, f32 arg3) {
    s32 pad;
    Vec3f diff;
    Player* player;

    player = PLAYER;
    if ((player->heldItemActionParam == 6) && (player->stickFlameTimer != 0)) {
        Math_Vec3f_Diff(&player->swordDimensions.tip, pos, &diff);
        return ((diff.x * diff.x) + (diff.z * diff.z)) <= (radius * radius) && 0.0f <= diff.y && diff.y <= arg3;
    } else {
        return false;
    }
}

s32 func_8008F034() {
    s32 temp_v1;

    temp_v1 = (s32)(gSaveContext.upgrades & gUpgradeMasks[2]) >> gUpgradeShifts[2];
    if (LINK_IS_ADULT) {
        return temp_v1;
    } else if (temp_v1 != 0) {
        return 1;
    } else {
        return 0;
    }
}

u8 func_8008F080(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    return player->currentMask;
}

Player* func_8008F08C(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    player->currentMask = 0;
    return player;
}

s32 func_8008F098(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    return player->currentShield == 3;
}

s32 func_8008F0AC(GlobalContext* globalCtx) {
    Player* player = PLAYER;
    return player->unk_15D == 0xa && player->currentShield == 3;
}

s32 func_8008F0D8(Player* player, s32 arg1) {
    s32 temp_v0 = arg1 - 0x15;
    if (temp_v0 >= 0 && temp_v0 < 6) {
        return temp_v0;
    }
    return -1;
}

s32 func_8008F104(Player* player) {
    return player->heldItemActionParam == 0x10 || player->heldItemActionParam == 0x11;
}

s32 func_8008F128(Player* player) {
    return func_8008F104(player) && player->heldActor == NULL;
}

s32 func_8008F158(s32 arg0) {
    s32 temp_v0 = arg0 - 2;
    if (temp_v0 > 0 && temp_v0 < 6) {
        return temp_v0;
    }
    return 0;
}

void func_8008F180(Player* player) {
    func_8008F158(player->heldItemActionParam);
}

s32 func_8008F1A0(Player* player) {
    if (player->heldItemActionParam >= 5 && player->heldItemActionParam < 8) {
        return 1;
    }
    return 0;
}

s32 func_8008F1CC(Player* player) {
    return player->heldItemActionParam == 5 && gSaveContext.bgsHitsLeft <= 0.0f;
}

s32 func_8008F224(Player* player, s32 arg1) {
    s32 temp_v0 = arg1 - 0x1E;
    if (temp_v0 >= 0 && temp_v0 < 0xD) {
        return temp_v0;
    }
    return -1;
}

void func_8008F250(Player* player) {
    func_8008F224(player, player->heldItemActionParam);
}

s32 func_8008F270(Player* player, s32 arg1) {
    s32 temp_v0 = arg1 - 0x12;
    if (temp_v0 >= 0 && temp_v0 < 2) {
        return temp_v0;
    }
    return -1;
}

s32 func_8008F29C(Player* player) {
    return func_8008F270(player, player->heldItemActionParam);
}

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008F2BC.s")

s32 func_8008F2F8(GlobalContext* globalCtx) {
    Player* player;
    Struct_8008F2F8* temp_a3;
    s32 phi_v1;

    player = PLAYER;
    if (globalCtx->roomCtx.curRoom.unk_02 == 3) {
        phi_v1 = 0;
    } else if (((s32)player->unk_840 >= 0x51) && (player->currentBoots == 1 || (s32)player->unk_840 >= 0x12C)) {
        phi_v1 = (player->currentBoots == 1 && (player->actor.bgCheckFlags & 1)) ? 1 : 3;
    } else if (((s32)player->stateFlags1 * 0x10) < 0) {
        phi_v1 = 2;
    } else {
        return 0;
    }
    if (func_8008E988(globalCtx) == 0) {
        temp_a3 = &D_80125C88[phi_v1];
        if (!temp_a3) {}
        if (temp_a3->unk_0 != 0 && !(gSaveContext.unk_13C6 & temp_a3->unk_0) &&
            ((phi_v1 == 0 && player->currentTunic != 1) ||
             ((phi_v1 == 1 || phi_v1 == 3) && player->currentBoots == 1 && player->currentTunic != 2))) {
            func_8010B680(globalCtx, temp_a3->unk_2, 0);
            gSaveContext.unk_13C6 |= temp_a3->unk_0;
        }
    }
    return phi_v1 + 1;
}

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008F470.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008F87C.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008FCC8.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80090014.s")

#ifdef NON_MATCHING
// Regalloc only
s32 func_800902F0(s32 arg0, s32 arg1, UNK_PTR** arg2, s32 arg3, s32 arg4, Player* player) {
    if (func_8008FCC8(arg0, arg1, arg2, arg3, arg4, player) == 0) {
        if (player->unk_6AD != 2) {
            *arg2 = NULL;
        } else {
            if (arg1 == 0xF) {
                *arg2 = D_80125F18[gSaveContext.linkAge];
            } else if (arg1 == 0x10) {
                *arg2 = D_80125F20[gSaveContext.linkAge];
            } else if (arg1 == 0x11) {
                *arg2 = D_80125F28[gSaveContext.linkAge];
            } else if (arg1 == 0x12) {
                *arg2 = D_80125F30[gSaveContext.linkAge];
            } else if (arg1 == 0x13) {
                *arg2 = func_8008F104(player) ? &D_0602A738 : D_80125F38[gSaveContext.linkAge];
            } else {
                *arg2 = NULL;
            }
        }
    }
    return 0;
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_800902F0.s")
#endif

s32 func_80090440(s32 arg0, s32 arg1, UNK_PTR** arg2, s32 arg3, s32 arg4, Player* player) {
    if (func_8008FCC8(arg0, arg1, arg2, arg3, arg4, player) == 0) {
        *arg2 = NULL;
    }
    return 0;
}

u8 func_80090480(GlobalContext* globalCtx, Collider* collider, Struct_80090480_arg2* arg2, Vec3f* arg3, Vec3f* arg4) {
    if (arg2->active == 0) {
        if (collider != NULL) {
            Collider_QuadSetAT(globalCtx, collider);
        }
        Math_Vec3f_Copy(&arg2->tip, arg3);
        Math_Vec3f_Copy(&arg2->base, arg4);
        arg2->active = 1;
        return 1;
    } else {
        if (arg2->tip.x == arg3->x && arg2->tip.y == arg3->y && arg2->tip.z == arg3->z && arg2->base.x == arg4->x &&
            arg2->base.y == arg4->y && arg2->base.z == arg4->z) {
            if (collider != NULL) {
                Collider_QuadSetAT(globalCtx, collider);
            }
            return 0;
        }
        if (collider != NULL) {
            func_80062734(collider, arg4, arg3, &arg2->base, &arg2->tip);
            CollisionCheck_SetAT(globalCtx, &globalCtx->colChkCtx, collider);
        }
        Math_Vec3f_Copy(&arg2->base, arg4);
        Math_Vec3f_Copy(&arg2->tip, arg3);
        arg2->active = 1;
        return 1;
    }
}

void func_80090604(GlobalContext* globalCtx, Player* player, ColliderQuad* collider, ColliderQuadDimInit* quadInit) {
    Vec3f d;
    Vec3f c;
    Vec3f b;
    Vec3f a;

    if ((s32)(player->stateFlags1 << 9) < 0) {
        player->unk_5F8 = D_8012607C[player->currentShield];
        Matrix_MultVec3f(&quadInit->quad[0], &a);
        Matrix_MultVec3f(&quadInit->quad[1], &b);
        Matrix_MultVec3f(&quadInit->quad[2], &c);
        Matrix_MultVec3f(&quadInit->quad[3], &d);
        func_80062734(collider, &a, &b, &c, &d);
        CollisionCheck_SetAC(globalCtx, &globalCtx->colChkCtx, &collider->base);
        CollisionCheck_SetAT(globalCtx, &globalCtx->colChkCtx, &collider->base);
    }
}

void func_800906D4(GlobalContext* globalCtx, Player* player, ColliderTrisItemDimInit* trisInit) {
    Vec3f sp44;
    Vec3f sp38;
    Vec3f sp2C;

    Matrix_MultVec3f(&D_801260A4, &sp2C);
    Matrix_MultVec3f(&D_801260B0, &sp38);
    Matrix_MultVec3f(&D_801260BC, &sp44);
    if (func_80090480(globalCtx, NULL, &player->swordDimensions, &trisInit->vtx[0], &sp2C) != 0 &&
        (s32)(player->stateFlags1 << 9) >= 0) {
        EffectBlure_AddVertex(Effect_GetByIndex(player->swordEffectId), &player->swordDimensions.tip,
                              &player->swordDimensions.base);
    }
    if (player->swordState > 0 && ((player->swordAnimation < 0x18) || ((s32)(player->stateFlags2 << 0xE) < 0))) {
        func_80090480(globalCtx, &player->unk_4E4, &player->unk_8D0, &trisInit->vtx[1], &sp38);
        func_80090480(globalCtx, &player->unk_564, &player->unk_8EC, &trisInit->vtx[2], &sp44);
    }
}

#ifdef NON_MATCHING
// Regalloc, single stack difference
void func_800907E4(GlobalContext* globalCtx, Player* player, Vec3f* arg2, s32 arg3) {
    f32 sp4C;
    GraphicsContext* gfxCtx;
    Gfx* dispRefs[4];
    s32 temp_at;
    f32 sp28;

    sp4C = (player->exchangeItemId != 0) ? 6.0f : 14.0f;
    gfxCtx = globalCtx->state.gfxCtx;
    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_player_lib.c", 0x961);
    gSegments[6] = PHYSICAL_TO_VIRTUAL(player->getItemModel);

    gSPSegment(gfxCtx->polyOpa.p++, 0x06, player->getItemModel);
    gSPSegment(gfxCtx->polyXlu.p++, 0x06, player->getItemModel);

    sp28 = Math_Sins(player->actor.shape.rot.y);
    Matrix_Translate((sp28 * 3.299999952316284f) + arg2->x, arg2->y + sp4C,
                     (Math_Coss(player->actor.shape.rot.y) * (3.299999952316284f + (IREG(90) / 10.0f))) + arg2->z,
                     MTXMODE_NEW);
    temp_at = globalCtx->gameplayFrames;
    Matrix_RotateZYX(0.0f, ((((globalCtx->gameplayFrames << 5) - temp_at) * 4) + temp_at) * 8, 0.0f, MTXMODE_APPLY);
    Matrix_Scale(0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, MTXMODE_APPLY);
    func_800694A0(globalCtx, arg3 - 1);
    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_player_lib.c", 0x975);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_800907E4.s")
#endif

void func_800909B4(GlobalContext* globalCtx, Player* player) {
    if ((player->unk_170 == 0) || !osRecvMesg(&player->unk_194, NULL, OS_MESG_NOBLOCK)) {
        player->unk_170 = 0;
        func_800907E4(globalCtx, player, &D_80160008, ABS(player->overheadItemId));
    }
}

void func_80090A28(Player* player, ColliderTrisItemDimInit* trisInit) {
    D_8012608C.x = D_80126080.x;
    if (player->unk_845 >= 3) {
        player->unk_845 += 1;
        D_8012608C.x *= (1.0f + ((9 - player->unk_845) * 0.10000000149011612f));
    }
    D_8012608C.x += 1200.0f;
    D_80126098.x = D_8012608C.x;
    Matrix_MultVec3f(&D_80126080, &trisInit->vtx[0]);
    Matrix_MultVec3f(&D_8012608C, &trisInit->vtx[1]);
    Matrix_MultVec3f(&D_80126098, &trisInit->vtx[2]);
}

#ifdef NON_MATCHING
// This function needs a bit of work still, but should be functionally equivalent.
// The biggest differences are in loads/stores of .data variables,
// also regalloc past Matrix_NewMtx and a minor stack difference.
void func_80090AFC(GlobalContext* globalCtx, Player* player, f32 arg2) {
    f32 sp9C;
    f32 sp98;
    Vec3f sp8C;
    Vec3f sp80;
    Vec3f sp74;
    Vec3f sp68;
    f32 sp64;
    f32 sp60;
    Gfx* dispRefs[5]; // TODO confirm size
    GraphicsContext* gfxCtx;

    D_801260D0 = 0.0f;
    Matrix_MultVec3f(&D_801260C8, &sp8C);
    D_801260D0 = arg2;
    Matrix_MultVec3f(&D_801260C8, &sp80);

    if (func_8003E188(&globalCtx->colCtx, &sp8C, &sp80, &sp74, &sp9C, 1, 1, 1, 1, &sp98) != 0) {
        gfxCtx = globalCtx->state.gfxCtx;
        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_player_lib.c", 0xA0C);

        gfxCtx->overlay.p = Gfx_CallSetupDL(gfxCtx->overlay.p, 7);

        func_800A6E10(&globalCtx->mf_11D60, &sp74, &sp68, &sp64);

        sp60 = (sp64 < 200.0f) ? 0.07999999821186066f : (sp64 / 200.0f) * 0.07999999821186066f;

        Matrix_Translate(sp74.x, sp74.y, sp74.z, MTXMODE_NEW);
        Matrix_Scale(sp60, sp60, sp60, MTXMODE_APPLY);

        gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(gfxCtx, "../z_player_lib.c", 0xA1B),
                  G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        gSPSegment(gfxCtx->overlay.p++, 0x06, globalCtx->objectCtx.status[player->actor.objBankIndex].segment);
        gSPDisplayList(gfxCtx->overlay.p++, &D_0602CB48);

        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_player_lib.c", 0xA20);
    }
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80090AFC.s")
#endif

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80090D20.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80091738.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80091880.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_80091A24.s")

#pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8009214C.s")